text stringlengths 4 690k |
|---|
{-# OPTIONS --cubical --safe #-}
module Path where
open import Cubical.Foundations.Everything
using ( _≡_
; sym
; refl
; subst
; transport
; Path
; PathP
; I
; i0
; i1
; funExt
; cong
; toPathP
; cong₂
; ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Fin Literals
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Fin.Literals where
open import Agda.Builtin.FromNat
open import Data.Nat usi... |
------------------------------------------------------------------------
-- A theorem related to pointwise equality
------------------------------------------------------------------------
-- To simplify the development, let's work with actual natural numbers
-- as variables and constants (see
-- Atom.one-can-restrict... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Machine words
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Word where
----------------------------------------------------------------... |
module examplesPaperJFP.SpaceShipCell where
open import SizedIO.Base
open import StateSizedIO.GUI.BaseStateDependent
open import Data.Bool.Base
open import Data.List.Base
open import Data.Integer
open import Data.Product hiding (map)
open import SizedIO.Object
open import SizedIO.IOObject
open import NativeIO
ope... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of interleaving using setoid equality
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (Setoid)
module Da... |
module Algebra.Linear.Category.Vect where
|
module Issue309a where
data D : Set where
d : D → D
syntax d x x = e x
g : D → D
g (d x) = e x
|
{-# OPTIONS --rewriting #-}
data _≡_ {ℓ} {A : Set ℓ} (x : A) : A → Set ℓ where
instance refl : x ≡ x
{-# BUILTIN REWRITE _≡_ #-}
postulate
admit : ∀ {ℓ} {A : Set ℓ} → A
X : Set
postulate
Wrap : Set → Set
wrap : {A : Set} → A → Wrap A
rec : (A : Set) (P : Set) → (A → P) → Wrap A → P
Rec : (A : Set) ... |
module Builtin.Size where
open import Agda.Builtin.Size public
|
{-# OPTIONS --without-K #-}
open import HoTT.Base
open import HoTT.Equivalence
module HoTT.Identity.Boolean where
private
variable
x y : 𝟐
_=𝟐_ : 𝟐 → 𝟐 → 𝒰₀
0₂ =𝟐 0₂ = 𝟏
0₂ =𝟐 1₂ = 𝟎
1₂ =𝟐 0₂ = 𝟎
1₂ =𝟐 1₂ = 𝟏
=𝟐-equiv : x == y ≃ x =𝟐 y
=𝟐-equiv = f , qinv→isequiv (g , η , ε)
where
f : x ==... |
open import Categories.Category
open import Categories.Category.CartesianClosed
open import Theory
module Categories.Category.Construction.Models
{ℓ₁ ℓ₂ ℓ₃}
(Th : Theory.Theory ℓ₁ ℓ₂ ℓ₃)
{o ℓ e}
(𝒞 : Category o ℓ e)
(cartesianClosed : CartesianClosed 𝒞)
where
open import Categories.Category.Cartesian... |
-- It is recommended to use Cubical.Algebra.CommRing.Instances.Int
-- instead of this file.
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommRing.Instances.BiInvInt where
open import Cubical.Foundations.Prelude
open import Cubical.Algebra.CommRing
open import Cubical.Data.Int.MoreInts.BiInvInt
renaming (
_+_ ... |
-- Example usage of solver
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Category.Cartesian
module Experiment.Categories.Solver.Category.Cartesian.Example
{o ℓ e} {𝒞 : Category o ℓ e} (cartesian : Cartesian 𝒞) where
open import Experiment.Categories.Solver.Category.Ca... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.KleinBottle where
open import Cubical.HITs.KleinBottle.Base public
open import Cubical.HITs.KleinBottle.Properties public
|
data Unit : Set where
unit : Unit
data Maybe (A : Set) : Set where
nothing : Maybe A
just : A → Maybe A
data Test : Set where
map : (Unit → Maybe Test) → Test
-- Accepted:
foo : Test → Unit
foo-aux : Maybe Test → Unit
foo (map f) = foo-aux (f unit)
foo-aux nothing = unit
foo-aux (just x) = foo x
test : Test... |
module nats where
open import Data.Nat
ten : ℕ
ten = 10
|
open import Agda.Builtin.Nat
postulate P : Nat → Set
record R : Set where
field
f : P zero
foo : R → Set
foo (record { f = f0 }) with zero
foo r | x = Nat
|
module Proof where
-- stdlib import
open import Data.Nat
main : ℕ
main = suc zero
|
{-# OPTIONS --cubical #-}
module _ where
open import Agda.Builtin.Nat
open import Agda.Builtin.Cubical.Path
postulate
admit : ∀ {A : Set} → A
data Z : Set where
pos : Nat → Z
neg : Nat → Z
sameZero : pos 0 ≡ neg 0
_+Z_ : Z → Z → Z
pos x +Z pos x₁ = admit
pos x +Z neg x₁ = admit
pos x +Z sameZero x... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT renaming (pt to ⊙pt)
open import homotopy.Bouquet
open import homotopy.FinWedge
open import homotopy.SphereEndomorphism
open import homotopy.DisjointlyPointedSet
open import groups.SphereEndomorphism
open import groups.SumOfSubIndicator
open import groups.Disjoi... |
-- FNF, 2017-06-13, issue # 2592 reported by Manuel Bärenz
-- The .in file loads Issue2592/B.agda and Issue2592/C.agda that both
-- imports Issue2592/A.agda.
|
data ⊥ : Set where
module M₁ where
postulate
∥_∥ : Set → Set
{-# POLARITY ∥_∥ ++ #-}
data D : Set where
c : ∥ D ∥ → D
module M₂ where
postulate
_⇒_ : Set → Set → Set
lambda : {A B : Set} → (A → B) → A ⇒ B
apply : {A B : Set} → A ⇒ B → A → B
{-# POLARITY _⇒_ ++ #-}
data D : Se... |
module Tuples where
open import Data.Product
_² : ∀ {a} (A : Set a) → Set a
A ² = A × A
_³ : ∀ {a} (A : Set a) → Set a
A ³ = A × A ²
_⁴ : ∀ {a} (A : Set a) → Set a
A ⁴ = A × A ³
_⁵ : ∀ {a} (A : Set a) → Set a
A ⁵ = A × A ⁴
_⁶ : ∀ {a} (A : Set a) → Set a
A ⁶ = A × A ⁵
_⁷ : ∀ {a} (A : Set a) → Set a
A ⁷ = A × A ⁶
... |
{-# OPTIONS --without-K #-}
module function.extensionality where
open import function.extensionality.core public
open import function.extensionality.proof public
open import function.extensionality.strong public
using (strong-funext; strong-funext-iso)
open import function.extensionality.computation public
open imp... |
module SimpleTermUnification where
open import OscarPrelude
data Term (n : Nat) : Set where
var : Fin n → Term n
leaf : Term n
_fork_ : Term n → Term n → Term n
|> : ∀ {m n} → (r : Fin m → Fin n) → Fin m → Term n
|> r = var ∘ r
_<|_ : ∀ {m n} → (f : Fin m → Term n) → Term m → Term n
f <| var x = f x
f <| lea... |
module Types where
open import Data.Bool
open import Data.Fin using (Fin)
import Data.Fin as F
open import Data.Nat renaming (_≟_ to _≟N_)
open import Data.Vec hiding (head; tail)
open import Relation.Binary.PropositionalEquality
open import Relation.Nullary
infixl 80 _∙_
data Type : Set where
𝔹 : Type
𝔹... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT.Base
open import HoTT.Identity
open import HoTT.Identity.Sigma
open import HoTT.Identity.Pi
open import HoTT.Identity.Universe
open import HoTT.Identity.Product
open import HoTT.HLevel
open import HoTT.HLevel.Truncate
open import HoTT.Equivalence
open import HoTT... |
module Agda.TypeChecking.Lock where
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Foundations.Pointed.FunExt where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Pointed.Base
open import Cubical.Foundations.Pointed.Properties
o... |
{-# OPTIONS --cubical --no-exact-split --safe #-}
module Cubical.Structures.MultiSet where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.SIP renaming (SNS-PathP to SNS)
open ... |
{-# OPTIONS --without-K #-}
module Swaps where
-- Intermediate representation of permutations to prove soundness and
-- completeness
open import Level using (Level; _⊔_) renaming (zero to lzero; suc to lsuc)
open import Relation.Binary.PropositionalEquality
using (_≡_; refl; sym; trans; subst; subst₂; cong; con... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Example showing how the free monad construction on containers can be
-- used
------------------------------------------------------------------------
module README.Container.FreeMonad where
open import Category... |
{-# OPTIONS --cubical --safe #-}
module Container.List where
open import Prelude
open import Data.Fin
open import Container
List : Type a → Type a
List = ⟦ ℕ , Fin ⟧
|
{-# OPTIONS --allow-unsolved-metas #-}
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
test : (x y : Nat) → x ≡ y → x ≡ 1 → y ≡ 1 → Nat
test (suc zero) (suc zero) refl refl refl = {!!}
|
open import Prelude
module Implicits.Syntax where
open import Implicits.Syntax.Type public
open import Implicits.Syntax.Term public
open import Implicits.Syntax.Context public
|
-- Enriched categories
{-# OPTIONS --safe #-}
module Cubical.Categories.Monoidal.Enriched where
open import Cubical.Categories.Monoidal.Base
open import Cubical.Foundations.Prelude
module _ {ℓV ℓV' : Level} (V : MonoidalCategory ℓV ℓV') (ℓE : Level) where
open MonoidalCategory V
renaming (ob to obV; Hom[_,_] ... |
{-
--{-# OPTIONS --allow-unsolved-metas #-}
--{-# OPTIONS -v 100 #-}
{- Yellow highlighting should be accompanied by an error message -}
{- By default, command-line agda reports "unsolved metas" and gives a source-code location, but no information about the nature of the unsolved metas. (Emacs agda gives only yellow... |
------------------------------------------------------------------------------
-- Testing the non-internal ATP equality
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorp... |
{-# OPTIONS --without-K --safe #-}
-- A Monad in a Bicategory.
-- For the more elementary version of Monads, see 'Categories.Monad'.
module Categories.Bicategory.Monad where
open import Level
open import Data.Product using (_,_)
open import Categories.Bicategory
import Categories.Bicategory.Extras as Bicat
open impo... |
{-# OPTIONS --without-K #-}
open import lib.Basics
-- open import lib.NType2
-- open import lib.PathGroupoid
open import lib.types.Bool
open import lib.types.IteratedSuspension
open import lib.types.Lift
open import lib.types.LoopSpace
open import lib.types.Nat
open import lib.types.Paths
open import lib.types.Pi... |
-- Andreas, Bentfest 2016-04-28 Marsstrand
-- Issue 1944: also resolve overloaded projections in checking position
module _ (A : Set) (a : A) where
record R B : Set where
field f : B
open R
record S B : Set where
field f : B
open S
test : ∀{A : Set} → A → A
test = f
-- Expected error:
-- Cannot resolve overload... |
open import Relation.Binary using (Rel)
open import Algebra.Bundles using (CommutativeRing)
open import Algebra.Module.Normed
module Algebra.Module.Limit.Compose
{r ℓr} {CR : CommutativeRing r ℓr}
(open CommutativeRing CR using () renaming (Carrier to X))
{rel} {_≤_ : Rel X rel}
{ma ℓma} (MA : NormedModule CR... |
{-# OPTIONS --cubical --safe #-}
module Data.Binary.Addition.Properties where
open import Prelude
open import Data.Binary.Definition
open import Data.Binary.Addition
open import Data.Binary.Conversion
import Data.Nat as ℕ
import Data.Nat.Properties as ℕ
open import Path.Reasoning
open import Data.Binary.Isomorphism
... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of operations on the Delay type
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --sized-types #-}
module Codata.Delay.Properties where
open im... |
------------------------------------------------------------------------
-- Helpers intended to ease the development of "tactics" which use
-- proof by reflection
------------------------------------------------------------------------
open import Relation.Binary
open import Data.Nat
open import Data.Fin
open import D... |
postulate
T : Set → Set
_>>=_ : ∀ {A B} → T A → (A → T B) → T B
argh : ∀ {A} → T A → T A
argh ta = do
f x ← ta
{!!}
|
module Common.Nat where
open import Agda.Builtin.Nat public
using ( Nat; zero; suc; _+_; _*_ )
renaming ( _-_ to _∸_ )
{-# COMPILED_JS Nat function (x,v) { return (x < 1? v.zero(): v.suc(x-1)); } #-}
{-# COMPILED_JS zero 0 #-}
{-# COMPILED_JS suc function (x) { return x+1; } #-}
{-# COMPILED_JS _+_ function (... |
-- You can have infix declarations in records.
module InfixRecordFields where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
infixl 50 _+_
_+_ : Nat -> Nat -> Nat
zero + m = m
suc n + m = suc (n + m)
data _==_ {A : Set}(x : A) : A -> Set where
refl : x == x
one = suc zero
two = suc (suc zero)
record A ... |
{-# OPTIONS --rewriting --confluence-check #-}
open import Agda.Builtin.Equality
open import Agda.Builtin.Equality.Rewrite
data Unit : Set where ∗ : Unit
postulate
A : Set
a b c : Unit → A
a→b : a ∗ ≡ b ∗
a→c : ∀ x → a x ≡ c x
b→c : b ∗ ≡ c ∗
{-# REWRITE a→b a→c b→c #-}
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Solver for commutative ring or semiring equalities
------------------------------------------------------------------------
-- Uses ideas from the Coq ring tactic. See "Proving Equalities in a
-- Commutative Rin... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommMonoid.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.SIP
open import Cubical.Data.Sigma
open import Cubical.... |
module Limit where
-- Statement that the limit of the function f at point l exists (and its value is L)
-- This is expressed by converting the standard (ε,δ)-limit definition to Skolem normal form (TODO: ...I think? Is this correct?
record Lim (f : ℝ → ℝ) (p : ℝ) (L : ℝ) : Stmt where
field
δ : ℝ₊ → ℝ₊ -... |
module FOLdisplay where
open import Data.String using (String)
open import Data.Empty
open import Data.Nat
open import Data.Product
open import Relation.Binary.PropositionalEquality as PropEq
using (_≡_; _≢_; refl; sym; cong; subst)
open import Relation.Nullary
open import Data.String using (String; _++_)
-- ... |
import Algebra
import Algebra.Structures
import Function.Equality
import Function.Equivalence
import Function.Bijection
import Level
import Relation.Binary
import Algebra.FunctionProperties
import Relation.Binary.EqReasoning
open Level renaming (zero to ₀)
open Relation.Binary using (Setoid; module Setoid)
open Functi... |
{-# OPTIONS --erased-cubical #-}
module Main where
open import Data.List using (map)
open import Data.Unit using (⊤)
open import Midi using (IO; _>>=_; getArgs; putStrLn; exportTracks; track→htrack)
open import FarmCanon using (canonTracks)
open import FarmFugue using (fugueTracks)
-- TODO: Remove
open import... |
{-# OPTIONS --cubical --no-import-sorts #-}
module MoreLogic.Reasoning where -- hProp logic
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.Data.Sigma renaming (_×_ to infixr 4 _×_)
-- "i... |
-- Mixing CatchAll branches with varying arity can be tricky.
--
-- If the number of arguments a catch all branch expects to be already abstracted over is smaller
-- than the number of arguments present in the failing clause/branch, we need to apply
-- the catch-all branch to the surplus arguments already abstracted ov... |
module NF.Nat where
open import NF
open import Relation.Binary.PropositionalEquality
open import Data.Nat
instance
nf0 : NF 0
Sing.unpack (NF.!! nf0) = 0
Sing.eq (NF.!! nf0) = refl
{-# INLINE nf0 #-}
nfSuc : {n : ℕ}{{nfn : NF n}} -> NF (suc n)
Sing.unpack (NF.!! (nfSuc {n})) = suc (nf n)
Sing.eq (NF.!... |
module STLC.Coquand.Renaming where
open import STLC.Syntax public
open import Category
--------------------------------------------------------------------------------
-- Renamings
infix 4 _∋⋆_
data _∋⋆_ : 𝒞 → 𝒞 → Set
where
∅ : ∀ {Γ} → Γ ∋⋆ ∅
_,_ : ∀ {Γ Γ′ A} → (η : Γ′ ∋⋆ Γ) (i : Γ′ ∋ A)
... |
------------------------------------------------------------------------
-- An investigation of nested fixpoints of the form μX.νY.… in Agda
------------------------------------------------------------------------
module MuNu where
open import Codata.Musical.Notation
import Codata.Musical.Colist as Colist
open import... |
open import Preliminaries
module Preorder where
record PreorderStructure (A : Set) : Set1 where
constructor preorder-structure
field
_≤_ : A → A → Set
refl : ∀ x → x ≤ x
trans : ∀ x y z → x ≤ y → y ≤ z → x ≤ z
record Preorder A : Set1 where
constructor preorder
field
preor... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Functor hiding (id)
module Categories.Diagram.Colimit.DualProperties
{o ℓ e} {o′ ℓ′ e′} {C : Category o ℓ e} {J : Category o′ ℓ′ e′} where
open import Function.Equality renaming (id to idFun)
open import Categories.Category.... |
{-# OPTIONS --without-K --safe #-}
module Cats.Category.Setoids.Facts.Initial where
open import Level
open import Relation.Binary using (Setoid)
open import Cats.Category
open import Cats.Category.Setoids using (Setoids ; ≈-intro)
import Data.Empty as Empty
⊥ : ∀ {l l′} → Setoid l l′
⊥ = record
{ Carrier = Lift ... |
open import Oscar.Prelude
open import Oscar.Class
open import Oscar.Class.Reflexivity
open import Oscar.Class.Symmetry
open import Oscar.Class.Transitivity
open import Oscar.Class.IsEquivalence
open import Oscar.Class.Setoid
open import Oscar.Data.Proposequality
module Oscar.Property.Setoid.Proposextensequality where... |
{-# OPTIONS --allow-unsolved-metas #-}
latex : Set
latex = {!test!}
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Some algebraic structures defined over some other structure
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (Rel; Se... |
------------------------------------------------------------------------
-- Some derivable properties
------------------------------------------------------------------------
open import Algebra
module Algebra.Props.BooleanAlgebra (b : BooleanAlgebra) where
open BooleanAlgebra b
import Algebra.Props.DistributiveLatt... |
{-# OPTIONS --cubical --no-import-sorts #-}
module Number.Consequences 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 (inr to inrᵖ; inl to inlᵖ)
... |
module Prelude.Ord where
open import Agda.Primitive
open import Prelude.Equality
open import Prelude.Decidable
open import Prelude.Bool
open import Prelude.Function
open import Prelude.Empty
data Comparison {a} {A : Set a} (_<_ : A → A → Set a) (x y : A) : Set a where
less : (lt : x < y) → Comparison _<_ x y
... |
-- Intuitionistic propositional calculus.
-- Translation between different formalisations of syntax.
module IPC.Syntax.Translation where
open import IPC.Syntax.Common public
import IPC.Syntax.ClosedHilbertSequential as CHS
import IPC.Syntax.ClosedHilbert as CH
import IPC.Syntax.HilbertSequential as HS
import IPC.Syn... |
------------------------------------------------------------------------------
-- Properties stated in the Burstall's paper
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-poly... |
{-# OPTIONS --without-K #-}
module TypeEquiv where
import Level using (zero; suc)
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 Algebra using (CommutativeSemiring)
open import Algeb... |
{-# OPTIONS --no-universe-polymorphism #-}
open import Relation.Binary.Core
open import Function
module Equivalence where
infixr 5 _⇔_
record _⇔_ (A B : Set) : Set where
field to : A → B
from : B → A
infixr 3 _↔_
record _↔_ (A B : Set) : Set where
field to : A → B
from : B → A
... |
module Data.List.Setoid where
import Lvl
open import Data.List
open import Data.List.Equiv
open import Data.List.Relation.Quantification
open import Logic.Propositional
open import Structure.Operator
open import Structure.Setoid
open import Structure.Relator.Equivalence
import Structure.Relator.Names as Name... |
module Background where
postulate Bits : Set
module Open where
data U : Set where
postulate
El : U → Set
marshal : (u : U) → El u → Bits
module Closed where
data Desc : Set where
postulate
μ : Desc → Set
marshal : (D : Desc) → μ D → Bits
|
{-# OPTIONS --rewriting #-}
module Properties where
import Properties.Contradiction
import Properties.Dec
import Properties.Equality
import Properties.Functions
import Properties.Remember
import Properties.Step
import Properties.StrictMode
import Properties.Subtyping
import Properties.TypeCheck
|
open import Prelude renaming (_≟_ to _N≟_)
module Implicits.Syntax.Type.Unification.McBride where
open import Implicits.Syntax
open import Implicits.Syntax.MetaType
open import Data.Vec hiding (_>>=_)
open import Data.Vec.Properties
open import Data.Nat as N using ()
open import Data.Nat.Properties.Simple
open impor... |
------------------------------------------------------------------------
-- A small definition of a dependently typed language, using the
-- technique from McBride's "Outrageous but Meaningful Coincidences"
------------------------------------------------------------------------
-- Inlining saves a lot of memory. Test... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Structures.Semigroup 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 --without-K #-}
open import Function.Related.TypeIsomorphisms.NP
open import Function.Inverse.NP
open import Data.Maybe.NP
open import Data.Nat
open import Explore.Type
open import Explore.Explorable
open import Explore.Sum
module Explore.Explorable.Maybe where
μMaybe : ∀ {A} → Explorable A → Explorable ... |
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary.Core
module Loop.Definitions
{a ℓ} {A : Set a} -- The underlying set
(_≈_ : Rel A ℓ) -- The underlying equality
where
open import Algebra.Core
open import Data.Product
LeftBol : Op₂ A → Set _
LeftBol _∙_ = ∀ x y z → (x ∙ (y ∙ (x ∙ z))) ≈ ((x... |
module UninstantiatedDotPattern where
f : Set -> Set -> Set
f .X X = X
|
{-# OPTIONS --universe-polymorphism #-}
module Categories.Opposite where
-- some properties of the opposite category.
-- XXX these should probably go somewhere else, but everywhere i think of
-- has other problems. ☹
open import Categories.Category
open import Categories.Functor
open import Categories.FunctorCategory... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
-- a zero object is both terminal and initial.
module Categories.Object.Zero {o ℓ e} (C : Category o ℓ e) where
open import Level using (_⊔_)
open import Categories.Object.Terminal C
open import Categories.Object.Initial C
open Category C
record Z... |
open import Data.Product using ( _×_ ; _,_ )
open import Relation.Unary using ( _∈_ )
open import Web.Semantic.DL.ABox using ( ABox )
open import Web.Semantic.DL.Signature using ( Signature )
open import Web.Semantic.DL.TBox using ( TBox )
open import Web.Semantic.Util using ( Finite )
module Web.Semantic.DL.Category.... |
module sn-calculus-compatconf.pot where
open import can-function-preserve
using (canₖ-monotonic ; canₛ-monotonic ; canₛₕ-monotonic)
open import sn-calculus
open import utility renaming (_U̬_ to _∪_)
open import context-properties
using (->pot-view)
open import Esterel.Lang
open import Esterel.Lang.Binding
open i... |
{-# OPTIONS --safe #-}
open import Cubical.Foundations.Prelude
open import Cubical.Categories.Category.Base
open import Cubical.Categories.Monoidal.Base
open import Cubical.Categories.Instances.Functors
open import Cubical.Categories.Functor.Base renaming (𝟙⟨_⟩ to idfunctor)
open import Cubical.Categories.NaturalTran... |
{-# OPTIONS -v impossible:10 #-}
module ImpossibleVerbose where
-- The only way to trigger an __IMPOSSIBLE__ that isn't a bug.
{-# IMPOSSIBLE This message should be debug-printed with option '-v impossible:10'. #-}
|
module nodcap.NF.CutND where
open import Algebra
open import Category.Monad
open import Data.Nat as ℕ using (ℕ; suc; zero)
open import Data.Pos as ℕ⁺
open import Data.List as L using (List; []; _∷_; _++_; map)
open import Data.List.Any as LA using (Any; here; there)
open import Data.List.Any.BagAndSetEquality as B
ope... |
module OlderBasicILP.Indirect.Hilbert.Nested where
open import OlderBasicILP.Indirect public
-- Derivations, as Hilbert-style combinator trees.
mutual
data Tm : Set where
VAR : ℕ → Tm
APP : Tm → Tm → Tm
CI : Tm
CK : Tm
CS : Tm
BOX : Tm → Tm
CDIST : Tm
CUP : Tm
... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Support for reflection
------------------------------------------------------------------------
module Reflection where
open import Data.Bool as Bool using (Bool); open Bool.Bool
open import Data.List using (Li... |
module Issue313 where
postulate
QName : Set
{-# BUILTIN QNAME QName #-}
postulate
X : Set
_+_ : QName → QName → Set
foo : Set
foo = quote X + quote X
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Simple combinators working solely on and with functions
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Function where
open import Level
open ... |
{-# OPTIONS --universe-polymorphism #-}
open import Common.Prelude
renaming (Nat to ℕ; module Nat to ℕ)
using (zero; suc; _+_; _∸_; List; []; _∷_; Bool; true; false)
open import Common.Level
open import Common.Reflection
module TermSplicing where
module Library where
data Box {a} (A : Set a) : Set a where
... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NType
open import lib.types.Cospan
open import lib.types.Pointed
open import lib.types.Sigma
module lib.types.Pullback where
module _ {i j k} (D : Cospan {i} {j} {k}) where
open Cospan D
record Pullback : Type (lmax i (lmax j k)) wh... |
{-# OPTIONS --without-K --safe #-}
module Data.Empty where
open import Data.Empty.Base public
|
{-# OPTIONS --without-K #-}
module tactic where
open import Type
open import Search.Type
open import Search.Searchable
open import Search.Searchable.Product
open import Data.One
open import Data.Product
open import Function
open import Relation.Binary.PropositionalEquality.NP
module _ {R S} (sum-R : Sum R)(sum-R-ext... |
-- ByteStrings where we track statically if they're lazy or strict
-- Note that lazy and strict bytestrings have the same semantics
-- in Agda, as all computation is guaranteed to terminate.
-- They may, however, have quite different performance characteristics.
open import Data.Bool using ( Bool )
open import Data.Na... |
module BasicConcreteImplementations where
open import AbstractInterfaces public
-- Process identifiers.
instance
⟨P⟩ : IsProc
⟨P⟩ = record
{ Proc = ℕ
; _≡ₚ?_ = _≡?_
; _<ₚ_ = _<_
; trans<ₚ = trans<
; tri<ₚ = tri<
}
-- Process clocks, message... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.