id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_15116 | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Logical relation for erasure (Def. 3.8 and Lemma 3.9)
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Para... |
algebraic-stack_agda0000_doc_15117 |
open import Agda.Builtin.Nat
open import Agda.Builtin.Sigma
open import Agda.Builtin.Equality
data I : Set where
it : I
data D : I → Set where
d : D it
data Box : Set where
[_] : Nat → Box
mutual
data Code : Set where
d : I → Code
box : Code
sg : (a : Code) → (El a → Code) → Code
El : Cod... |
algebraic-stack_agda0000_doc_15118 | {-# OPTIONS --rewriting #-}
open import Agda.Builtin.Equality
{-# BUILTIN REWRITE _≡_ #-}
module _ (Form : Set) where -- FAILS
-- postulate Form : Set -- WORKS
data Cxt : Set where
ε : Cxt
_∙_ : (Γ : Cxt) (A : Form) → Cxt
data _≤_ : (Γ Δ : Cxt) → Set where
id≤ : ∀{Γ} → Γ ≤ Γ
weak : ∀{A Γ Δ} (τ : Γ ≤ Δ) → (... |
algebraic-stack_agda0000_doc_15119 | open import Agda.Builtin.Nat
record R : Set where
field
x : Nat
open R {{...}}
f₁ : R
-- This is fine.
x ⦃ f₁ ⦄ = 0
-- WAS: THIS WORKS BUT MAKES NO SENSE!!!
_ : Nat
_ = f₁ {{ .x }}
-- Should raise an error.
-- Illegal hiding in postfix projection ⦃ .x ⦄
-- when scope checking f₁ ⦃ .x ⦄
|
algebraic-stack_agda0000_doc_976 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of disjoint lists (setoid equality)
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Relation.Binary.Disjoint.Setoid.Proper... |
algebraic-stack_agda0000_doc_977 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.EilenbergMacLane
open import homotopy.EilenbergMacLaneFunctor
open import groups.ToOmega
open import cohomology.Theory
open import cohomology.SpectrumModel
module cohomology.EMModel where
module _ {i} (G : AbGroup i) where
open EMExplic... |
algebraic-stack_agda0000_doc_978 | module BTree.Complete.Base.Properties {A : Set} where
open import BTree {A}
open import BTree.Complete.Base {A}
open import BTree.Equality {A}
open import BTree.Equality.Properties {A}
lemma-≃-⋗ : {l l' r' : BTree} → l ≃ l' → l' ⋗ r' → l ⋗ r'
lemma-≃-⋗ (≃nd x x' ≃lf ≃lf ≃lf) (⋗lf .x') = ⋗lf x
lemma-≃-⋗ (≃nd {r = r}... |
algebraic-stack_agda0000_doc_979 | module plfa-exercises.Practice5 where
open import Data.Nat using (ℕ; zero; suc)
open import Data.String using (String; _≟_)
open import Relation.Binary.PropositionalEquality using (_≡_; _≢_; refl; cong)
open import Relation.Nullary using (Dec; yes; no; ¬_)
open import plfa.part1.Isomorphism using (_≲_)
Id : Set
Id = ... |
algebraic-stack_agda0000_doc_980 | module Ag13 where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl)
open Eq.≡-Reasoning
open import Data.Nat using (ℕ; zero; suc)
open import Data.Product using (_×_) renaming (_,_ to ⟨_,_⟩)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Relation.Nullary using (¬_)
open import Rela... |
algebraic-stack_agda0000_doc_981 | {-# OPTIONS --safe #-}
useful-lemma : ∀ {a} {A : Set a} → A
useful-lemma = useful-lemma
|
algebraic-stack_agda0000_doc_982 | {-# OPTIONS --without-K --copatterns --sized-types #-}
open import lib.Basics
open import lib.PathGroupoid
open import lib.types.Paths
open import lib.Funext
open import Size
{-
-- | Coinductive delay type. This is the functor νπ̂ : Set → Set arising
-- as the fixed point of π̂(H) = π ∘ ⟨Id, H⟩, where π : Set × Set → ... |
algebraic-stack_agda0000_doc_983 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Group where
open import Cubical.Algebra.Group.Base public
open import Cubical.Algebra.Group.Properties public
open import Cubical.Algebra.Group.Morphism public
open import Cubical.Algebra.Group.MorphismProperties public
open import Cubical.Algeb... |
algebraic-stack_agda0000_doc_984 | {-# OPTIONS --without-K #-}
module Sigma {a b} {A : Set a} {B : A → Set b} where
open import Equivalence
open import Types
-- Projections for the positive sigma.
π₁′ : (p : Σ′ A B) → A
π₁′ p = split (λ _ → A) (λ a _ → a) p
π₂′ : (p : Σ′ A B) → B (π₁′ p)
π₂′ p = split (λ p → B (π₁′ p)) (λ _ b → b) p
-- Induction pri... |
algebraic-stack_agda0000_doc_985 | {-# OPTIONS --cubical #-}
module Multidimensional.Data.NNat.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Unit
open import Cubical.Data.Nat
open import Cubical.Data.Prod
open import Cubical.Data.Bool
open import Cubical.Relation.Nullary
open import Multidimensional.Data.Extra.Nat
open... |
algebraic-stack_agda0000_doc_986 | {-# OPTIONS --safe #-}
module Cubical.Homotopy.HSpace where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed
open import Cubical.Foundations.HLevels
open import Cubical.HITs.S1
open import Cubical.HITs.Sn
record HSpace {ℓ : Level} (A : Pointed ℓ) : Type ℓ where
constructor HSp
field... |
algebraic-stack_agda0000_doc_987 |
module Prelude.Equality.Unsafe where
open import Prelude.Equality
open import Prelude.Empty
open import Prelude.Erased
open import Agda.Builtin.TrustMe
-- unsafeEqual {x = x} {y = y} evaluates to refl if x and y are
-- definitionally equal.
unsafeEqual : ∀ {a} {A : Set a} {x y : A} → x ≡ y
unsafeEqual = primTrustMe... |
algebraic-stack_agda0000_doc_988 | {-# OPTIONS --without-K --safe #-}
module Definition.Conversion.Lift where
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.Weakening
open import Definition.Typed.Properties
open import Definition.Typed.EqRelInstance
open import Definit... |
algebraic-stack_agda0000_doc_989 | {-# OPTIONS --without-K #-}
open import Types
open import Functions
module Paths where
-- Identity type
infix 4 _≡_ -- \equiv
data _≡_ {i} {A : Set i} (a : A) : A → Set i where
refl : a ≡ a
_==_ = _≡_
_≢_ : ∀ {i} {A : Set i} → (A → A → Set i)
x ≢ y = ¬ (x ≡ y)
-- -- This should not be provable
-- K : {A : Set... |
algebraic-stack_agda0000_doc_990 | -- 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... |
algebraic-stack_agda0000_doc_991 | {-# OPTIONS --cubical --safe --postfix-projections #-}
module Data.Nat.Order where
open import Prelude
open import Data.Nat.Properties
open import Relation.Binary
<-trans : Transitive _<_
<-trans {zero} {suc y} {suc z} x<y y<z = tt
<-trans {suc x} {suc y} {suc z} x<y y<z = <-trans {x} {y} {z} x<y y<z
<-asym : Asymm... |
algebraic-stack_agda0000_doc_9824 | {-# OPTIONS --safe --without-K #-}
module JVM.Prelude where
open import Level public hiding (zero) renaming (suc to sucℓ)
open import Function public using (case_of_; _∘_; id; const)
open import Data.List using (List; _∷_; []; [_]) public
open import Data.Unit using (⊤; tt) public
open import Data.Nat using (ℕ; suc; ... |
algebraic-stack_agda0000_doc_9825 | module Coverage where
infixr 40 _::_
data List (A : Set) : Set where
[] : List A
_::_ : A -> List A -> List A
data D : Set where
c1 : D -> D
c2 : D
c3 : D -> D -> D -> D
c4 : D -> D -> D
f : D -> D -> D -> D -> List D
f (c3 a (c1 b) (c1 c2)) (c1 (c1 c)) d (c1 (c1 (c1 e))) = a :: b :: c :: d :: e :: []
... |
algebraic-stack_agda0000_doc_9826 | open import Data.Product using ( proj₁ ; proj₂ )
open import Relation.Binary.PropositionalEquality using ( _≡_ ; sym ; cong )
open import Relation.Unary using ( _⊆_ )
open import Web.Semantic.DL.ABox using ( ABox ; ⟨ABox⟩ ; Assertions )
open import Web.Semantic.DL.ABox.Interp using ( ⌊_⌋ ; ind )
open import Web.Semanti... |
algebraic-stack_agda0000_doc_9827 | ----------------------------------------------------------------------
-- Copyright: 2013, Jan Stolarek, Lodz University of Technology --
-- --
-- License: See LICENSE file in root of the repo --
-- Repo address: https://github.com/... |
algebraic-stack_agda0000_doc_9828 | {-# OPTIONS --without-K --safe #-}
module Definition.Typed.Consequences.NeTypeEq where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Consequences.Syntactic
open import Definition.Typed.Consequences.Injectivity
open import Definition.Typed.Consequences.Substitution
open impo... |
algebraic-stack_agda0000_doc_9829 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.Bouquet
open import homotopy.DisjointlyPointedSet
open import cohomology.Theory
module cohomology.DisjointlyPointedSet {i} (OT : OrdinaryTheory i) where
open OrdinaryTheory OT
open import cohomology.Bouquet OT
module _ (X : Ptd i)
... |
algebraic-stack_agda0000_doc_9830 | module tests.Forcing3 where
open import Prelude.Nat
-- {-
open import Prelude.IO
open import Prelude.Product
open import Prelude.Unit
-- -}
data _**_ (A B : Set) : Set where
_,_ : A -> B -> A ** B
data P {A B : Set} : A ** B -> Set where
_,_ : (x : A)(y : B) -> P (x , y)
data Q {A : Set} : A ** A -> Set where
... |
algebraic-stack_agda0000_doc_9831 | module Structure.Relator where
import Lvl
open import Functional using (_∘₂_)
open import Functional.Dependent
open import Lang.Instance
open import Logic
open import Logic.Propositional
open import Structure.Setoid
open import Structure.Relator.Names
open import Structure.Relator.Properties
open import Syntax.Functio... |
algebraic-stack_agda0000_doc_9832 |
module IID-Proof-Test where
open import LF
open import Identity
open import IID
open import IIDr
open import DefinitionalEquality
open import IID-Proof-Setup
η : {I : Set}(γ : OPg I)(U : I -> Set) -> Args γ U -> Args γ U
η (ι i) U _ = ★
η (σ A γ) U a = < a₀ | η (γ a₀) U a₁ >
where
a₀ = π₀ a
a₁ = π₁ a
η (... |
algebraic-stack_agda0000_doc_9833 |
module Nat where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
|
algebraic-stack_agda0000_doc_9834 | {-# OPTIONS --allow-unsolved-metas #-}
module StateSizedIO.GUI.BaseStateDependent where
open import Size renaming (Size to AgdaSize)
open import NativeIO
open import Function
open import Agda.Primitive
open import Level using (_⊔_) renaming (suc to lsuc)
open import Data.Product
open import Relation.Binary.Propositio... |
algebraic-stack_agda0000_doc_9835 | {-# OPTIONS --cubical --safe #-}
module Control.Monad.Levels.Definition where
open import Prelude
open import Data.Bag
data Levels (A : Type a) : Type a where
_∷_ : ⟅ A ⟆ → Levels A → Levels A
[] : Levels A
trail : [] ∷ [] ≡ []
trunc : isSet (Levels A)
|
algebraic-stack_agda0000_doc_9836 |
module Issue474 where
open import Common.Level
postulate
a b c : Level
A : Set a
B : Set b
C : Set c
data Foo : Set (lsuc lzero ⊔ (a ⊔ (b ⊔ c))) where
foo : (Set → A → B) → Foo
|
algebraic-stack_agda0000_doc_9837 | {-# OPTIONS --without-K --safe #-}
-- A cartesian functor preserves products (of cartesian categories)
module Categories.Functor.Cartesian where
open import Level
open import Categories.Category.Cartesian.Structure
open import Categories.Functor using (Functor; _∘F_)
open import Categories.Functor.Properties
import... |
algebraic-stack_agda0000_doc_9838 | module Text.Greek.Bible where
open import Data.Nat
open import Data.List
open import Data.String
open import Text.Greek.Script
data Word : Set where
word : (List Token) → String → Word
|
algebraic-stack_agda0000_doc_9839 | {-# OPTIONS --safe --warning=error --without-K #-}
open import Setoids.Setoids
open import Groups.Definition
open import Groups.Lemmas
open import Groups.Homomorphisms.Definition
open import Groups.QuotientGroup.Definition
open import Groups.Homomorphisms.Lemmas
open import Groups.Actions.Definition
open import Sets.E... |
algebraic-stack_agda0000_doc_16000 | {- NEW INTERP WITH RREC -}
{-# OPTIONS --no-termination-check #-}
open import Preliminaries
open import Preorder
open import Pilot-WithFlatrec
module Interp-WithFlatrec where
-- interpret complexity types as preorders
[_]t : CTp → PREORDER
[ unit ]t = unit-p
[ nat ]t = Nat , ♭nat-p
[ τ ->c τ₁ ]t = [ τ ]t ... |
algebraic-stack_agda0000_doc_16001 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- AVL trees
------------------------------------------------------------------------
-- AVL trees are balanced binary search trees.
-- The search tree invariant is specified using the technique
-- described by Co... |
algebraic-stack_agda0000_doc_16002 | module Issue4260.M where
postulate
F : Set → Set
syntax F X = G X
|
algebraic-stack_agda0000_doc_16003 | {-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
open import Light.Library.Data.Integer as ℤ using (ℤ ; zero ; successor)
open import Light.Package using (Package)
module Light.Literals.Integer ⦃ package : Package record { ℤ } ⦄ where
open import Light.Literals.Definition.Natural using... |
algebraic-stack_agda0000_doc_16004 | {-# OPTIONS --cubical --safe #-}
module Cubical.Data.Int.Base where
open import Cubical.Core.Everything
open import Cubical.Data.Nat
data Int : Type₀ where
pos : (n : ℕ) → Int
negsuc : (n : ℕ) → Int
sucInt : Int → Int
sucInt (pos n) = pos (suc n)
sucInt (negsuc zero) = pos zero
sucInt (negsuc (su... |
algebraic-stack_agda0000_doc_16005 | open import Relation.Binary.PropositionalEquality using
( _≡_ ; refl ; sym ; trans ; subst ; subst₂ ; cong ; cong₂ )
open import AssocFree.Util using ( δsubst₂ )
import AssocFree.STLambdaC.Typ
import AssocFree.STLambdaC.Exp
import AssocFree.STLambdaC.NF
import AssocFree.STLambdaC.Redn
module AssocFree.STLambdaC.E... |
algebraic-stack_agda0000_doc_16006 | module Duploid.Functor where
open import Preduploid
open import Duploid
import Preduploid.Functor as PF
open import Level
record Functor {o₁ ℓ₁ o₂ ℓ₂} (𝒞 : Duploid o₁ ℓ₁) (𝒟 : Duploid o₂ ℓ₂)
: Set (levelOfTerm 𝒞 ⊔ levelOfTerm 𝒟) where
private
module 𝒞 = Duploid.Duploid 𝒞
module 𝒟 = Duploid.Duploid... |
algebraic-stack_agda0000_doc_16007 | {-# OPTIONS --cubical --safe #-}
module Cubical.Structures.Ring where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Data.Sigma
open import Cubical.Foundations.SIP renaming (SNS-PathP to SNS)
open import Cubical.Structures.NA... |
algebraic-stack_agda0000_doc_16008 |
open import Common.Prelude hiding (_>>=_)
open import Common.Reflection
open import Common.Equality
open import Agda.Builtin.Sigma
record Functor (F : Set → Set) : Set₁ where
field
fmap : ∀ {A B} → (A → B) → F A → F B
IdF : Functor (λ A → A)
unquoteDef IdF =
defineFun IdF (clause (("x" , vArg unknown) ∷ ("f"... |
algebraic-stack_agda0000_doc_16009 |
open import Agda.Builtin.Reflection
open import Agda.Builtin.Unit
open import Agda.Builtin.String
infixr 4 _>>=_
_>>=_ = bindTC
login : String → String
login "secret" = "access granted"
login _ = "access denied"
macro
getDef : Name → Term → TC ⊤
getDef f hole =
getDefinition f >>= λ def → quoteTC def... |
algebraic-stack_agda0000_doc_16010 | module Everything where
import Prelude
import Category
--------------------------------------------------------------------------------
-- The syntax of STLC.
import STLC.Syntax
-- A simplification of Coquand 2002,
-- with de Bruijn indices and implicit substitutions.
import STLC.Coquand.Renaming
import STLC.Coqu... |
algebraic-stack_agda0000_doc_16011 | {-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Implementation.Standard.Relation.Sets where
open import Light.Level using (_⊔_)
open import Light.Variable.Levels
open import Light.Variable.Sets
open import Light.Library.Relation using (Base ; Kind ; Style)
open import Ligh... |
algebraic-stack_agda0000_doc_16012 | -- Agda program using the Iowa Agda library
open import bool
module PROOF-permlength
(Choice : Set)
(choose : Choice → 𝔹)
(lchoice : Choice → Choice)
(rchoice : Choice → Choice)
where
open import eq
open import bool
open import nat
open import list
open import maybe
--------------------------------------... |
algebraic-stack_agda0000_doc_16013 | module SHE-Prelude where
record Functor (T : Set -> Set) : Set1 where
field
-- OPERATIONS ----------------------------------------------
map : forall {X Y} -> (X -> Y) -> T X -> T Y
record Applicative (T : Set -> Set) : Set1 where
field
-- OPERATIONS ----------------------------------------------
... |
algebraic-stack_agda0000_doc_16014 | -- Note that this module assumes function extensionality
module guarded-recursion.prelude where
open import Level
public
using (_⊔_)
renaming (zero to ₀
;suc to ₛ)
open import Function
public
using (id; _∘_; _∘′_)
open impor... |
algebraic-stack_agda0000_doc_16015 | module Categories.Terminal where
open import Library
open import Categories
open import Categories.Sets
open Cat
record Term {a b} (C : Cat {a}{b})(T : Obj C) : Set (a ⊔ b) where
constructor term
field t : ∀{X} → Hom C X T
law : ∀{X}{f : Hom C X T} → t {X} ≅ f
OneSet : Term Sets ⊤
OneSet = record {t = λ ... |
algebraic-stack_agda0000_doc_9360 | -- {-# OPTIONS --without-K #-}
module kripke where
open import common
infixl 2 _▻_
infixl 3 _‘’_
infixr 1 _‘→’_
infixr 1 _‘‘→’’_
infixr 1 _ww‘‘‘→’’’_
infixl 3 _‘’ₐ_
infixl 3 _w‘‘’’ₐ_
infixr 2 _‘∘’_
infixr 2 _‘×’_
infixr 2 _‘‘×’’_
infixr 2 _w‘‘×’’_
mutual
data Context : Set where
ε : Context
_▻_ : (Γ : Conte... |
algebraic-stack_agda0000_doc_9361 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Which Maybe type which calls out to Haskell via the FFI
------------------------------------------------------------------------
{-# OPTIONS --without-K #-}
module Foreign.Haskell.Maybe where
open import Level... |
algebraic-stack_agda0000_doc_9362 | -- Andreas, 2017-01-18, issue #5 is fixed
-- reported by Ulf 2007-10-24
data Nat : Set where
zero : Nat
data Vec : Nat -> Set where
[] : Vec zero
f : (n : Nat) -> Vec n -> Nat
f n@._ [] = n
|
algebraic-stack_agda0000_doc_9363 | {-# OPTIONS --without-K #-}
module function.extensionality.core where
open import level using (lsuc; _⊔_)
open import equality.core
Extensionality : ∀ i j → Set (lsuc (i ⊔ j))
Extensionality i j = {X : Set i}{Y : Set j}
→ {f g : X → Y}
→ ((x : X) → f x ≡ g x)
→... |
algebraic-stack_agda0000_doc_9364 | -- This file gives the definition of Gaussian Integers, and common
-- operations on them.
{-# OPTIONS --without-K --safe #-}
module GauInt.Base where
open import Data.Bool using (Bool ; true ; false ; T ; not ; _∧_)
open import Data.Nat using (ℕ ; _≡ᵇ_)
open import Data.Integer renaming (-_ to -ℤ_ ; _-_ to _-ℤ_ ; _... |
algebraic-stack_agda0000_doc_9365 | module Category.Instance where
open import Level
open import Category.Core
𝟙 : Category _ _
𝟙 = record
{ Objects = record
{ Carrier = ⊤
; _≈_ = λ _ _ → ⊤
; isEquivalence = _
}
; Morphisms = record
{ Carrier = λ x → ⊤
; _≈_ = λ _ _ → ⊤
; isEquivalence =... |
algebraic-stack_agda0000_doc_9366 | {-# OPTIONS --enable-prop #-}
data TestProp : Prop where
p₁ p₂ : TestProp
data _≡Prop_ {A : Prop} (x : A) : A → Set where
refl : x ≡Prop x
p₁≢p₂ : {P : Prop} → p₁ ≡Prop p₂ → P
p₁≢p₂ ()
|
algebraic-stack_agda0000_doc_9367 | ------------------------------------------------------------------------
-- Up-to techniques for the standard coinductive definition of weak
-- bisimilarity
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
open import Labelled-transition-system
module Bisimilarit... |
algebraic-stack_agda0000_doc_9368 | {-# OPTIONS --safe #-}
module Cubical.Algebra.CommAlgebra.FGIdeal where
open import Cubical.Foundations.Prelude
open import Cubical.Data.FinData
open import Cubical.Data.Nat
open import Cubical.Data.Vec
open import Cubical.Algebra.CommRing
open import Cubical.Algebra.CommRing.FGIdeal renaming (generatedIdeal to gener... |
algebraic-stack_agda0000_doc_9369 | {-# OPTIONS --allow-unsolved-metas #-}
record ⊤ : Set where
constructor tt
data I : Set where
i : ⊤ → I
data D : I → Set where
d : D (i tt)
postulate
P : (x : I) → D x → Set
foo : (y : _) → P _ y
foo d = {!!}
|
algebraic-stack_agda0000_doc_9370 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Semigroup.Construct.Unit where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Algebra.Semigroup
open import Cubical.Data.Unit
import Cubical.Algebra.Magma.Construct.Unit as ⊤Magma
open ⊤Magma pu... |
algebraic-stack_agda0000_doc_9371 | ------------------------------------------------------------------------
-- Some properties that hold for Erased do not hold for every
-- accessible modality
------------------------------------------------------------------------
{-# OPTIONS --erased-cubical --safe #-}
import Equality.Path as P
module Erased.Counte... |
algebraic-stack_agda0000_doc_9372 |
data U : Set
T : U → Set
{-# NO_UNIVERSE_CHECK #-}
data U where
pi : (A : Set)(b : A → U) → U
T (pi A b) = (x : A) → T (b x)
|
algebraic-stack_agda0000_doc_9373 | module Examples.TrafficLight where
open import Data.Bool
open import Data.Empty
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Data.Unit
open import Relation.Binary.PropositionalEquality
open import Library
open import FStream.Core
open import FStream.FVec
open import FStream.Containers
open import CTL.Mod... |
algebraic-stack_agda0000_doc_9374 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.S2.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
data S² : Type₀ where
base : S²
surf : PathP (λ i → base ≡ base) refl refl
S²ToSetRec : ∀ {ℓ} {A : S² → Type ℓ}
→ ((x : S²) → isSet (A x)... |
algebraic-stack_agda0000_doc_9375 | {- 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
import LibraBFT.Impl.OBM.ECP-LBFT-OBM-Dif... |
algebraic-stack_agda0000_doc_15280 | ------------------------------------------------------------------------
-- Some results/examples related to CCS, implemented using the
-- coinductive definition of bisimilarity
------------------------------------------------------------------------
-- Unless anything else is stated the results (or statements, in the... |
algebraic-stack_agda0000_doc_15281 | {-# OPTIONS --verbose tc.constr.findInScope:15 #-}
module InstanceArguments.03-classes where
open import Algebra
open import Algebra.Structures
open import Algebra.FunctionProperties
open import Data.Nat.Properties as NatProps
open import Data.Nat
open import Data.Bool.Properties using (isCommutativeSemiring-∧-∨)
ope... |
algebraic-stack_agda0000_doc_15282 | {-# OPTIONS --universe-polymorphism #-}
module Categories.Yoneda where
open import Level
open import Data.Product
open import Categories.Support.Equivalence
open import Categories.Support.EqReasoning
open import Categories.Category
import Categories.Functor as Cat
open import Categories.Functor using (Functor; modul... |
algebraic-stack_agda0000_doc_15283 | module Common where
open import Data.String
using (String)
-- Basic sorts -----------------------------------------------------------------
Id : Set
Id = String
|
algebraic-stack_agda0000_doc_15284 | {-# OPTIONS --cubical #-}
module Multidimensional.Data.DirNum where
open import Multidimensional.Data.DirNum.Base public
open import Multidimensional.Data.DirNum.Properties public
|
algebraic-stack_agda0000_doc_15285 | module Data.List.Equiv.Id where
import Lvl
open import Functional
open import Function.Names as Names using (_⊜_)
import Function.Equals as Fn
open import Data.Boolean
open import Data.Option
open import Data.Option.Equiv.Id
open import Data.Option.Proofs using ()
open import Data.List
open import Data.List.Equiv... |
algebraic-stack_agda0000_doc_15286 | {-# OPTIONS --rewriting #-}
-- {-# OPTIONS -v rewriting:30 #-}
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality renaming (_≡_ to _≡≡_)
record Eq (t : Set) : Set₁ where
field
_≡_ : t → t → Set
open Eq {{...}}
{-# BUILTIN REWRITE _≡_ #-}
instance
eqN : Eq Nat
eqN = record { _≡_ = _≡≡_ }
pos... |
algebraic-stack_agda0000_doc_15287 | module MLib.Algebra.PropertyCode.RawStruct where
open import MLib.Prelude
open import MLib.Fin.Parts
open import MLib.Finite
open import Relation.Binary as B using (Setoid)
open import Data.List.Any using (Any; here; there)
open import Data.List.Membership.Propositional using (_∈_)
open import Data.Vec.N-ary
open ... |
algebraic-stack_agda0000_doc_15288 | {-# OPTIONS --universe-polymorphism #-}
module Issue293a where
open import Agda.Primitive
using (Level; _⊔_) renaming (lzero to zero; lsuc to suc)
------------------------------------------------------------------------
record RawMonoid c ℓ : Set (suc (c ⊔ ℓ)) where
infixl 7 _∙_
infix 4 _≈_
field
Carri... |
algebraic-stack_agda0000_doc_15289 | ----------------------------------------------------------------------
-- Copyright: 2013, Jan Stolarek, Lodz University of Technology --
-- --
-- License: See LICENSE file in root of the repo --
-- Repo address: https://github.com/... |
algebraic-stack_agda0000_doc_15290 | {-# OPTIONS --without-K --rewriting #-}
open import lib.Base
open import lib.PathGroupoid
module lib.PathFunctor where
{- Nondependent stuff -}
module _ {i j} {A : Type i} {B : Type j} (f : A → B) where
!-ap : {x y : A} (p : x == y)
→ ! (ap f p) == ap f (! p)
!-ap idp = idp
ap-! : {x y : A} (p : x == y)
... |
algebraic-stack_agda0000_doc_15291 | {-# OPTIONS --show-implicit #-}
-- {-# OPTIONS -v tc.constr.findInScope:10 #-} -- -v tc.conv.elim:25 #-}
-- Andreas, 2012-07-01
module Issue670a where
import Common.Level
open import Common.Equality
findRefl : {A : Set}(a : A){{p : a ≡ a}} → a ≡ a
findRefl a {{p}} = p
uip : {A : Set}{a : A} → findRefl a ≡ refl
uip =... |
algebraic-stack_agda0000_doc_15292 | module BasicIO where
open import Agda.Builtin.IO public
open import Data.Char
open import Data.List
{-# FOREIGN GHC import Control.Exception #-}
{-# FOREIGN GHC import System.Environment #-}
-- This is easier than using the IO functions in the standard library,
-- but it's technically not as type-safe. And it bypass... |
algebraic-stack_agda0000_doc_15293 | -- Andreas, 2016-12-20, issue #2350
-- Agda ignores a wrong instance parameter to a constructor
data D {{a}} (A : Set a) : Set a where
c : A → D A
test : ∀ ℓ {ℓ'} (A : Set ℓ') {B : Set ℓ} (a : A) → D A
test ℓ A a = c {{ℓ}} a
-- Expected Error:
-- .ℓ' != ℓ of type .Agda.Primitive.Level
-- when checking that the exp... |
algebraic-stack_agda0000_doc_15294 | {-# OPTIONS --universe-polymorphism #-}
module Categories.Free where
open import Categories.Category
open import Categories.Free.Core
open import Categories.Free.Functor
open import Categories.Graphs.Underlying
open import Categories.Functor
using (Functor)
open import Graphs.Graph
open import Graphs.GraphMorphism
... |
algebraic-stack_agda0000_doc_15295 | {-# OPTIONS --rewriting #-}
module DualContractive where
open import Data.Fin
open import Data.Maybe
open import Data.Nat hiding (_≤_ ; compare) renaming (_+_ to _+ℕ_)
open import Data.Nat.Properties
open import Data.Sum hiding (map)
open import Data.Product
open import Relation.Nullary
open import Relation.Binary.Pr... |
algebraic-stack_agda0000_doc_9760 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Pointwise lifting of relations to lists
------------------------------------------------------------------------
module Relation.Binary.List.Pointwise where
open import Function
open import Function.Inverse usi... |
algebraic-stack_agda0000_doc_9761 |
data ℕ : Set where
ze : ℕ
su : ℕ → ℕ
f : (ℕ → ℕ) → ℕ → ℕ
f g n = g n
syntax f g n = n , g
h : ℕ
h = ?
|
algebraic-stack_agda0000_doc_9762 | -- 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... |
algebraic-stack_agda0000_doc_9763 | ------------------------------------------------------------------------
-- The semantics given in OneSemantics and TwoSemantics are equivalent
------------------------------------------------------------------------
module Lambda.Substitution.Equivalence where
open import Codata.Musical.Notation
open import Lambda.... |
algebraic-stack_agda0000_doc_9764 | 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... |
algebraic-stack_agda0000_doc_9765 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Helper reflection functions
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Tactic.RingSolver.Core.ReflectionHelp where
open import Agda.Built... |
algebraic-stack_agda0000_doc_9766 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties related to All
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Maybe.Relation.Unary.All.Properties where
open import Data.Mayb... |
algebraic-stack_agda0000_doc_9767 | 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 → ℕ ×... |
algebraic-stack_agda0000_doc_9768 |
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... |
algebraic-stack_agda0000_doc_9769 | 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 = λ ()
|
algebraic-stack_agda0000_doc_9770 | {-# 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... |
algebraic-stack_agda0000_doc_9771 | 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}
... |
algebraic-stack_agda0000_doc_9772 | module CS410-Prelude where
------------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Standard Equipment for use in Exercises
------------------------------------------------------------------------------
-----------... |
algebraic-stack_agda0000_doc_9773 | ------------------------------------------------------------------------
-- Traditional non-dependent lenses
------------------------------------------------------------------------
{-# OPTIONS --cubical #-}
import Equality.Path as P
module Lens.Non-dependent.Traditional
{e⁺} (eq : ∀ {a p} → P.Equality-with-paths ... |
algebraic-stack_agda0000_doc_9774 | {-# 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... |
algebraic-stack_agda0000_doc_9775 | {-# 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.... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.