text stringlengths 4 690k |
|---|
module Examples.Main where
import Examples.PingPong as PingPong
import Examples.InfiniteBind as InfiniteBind
import Examples.TestSelectiveReceive as SelectiveReceive
import Examples.TestCall as Call
open import Runtime
open import SimulationEnvironment
open import ActorMonad
import IO
open ∞ActorM
pingpongEntry = sing... |
{-
This second-order signature was created from the following second-order syntax description:
syntax GroupAction | GA
type
* : 0-ary
X : 0-ary
term
unit : * | ε
add : * * -> * | _⊕_ l20
neg : * -> * | ⊖_ r40
act : * X -> X | _⊙_ r30
theory
(εU⊕ᴸ) a |> add (unit, a) = a
(εU⊕ᴿ) a |> add (... |
module Typechecker where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
{-# BUILTIN NATURAL Nat #-}
{-# BUILTIN ZERO zero #-}
{-# BUILTIN SUC suc #-}
_+_ : Nat -> Nat -> Nat
zero + m = m
suc n + m = suc (n + m)
data Fin : Nat -> Set where
f0 : {n : Nat} -> Fin (suc n)
fs : {n : Nat} -> Fin n -> Fin (s... |
{-# OPTIONS --without-K #-}
open import Base
module Homotopy.VanKampen.Guide where
open import Homotopy.Truncation
open import Homotopy.Connected
record legend i (city : Set i) : Set (suc i) where
constructor leg_,_,_
field
name : Set i
loc : name → city
all-listed : ∀ c → [ hfiber loc c ]
id-legen... |
{-# OPTIONS --profile=notclose #-}
|
{-
Descriptor language for easily defining relational structures
-}
{-# OPTIONS --cubical --no-import-sorts --no-exact-split --safe #-}
module Cubical.Structures.Relational.Macro where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cu... |
------------------------------------------------------------------------------
-- Totality properties respect to OrdList
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymor... |
{- 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
-}
-- This module contains properties that are only about the behavior of the ha... |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Cones where
open import Level
open import Categories.Support.PropositionalEquality
open import Categories.Category
open import Categories.Functor hiding (_∘_; _≡_; equiv; id; assoc; identityˡ; identityʳ; ∘-resp-≡)
open import Categories.Cone
record ConeMorph... |
module L.Base.Core where
-- Reexport all of the Cores
open import L.Base.Sigma.Core public
open import L.Base.Coproduct.Core public
open import L.Base.Empty.Core public
open import L.Base.Unit.Core public
open import L.Base.Nat.Core public
open import L.Base.Id.Core public
|
module Data.DependentWidthTree where
import Lvl
open import Functional using (id)
open import Functional.Dependent
open import Numeral.Finite
open import Numeral.Natural
open import Type
private variable ℓ ℓᵢ ℓₗ ℓₙ ℓₒ : Lvl.Level
private variable N N₁ N₂ L T A B : Type{ℓ}
module _ {N : Type{ℓₙ}} (Index : N → Ty... |
module SafeFlagPrimTrustMe where
-- Cannot make an example with the correct type signature for
-- primTrustMe since it requires postulated universe level builtins,
-- which --safe flag will reject.
private
primitive
primTrustMe : Set
|
-- {-# OPTIONS --no-forcing #-}
{-# OPTIONS --rewriting #-}
{-# OPTIONS --sized-types #-}
open import Agda.Builtin.Equality
open import Agda.Builtin.Size
{-# BUILTIN REWRITE _≡_ #-}
variable i j : Size
postulate ANY : ∀{A : Set} → A
data Ty : Set where
bool : Ty
variable a b c d : Ty
infixl 5 _∘_
infixr 6 _∷_ ... |
module Sets where
import Equality
open Equality public
infixr 10 _$_
infixr 40 _[+]_ _<+>_ _>+<_
infixr 60 _[×]_ _<×>_ _>×<_
infixr 90 _∘_
id : {A : Set} -> A -> A
id x = x
_∘_ : {A B C : Set} -> (B -> C) -> (A -> B) -> A -> C
f ∘ g = \x -> f (g x)
_$_ : {A B : Set} -> (A -> B) -> A -> B
f... |
-- 2014-04-24
module _ where
open import Common.Size
open import Common.Prelude using (Bool; true; false; if_then_else_)
open import Common.Product
-- sized lists
data List A {i} : Set where
[] : List A
_∷_ : {i' : Size< i} (x : A) (xs : List A {i'}) → List A
_++_ : ∀{A} → List A → List A → List A
[] ++... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Functions.Definition
open import Groups.Definition
open import Groups.Abelian.Definition
open import Setoids.Setoids
open import Rings.Definition
open import Sets.FinSet.Definition
open import Vectors
open import Numbers.Natural... |
------------------------------------------------------------------------
-- "Equational" reasoning combinator setup
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
open import Labelled-transition-system
module Bisimilarity.Weak.Equational-reasoning-instances
... |
open import Data.Product using ( _,_ )
open import Data.Sum using ( _⊎_ )
open import Web.Semantic.DL.ABox.Interp using ( Interp ; _*_ )
open import Web.Semantic.DL.ABox.Model using ( _⊨a_ ; _⊨b_ ; *-resp-⟨ABox⟩ )
open import Web.Semantic.DL.Category.Object using ( Object ; _,_ ; IN )
open import Web.Semantic.DL.Catego... |
{-# OPTIONS --type-in-type #-}
module TabsInPragmas where
|
import Lvl
open import Structure.Setoid
open import Type
module Automaton.Deterministic.Accessible where
open import Automaton.Deterministic
open import Data.List renaming (∅ to ε ; _⊰_ to _·_)
open import Data.List.Functions using (postpend ; _++_)
open import Logic.Predicate
open import Logic.Predicate.Equiv
o... |
open import Data.Char using ( Char )
open import Data.Bool using ( Bool )
module Data.Char.Classifier.Primitive where
postulate
isAscii : Char → Bool
isLatin1 : Char → Bool
isControl : Char → Bool
isSpace : Char → Bool
isLower : Char → Bool
isUpper : Char → Bool
isAlpha : Char → Bool
isAlphaNum : Cha... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NType2
open import lib.NConnected
open import lib.types.Truncation
open import lib.types.Group
module lib.types.EilenbergMacLane1.Core {i} where
module _ (G : Group i) where
private
module G = Group G
postulate -- HIT
EM₁ : ... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.CMonoidEnriched where
-- A category where the Homs are not sets, but commutative monoids
-- There are weak kind of Ab-enriched.
-- The reason to do these "by hand" is that the
-- "free commutative monoid monad", i.e. Bag, is very hard to work
-- with in typ... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.DStructures.Structures.Nat where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Functions.FunExtEquiv
open import Cub... |
open import SOAS.Common
open import SOAS.Families.Core
open import Categories.Object.Initial
open import SOAS.Coalgebraic.Strength
import SOAS.Metatheory.MetaAlgebra
-- Coalgebraic traversal maps
module SOAS.Metatheory.Coalgebraic {T : Set}
(⅀F : Functor 𝔽amiliesₛ 𝔽amiliesₛ) (⅀:Str : Strength ⅀F)
(𝔛 : Familyₛ)... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Data.Bool.SwitchStatement where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Data.Bool.Base
open import Cubical.Data.Nat
{-
Switch-case:
_==_ : A → A → Bool
_ : B
_ = switch (λ x → x ... |
module Data.Lens.Proofs.LensComposition where
open import Haskell.Prelude renaming (zero to Z; suc to S)
open import Data.Lens.Lens
open import Data.Logic
open import Agda.Primitive
open import Data.Lens.Proofs.LensLaws
open import Data.Lens.Proofs.LensPostulates
-- We proof that if we have 2 valid lenses l1 and l2, ... |
-- Andreas, 2018-09-07 issue #3217 reported by Nisse
--
-- Missing range for cubical error
{-# OPTIONS --cubical #-}
-- {-# OPTIONS -v tc.term.lambda:100 -v tc.term:10 #-}
open import Agda.Builtin.Cubical.Path
data Bool : Set where
true false : Bool
eq : true ≡ false
eq = λ i → true
-- Expected error
-- Issue32... |
-- Andreas, 2015-07-07 continuation of issue 665
-- Jesper, 2015-12-18 some of these don't work anymore with the new unifier,
-- but a few others that weren't accepted are now.
{-# OPTIONS --show-implicit #-}
-- {-# OPTIONS -v tc.with.strip:10 #-}
-- {-# OPTIONS -v tc.with.strip:60 -v tc.lhs:20 -v tc.lhs.unify:20 #-}... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category using (Category; _[_,_]; _[_∘_]; _[_≈_])
-- Bundled versions of Idempotents, as well as maps between idempotents.
module Categories.Morphism.Idempotent.Bundles {o ℓ e} (𝒞 : Category o ℓ e) where
open import Level
import Categories.Morphism.Idempote... |
{-# OPTIONS --cubical --safe --no-import-sorts #-}
module Cubical.Algebra.Algebra.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... |
-- Andreas, 2016-10-03, re issue #2231
-- Termination checking a corecursive definition in abstract mode.
{-# OPTIONS --guardedness #-}
infix 1000 ♯_
{-# BUILTIN INFINITY ∞ #-}
{-# BUILTIN SHARP ♯_ #-}
{-# BUILTIN FLAT ♭ #-}
abstract
data Functor : Set where
Id : Functor
_·_ : Functor → Set → Set
... |
module _ (A : Set) where
open import Common.Prelude
open import Common.Reflection
macro
foo : Tactic
foo _ = returnTC _
bar : ⊤
bar = foo
|
------------------------------------------------------------------------
-- Some results related to CCS, implemented without using a fixed form
-- of bisimilarity
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
open import Prelude
module Bisimilarity.CCS.General... |
record R : Set₁
where
field
_f_ : Set → Set
postulate A : Set
I₁ : R
I₁ R.f x = A
|
module A.B.M where
|
module SetClash where
postulate x : Set
y : Set1
y = x
|
------------------------------------------------------------------------------
-- Equivalent approaches for implement the inductive predicate N
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTION... |
postulate
F : Set → Set
{-# POLARITY F * #-}
data D : Set where
d : F D → D
|
module Where where
-- all these examples should not termination check
f : forall {A : Set} -> A
f {A} = g
where g : A
g = f
f1 : forall {A : Set} -> A -> A
f1 {A} a = g a
where g : A -> A
g a = f1 a
f2 : forall {A : Set} -> A -> A
f2 {A} a = g a
where g : A -> A
... |
module Cats.Util.Function where
open import Relation.Binary using (Rel ; IsEquivalence ; _Preserves₂_⟶_⟶_)
open import Relation.Binary.PropositionalEquality as ≡
open import Function as Fun public using (id ; _on_)
open import Relation.Binary.Construct.On public
renaming (isEquivalence to on-isEquivalence)
infixr... |
{- Name: Bowornmet (Ben) Hudson
-- define the complexity language from the paper
-}
open import Preliminaries
open import Preorder-withmax
module Comp-lang where
-- define the complexity language from the paper
-- we want to focus on arrow, cross, and nat types
-- do I need unit types?
data CTp : Set where... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import cohomology.Theory
open import cw.CW
module cw.cohomology.TipAndAugment {i} (OT : OrdinaryTheory i)
(⊙skel : ⊙Skeleton {i} 0) where
open OrdinaryTheory OT
open import homotopy.DisjointlyPointedSet
open import cohomology.DisjointlyPointedSet OT
m... |
module Class.Monad.State where
open import Class.Monad
open import Data.Product
open import Data.Unit.Polymorphic
open import Function
open import Level
private
variable
a : Level
A : Set a
record MonadState {a} (M : Set a → Set a) {{_ : Monad M}} (S : Set a) : Set (suc a) where
field
get : M S
p... |
postulate
M : Set → Set
_>>=_ : ∀ {A B} → M A → (A → M B) → M B
_>>_ : ∀ {A B} → M A → M B → M B
_<|>_ : ∀ {A} → M A → M A → M A
infixr 4 _>>=_ _>>_
infixr -100 _<|>_
expr : ∀ {A} → (A → M A) → (A → M A)
expr f a = do
x ← {!f a!}
y ← {!f x <|> f a!}
{!f x <|> f y!}
{!f x <|> f y!}
|
{-# OPTIONS --no-copatterns #-}
-- Andreas, 2015-08-26: copatterns are on by default now.
-- Andreas, James, 2011-11-24
-- trigger error message 'NeedOptionCopatterns'
module NeedOptionCopatterns where
record Bla : Set2 where
field
bla : Set1
open Bla
f : Bla
bla f = Set
-- should request option --copatterns
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Definitions of algebraic structures like monoids and rings
-- (packed in records together with sets, operations, etc.)
------------------------------------------------------------------------
{-# OPTIONS --witho... |
variable
ℓ : _
A : Set ℓ
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.ZCohomology.Groups.Sn where
open import Cubical.ZCohomology.Base
open import Cubical.ZCohomology.Properties
open import Cubical.ZCohomology.MayerVietorisUnreduced
open import Cubical.ZCohomology.Groups.Unit
open import Cubical.ZCohomology.Groups.Connect... |
{-# OPTIONS --safe --sized-types #-}
module Generic.Semantics.Elaboration.LetBinder where
open import Size
open import Data.Product
open import Agda.Builtin.List
open import Function
open import Relation.Unary
open import Data.Environment
open import Generic.Syntax
open import Generic.Syntax.LetBinder
open import Ge... |
module reverse-involution where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; sym; cong)
open Eq.≡-Reasoning
open import lists using (List; []; _∷_; [_]; _++_; reverse)
open import reverse-++-distrib using (reverse-++-distrib)
-- reverseが対合(involution)である事の証明
reverse-involution : {A : S... |
------------------------------------------------------------------------------
-- Definition of the gcd of two natural numbers using the Euclid's algorithm
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-... |
module Cats.Limit.Product where
open import Data.Bool using (Bool ; true ; false)
open import Data.Product using (_×_ ; _,_ ; ∃-syntax ; proj₁ ; proj₂)
open import Cats.Category
open import Cats.Category.Cones using (Cones ; Cone ; HasObj-Cone)
open import Cats.Category.Discrete as Discrete using (Discrete)
open impo... |
-- Very simple facts about natural numbers
module NatSimple where
import Data.Fin as F
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 re... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Group where
open import Cubical.Algebra.Base public
open import Cubical.Algebra.Definitions public
open import Cubical.Algebra.Structures public using (IsGroup; isgroup)
open import Cubical.Algebra.Bundles public using (Group; mkgroup; GroupCar... |
------------------------------------------------------------------------
-- List-related properties
------------------------------------------------------------------------
-- Note that the lemmas below could be generalised to work with other
-- equalities than _≡_.
module Data.List.Properties where
open import Data... |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2021, Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.Base.Types
open import LibraBFT.Impl.OBM.Logging.Logging... |
------------------------------------------------------------------------------
-- The program to sort a list is correct
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorp... |
module Builtin.Coinduction where
open import Agda.Builtin.Coinduction public
|
{-
This second-order signature was created from the following second-order syntax description:
syntax TLC | Λ
type
N : 0-ary
_↣_ : 2-ary | r30
𝟙 : 0-ary
_⊗_ : 2-ary | l40
𝟘 : 0-ary
_⊕_ : 2-ary | l30
term
app : α ↣ β α -> β | _$_ l20
lam : α.β -> α ↣ β | ƛ_ r10
unit : 𝟙
pair : ... |
-- A discussion from -- https://twitter.com/YuumuKonpaku/status/1052959340468953088
module MdJustHighlightAgdaAsHtml where
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
open import Agda.Primitive public using (lzero)
renaming (Level to ULevel; lsuc to lsucc; _⊔_ to lmax)
Type : (i : ULevel) -> Set... |
{-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped as U
open import Definition.Typed
open import Definition.Typed.Weakening
open import Definition.Typed.Reduction
open import Tools.... |
module DualCoinductive where
open import Data.Nat hiding (compare)
open import Data.Nat.Properties
open import Data.Fin hiding (_+_)
open import Function
open import Relation.Binary.PropositionalEquality hiding (Extensionality)
open import Agda.Builtin.Equality.Rewrite
open import Direction
-- variables
variable
n... |
------------------------------------------------------------------------
-- A simplified parser type
------------------------------------------------------------------------
module StructurallyRecursiveDescentParsing.Simplified where
open import Category.Monad
open import Codata.Musical.Notation
open import Data.Bool... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Core definitions for Functions
------------------------------------------------------------------------
-- The contents of this file should usually be accessed from `Function`.
{-# OPTIONS --without-K --safe #-... |
{-# OPTIONS --cubical --safe #-}
module Cubical.Foundations.Pointed.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed.Base
open import Cubical.Data.Prod
Π∙ : ∀ {ℓ ℓ'} (A : Type ℓ) (B∙ : A → Pointed ℓ') → Pointed (ℓ-max ℓ ℓ')
Π∙ A B∙ = (∀ a → typ (B∙ a)) , (λ a → pt (B∙ a... |
module FStream.Containers where
------------------------------------------------------------------------
-- Containers & their extension
------------------------------------------------------------------------
open import Data.Fin
open import Data.Maybe
open import Data.Unit
open import Library
ListC : Container ℓ₀... |
module MJ.Types where
open import Prelude hiding (_≟_)
open import Data.Fin.Properties as FinP using ()
open import Data.Vec
open import Data.List
open import Relation.Binary.Core
open import Relation.Nullary
open import Relation.Binary
data Cid (c : ℕ) : Set where
cls : Fin c → Cid c
Object : Cid c
_cid≟_ : ∀ ... |
{-# OPTIONS --without-K --safe #-}
module Math.NumberTheory.Summation.Generic where
-- agda-stdlib
open import Algebra
open import Data.Nat
module MonoidSummation {c e} (M : Monoid c e) where
open Monoid M renaming (Carrier to A)
-- Σ< n f = Σₖ₌₀ⁿ⁻¹[f k]
Σ< : ℕ → (ℕ → A) → A
Σ< 0 f = ε
Σ< (suc n) f ... |
module Type.Dependent where
import Lvl
open import Type
private
module Module where
-- Dependent product type (pi-type).
-- Also called: Dependent function type.
-- The right-hand side's type is a function type that uses the left-hand side's type as its "domain".
-- And then the type of the res... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category.Core
module Categories.Object.Product.Limit {o ℓ e} (C : Category o ℓ e) where
open import Level
open import Data.Nat.Base using (ℕ)
open import Data.Fin.Base using (Fin)
open import Data.Fin.Patterns
open import Categories.Category.Lift
open import... |
module Scratch.FinDecEq1 where
open import Data.Bool.Base hiding (_≤_)
open import Data.Product
open import Data.Sum
open import Level renaming (suc to lsuc; _⊔_ to _⊔ℓ_; zero to lzero)
open import Relation.Nullary
open import Relation.Nullary.Decidable
open import Relation.Unary using (Decidable)
open import Relati... |
module Web.Semantic.DL.Signature where
infixr 4 _,_
-- a Signature is constructed from Concept Names and Role/Relation Names
data Signature : Set₁ where
_,_ : (CN RN : Set) → Signature
-- concept name (maps to Sets)
CN : Signature → Set
CN (CN , RN) = CN
-- Role Names (or relation names)
RN : Signature → Set
RN (... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Every respectful binary relation induces a preorder. No claim is
-- made that this preorder is unique.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
... |
module regular-star where
open import Level renaming ( suc to Suc ; zero to Zero )
open import Data.List
open import Data.Nat hiding ( _≟_ )
open import Data.Fin hiding ( _+_ )
open import Data.Empty
open import Data.Unit
open import Data.Product
-- open import Data.Maybe
open import Relation.Nullary
open import ... |
-- Andreas, Ulf, 2022-05-06, AIM XXXV
-- Make sure you cannot trick Agda into admitting data types in IUniv.
-- The previous check let this exploit through.
-- Note: I : IUniv : SSet₁
open import Agda.Primitive.Cubical
mutual
Univ = _
data False : Univ where
I' : Univ
I' = I
-- Should fail.
-- Error:
-- Th... |
module Run where
open import Data.Bool
open import Data.Maybe
open import Data.Nat
open import Data.List
open import Data.List.All
open import Typing
open import Syntax
open import Global
open import Channel
open import Values
open import Session
open import Schedule
open import Examples
open import Aexamples
gas :... |
import Lvl
open import Type
module Type.Cardinality.Proofs {ℓₗ : Lvl.Level} where
open import Functional
import Logic.Predicate
import Logic.Predicate.Theorems
import Relator.Equals
import Relator.Equals.Proofs
import Type.Cardinality
import Type.Functions
import Type.Functions... |
-- Andreas, 2016-06-03, bug found by Ulf
-- {-# OPTIONS -v tc.cover:20 #-}
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
record Σ (A : Set) (B : A → Set) : Set where
constructor _,_
field fst : A
snd : B fst
open Σ
record ⊤ : Set where
data ⊥ : Set where
T : Bool → Set
T true = ⊤
T fal... |
module Data.List.Relation.Permutation where
import Data
open import Data.Boolean
open import Data.List
open import Data.List.Functions renaming (module LongOper to List)
open import Data.List.Relation
open import Functional using (id ; _∘_ ; const)
open import Logic.Propositional
open import Logic
import Lvl... |
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Pi
open import lib.types.Sigma
open import lib.types.Span
open import lib.types.Paths
import lib.types.Generic1HIT as Generic1HIT
open import lib.types.Pushout
module lib.types.PushoutFlattening {i} {j} {k} {d : Span {i} {j} {k}} where
open Spa... |
postulate
A : Set
I : (@erased _ : A) → Set
R : A → Set
f : ∀ (@erased x : A) (r : R x) → I x
-- can now be used here ^
|
{-# OPTIONS --cubical --no-import-sorts --no-exact-split --safe #-}
module Cubical.Data.NatMinusOne.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Nat
open import Cubical.Data.NatMinusOne.Base
-1+Path : ℕ ≡ ℕ₋₁
-1+Path = isoToPath (iso -1+... |
data _ : Set where
|
-- Andreas, 2016-09-28, Level meta below neutral level
-- Agda previously simplified X <= a to X = a.
-- This loses the solution X = lzero.
-- {-# OPTIONS -v tc.constr.add:40 #-}
open import Common.Level
module _ (a : Level) where
module WorksWithSwappedDeclarations where
mutual
X : Level
X = _
data... |
open import Data.Product using ( ∃ ; _×_ ; _,_ ; proj₁ ; proj₂ )
open import Relation.Unary using ( _∈_ )
open import Web.Semantic.DL.TBox.Interp using ( Δ ; _⊨_≈_ ) renaming
( Interp to Interp′ ; emp to emp′ )
open import Web.Semantic.DL.Signature using ( Signature )
open import Web.Semantic.Util using ( False ; id... |
module cwf where
open import Nat
open import Base
open import univ
open import help
-- Category with Families
infix 40 _─→_
infixl 50 _,_ _,,_
infixl 70 _∘_ _∙_
infixl 60 _/_ _//_
Con : Set
Con = S
_─→_ : Con -> Con -> Set
Γ ─→ Δ = El (pi Γ (K Δ))
p─→ : {Γ Δ : Con}(σ : Γ ─→ Δ){x y : El Γ} -> x == y -> σ # x == σ... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.CommRing.Instances.Polynomials.UnivariatePolyFun where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Empty as ⊥
open import Cubical.Data.Nat hiding (_·_) renaming (_+_ to _+n_)
open import Cubical.Data.Nat.Order
open imp... |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2021, Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.ImplShared.Consensus.Types
open import Optics.All
modul... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NType2
open import lib.types.Sigma
module lib.types.Modality where
-- Where to put this? Or maybe there's
-- a simpler proof from some library function?
!ᵈ-inv-l-out : ∀ {ℓ} {A : Type ℓ} {P : A → Type ℓ}
{a₀ a₁ : A} {p : a₀ == ... |
{-# OPTIONS --cubical --safe #-}
module Cubical.Data.DiffInt where
open import Cubical.Data.DiffInt.Base public
open import Cubical.Data.DiffInt.Properties public
|
module MLib.Fin.Parts where
open import MLib.Prelude
open import MLib.Prelude.RelProps
import MLib.Fin.Parts.Core as C
open import MLib.Fin.Parts.Nat
open import Function.Surjection using (_↠_)
open import Function.Related renaming (module EquationalReasoning to BijReasoning)
import Relation.Binary.Indexed as I
ope... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
open import Cubical.Algebra.Semigroup
module Cubical.Algebra.Semigroup.Construct.Opposite {ℓ} (S : Semigroup ℓ) where
open import Cubical.Foundations.Prelude
open Semigroup S
import Cubical.Algebra.Magma.Construct.Opposite magma... |
-- Andreas, 2014-09-09
{-# NON_TERMINATING #-}
Foo : Set
Foo = Foo
|
{-# OPTIONS --safe #-}
module Definition.Typed.Consequences.SucCong where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Weakening
open import Definition.Typed.Properties
open import Definition.Typed.Consequences.Syntactic
open import Definition.Typed.Consequences.Substitutio... |
module Reasoning where
open import Algebra
-- Standard syntax sugar for writing equational proofs
infix 4 _≈_
data _≈_ {A} (x y : Graph A) : Set where
prove : x ≡ y -> x ≈ y
infix 1 begin_
begin_ : ∀ {A} {x y : Graph A} -> x ≈ y -> x ≡ y
begin prove p = p
infixr 2 _≡⟨_⟩_
_≡⟨_⟩_ : ∀ {A} (x : Graph A) {y z : Grap... |
module CTL.Modalities.EG where
open import FStream.Core
open import Library
-- Possibly forever : s₀ ⊧ φ ⇔ ∃ s₀ R s₁ R ... ∀ i . sᵢ ⊧ φ
{-# NO_POSITIVITY_CHECK #-} -- Not necessary from EGda 2.6 upwards
record EG' {i : Size} {ℓ₁ ℓ₂} {C : Container ℓ₁}
(props : FStream' C (Set ℓ₂)) : Set (ℓ₁ ⊔ ℓ₂) where
coinductiv... |
module IPL where
data _∧_ (P : Set) (Q : Set) : Set where
∧-intro : P → Q → (P ∧ Q)
_⇔_ : (P : Set) → (Q : Set) → Set
a ⇔ b = (a → b) ∧ (b → a)
proof₁ : {P Q : Set} → (P ∧ Q) → P
proof₁ (∧-intro p q) = p
proof₂ : {P Q : Set} → (P ∧ Q) → Q
proof₂ (∧-intro p q) = q
∧-assoc₁ : { P Q R : Set } ... |
{-# OPTIONS --without-K #-}
open import Base
open import Homotopy.Connected
{-
An example of using the overkilling covering space library.
-}
module Homotopy.Cover.ExamplePi1Circle where
open import Homotopy.Truncation
open import Homotopy.PathTruncation
open import Spaces.Circle
{-
The 1st step: S... |
-- The NO_POSITIVITY_CHECK pragma can only precede a mutual block or a
-- data/record definition.
module Issue1614c where
{-# NO_POSITIVITY_CHECK #-}
postulate Foo : Set
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.