id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_56 | ------------------------------------------------------------------------
-- Values
------------------------------------------------------------------------
open import Atom
module Values (atoms : χ-atoms) where
open import Equality.Propositional
open import Prelude hiding (const)
open import Chi atoms
open import D... |
algebraic-stack_agda0000_doc_57 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Semigroup.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Function using (_∘_; id)
open import Cubical.Foundations.Equiv
ope... |
algebraic-stack_agda0000_doc_58 | {-# OPTIONS --prop #-}
data _≡_ {A : Set} (a : A) : A → Set where
refl : a ≡ a
postulate
funextP : {A : Prop} {B : A → Set} {f g : (a : A) → B a} (h : (x : A) → f x ≡ g x) → f ≡ g
test : {A : Prop} {B : A → Set} {f g : (a : A) → B a} (h : (x : A) → f x ≡ g x) → f ≡ g
test h = funextP h
|
algebraic-stack_agda0000_doc_59 | ------------------------------------------------------------------------------
-- Parametrized preorder reasoning
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #... |
algebraic-stack_agda0000_doc_60 | {-# OPTIONS --without-K #-}
module SubstLemmas where
open import Level using (Level)
open import Relation.Binary.PropositionalEquality
using (_≡_; refl; sym; trans; subst; cong₂)
open import Data.Nat using (ℕ; _+_; _*_)
------------------------------------------------------------------------------
-- Lemmas about ... |
algebraic-stack_agda0000_doc_61 | -- Andreas, 2015-12-29
-- with-clause stripping for record patterns
-- {-# OPTIONS -v tc.with.strip:60 #-}
record R : Set1 where
field
f : Set
test : R → Set1
test record{ f = a } with a
... | x = R
test1 : R → Set1
test1 record{ f = a } with a
test1 record{ f = a } | _ = R
test2 : R → Set1
test2 record{ f =... |
algebraic-stack_agda0000_doc_62 | {-# OPTIONS --without-K --safe #-}
module TypeTheory.HoTT.Data.Sum.Properties where
-- agda-stdlib
open import Level
open import Data.Empty
open import Data.Product
open import Data.Sum
open import Function.Base
open import Relation.Binary.PropositionalEquality
open import Relation.Nullary
-- agda-misc
open import T... |
algebraic-stack_agda0000_doc_63 | module Proofs where
open import Agda.Builtin.Equality
open import Relation.Binary.PropositionalEquality.Core
open import Data.Nat
open ≡-Reasoning
open import Classes
data Vec : ℕ → Set → Set where
Nil : ∀ {a} → Vec 0 a
Cons : ∀ {n A} → (a : A) → Vec n A → Vec (suc n) A
cons-cong : ∀ {n A} {a c : A} {b d : V... |
algebraic-stack_agda0000_doc_5984 | {-# OPTIONS --without-K #-}
module WithoutK8 where
data I : Set where
i : I
module M (x : I) where
data D : Set where
d : D
data P : D → Set where
postulate x : I
open module M′ = M x
Foo : P d → Set
Foo ()
|
algebraic-stack_agda0000_doc_5985 | module Human.List where
open import Human.Nat
infixr 5 _,_
data List {a} (A : Set a) : Set a where
end : List A
_,_ : (x : A) (xs : List A) → List A
{-# BUILTIN LIST List #-}
{-# COMPILE JS List = function(x,v) { if (x.length < 1) { return v["[]"](); } else { return v["_∷_"](x[0], x.slice(1)); } } #-}
{-# COMP... |
algebraic-stack_agda0000_doc_5986 | {-# OPTIONS --safe #-}
module Cubical.Data.Vec.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Univalence
import Cubical.Data.Empty as ⊥
open import Cubica... |
algebraic-stack_agda0000_doc_5987 |
module Oscar.Data.AList where
open import Oscar.Data.Equality
open import Oscar.Data.Nat
open import Oscar.Level
module _ {a} (A : Nat → Set a) where
data AList (n : Nat) : Nat → Set a where
[] : AList n n
_∷_ : ∀ {m} → A m → AList n m → AList n (suc m)
open import Oscar.Category
module Category' {a} {... |
algebraic-stack_agda0000_doc_5988 | module AKS.Primality where
open import AKS.Primality.Base public
open import AKS.Primality.Properties public
|
algebraic-stack_agda0000_doc_5989 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category.Core using (Category)
open import Categories.Comonad
-- Verbatim dual of Categories.Adjoint.Construction.Kleisli
module Categories.Adjoint.Construction.CoKleisli {o ℓ e} {C : Category o ℓ e} (M : Comonad C) where
open import Categories.Category.Const... |
algebraic-stack_agda0000_doc_5990 | {-# OPTIONS --safe #-}
{-
This uses ideas from Floris van Doorn's phd thesis and the code in
https://github.com/cmu-phil/Spectral/blob/master/spectrum/basic.hlean
-}
module Cubical.Homotopy.Spectrum where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Unit.Pointed
open import Cubical.Foundations.... |
algebraic-stack_agda0000_doc_5991 | {-
This file contains:
- the abelianization of groups as a HIT as proposed in https://arxiv.org/abs/2007.05833
The definition of the abelianization is not as a set-quotient, since the relation of abelianization is cumbersome to work with.
-}
{-# OPTIONS --safe #-}
module Cubical.Algebra.Group.Abelianization.Base... |
algebraic-stack_agda0000_doc_5992 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Category.Construction.Properties.Presheaves.Complete {o ℓ e} (C : Category o ℓ e) where
open import Data.Product
open import Function.Equality using (Π) renaming (_∘_ to _∙_)
open import Relation.Binary
open import Relation.Binary.C... |
algebraic-stack_agda0000_doc_5993 | {-# OPTIONS --cubical-compatible #-}
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
Test : Set
Test = ℕ
test : Test → ℕ
test zero = zero
test (suc n) = test n
|
algebraic-stack_agda0000_doc_5994 | module Serializer where
open import Data.List
open import Data.Fin hiding (_+_)
open import Data.Nat
open import Data.Product
open import Data.Bool
open import Function using (_∘_ ; _$_ ; _∋_)
open import Function.Injection hiding (_∘_)
open import Function.Surjection hiding (_∘_)
open import Function.Bijection hiding... |
algebraic-stack_agda0000_doc_5995 | ------------------------------------------------------------------------------
-- Test the consistency of FOTC.Data.List
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymor... |
algebraic-stack_agda0000_doc_5996 | open import Data.Product using ( _×_ ; _,_ )
open import Data.Sum using ( inj₁ ; inj₂ )
open import Relation.Binary.PropositionalEquality using ( _≡_ ; refl )
open import Relation.Unary using ( _∈_ ; _⊆_ )
open import Web.Semantic.DL.ABox using
( ABox ; Assertions ; ⟨ABox⟩ ; ε ; _,_ ; _∼_ ; _∈₁_ ; _∈₂_ )
open import ... |
algebraic-stack_agda0000_doc_5997 | {-# OPTIONS --allow-unsolved-metas --no-termination-check
#-}
module Bag where
import Prelude
import Equiv
import Datoid
import Eq
import Nat
import List
import Pos
open Prelude
open Equiv
open Datoid
open Eq
open Nat
open List
abstract
----------------------------------------------------------------------
-- Bag... |
algebraic-stack_agda0000_doc_5998 | {-# OPTIONS --without-K --safe #-}
-- | Operations that ensure a cycle traverses a particular element
-- at most once.
module Dodo.Binary.Cycle where
-- Stdlib import
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; _≢_; refl)
open import Level using (Level; _⊔_)
open import Function using (_∘_)... |
algebraic-stack_agda0000_doc_5999 | {-# OPTIONS --without-K --safe #-}
-- A "canonical" presentation of limits in Setoid.
--
-- These limits are obviously isomorphic to those created by
-- the Completeness proof, but are far less unweildy to work with.
-- This isomorphism is witnessed by Categories.Diagram.Pullback.up-to-iso
module Categories.Category.... |
algebraic-stack_agda0000_doc_5872 | {-# OPTIONS --cubical --safe #-}
module Data.Bag where
open import Prelude
open import Algebra
open import Path.Reasoning
infixr 5 _∷_
data ⟅_⟆ (A : Type a) : Type a where
[] : ⟅ A ⟆
_∷_ : A → ⟅ A ⟆ → ⟅ A ⟆
com : ∀ x y xs → x ∷ y ∷ xs ≡ y ∷ x ∷ xs
trunc : isSet ⟅ A ⟆
record Elim {a ℓ}
... |
algebraic-stack_agda0000_doc_5873 |
record R (A : Set) : Set₁ where
field
P : A → Set
p : (x : A) → P x
module M (r : (A : Set) → R A) where
open module R′ {A : Set} = R (r A) public
postulate
r : (A : Set) → R A
A : Set
open M r
internal-error : (x : A) → P x
internal-error x = p
|
algebraic-stack_agda0000_doc_5874 | -- Andreas, 2017-08-23, issue #2714
-- Make sure we produce a warning about missing main function
-- even though we import a module with --no-main.
open import Issue2712
|
algebraic-stack_agda0000_doc_5875 |
module _ where
open import Common.Prelude
case_of_ : {A B : Set} → A → (A → B) → B
case x of f = f x
{-# INLINE case_of_ #-}
patlam : Nat → Nat
patlam zero = zero
patlam (suc n) =
case n of λ
{ zero → zero
; (suc m) → m + patlam n
}
static : {A : Set} → A → A
static x = x
{-# STATIC static #-}
-- The s... |
algebraic-stack_agda0000_doc_5876 | import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; sym; cong; cong₂; cong-app)
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_; step-≡; _∎)
open import Function using (_∘_)
open import Data.Nat using (ℕ; zero; suc)
open import Data.Fin hiding (_+_; #_)
open import DeBruijn
postulate
extensionali... |
algebraic-stack_agda0000_doc_5877 | module Category.Functor.Either where
open import Agda.Primitive using (_⊔_)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Category.Functor using (RawFunctor ; module RawFunctor )
open import Category.Applicative using (RawApplicative; module RawApplicative)
open import Function using (_∘_)
Either ... |
algebraic-stack_agda0000_doc_5878 | {-# OPTIONS --cubical --safe #-}
module Cubical.HITs.FiniteMultiset.Base where
open import Cubical.Foundations.Prelude
open import Cubical.HITs.SetTruncation
open import Cubical.Foundations.HLevels
private
variable
A : Type₀
infixr 5 _∷_
data FMSet (A : Type₀) : Type₀ where
[] : FMSet A
_∷_ : (x : A)... |
algebraic-stack_agda0000_doc_5879 | -- Σ type (also used as existential) and
-- cartesian product (also used as conjunction).
{-# OPTIONS --without-K --safe #-}
module Tools.Product where
open import Agda.Primitive
open import Agda.Builtin.Sigma public using (Σ; _,_)
open import Agda.Builtin.Sigma using (fst; snd)
infixr 2 _×_
-- Dependent pair type... |
algebraic-stack_agda0000_doc_5880 |
-- When defining types by recursion it is sometimes difficult to infer implicit
-- arguments. This module illustrates the problem and shows how to get around
-- it for the example of vectors of a given length.
module DataByRecursion where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
data Nil : Set where
... |
algebraic-stack_agda0000_doc_5881 | module FSC where
-- focused sequent calculus
{-
open import Relation.Binary.PropositionalEquality
open import Data.Nat hiding (_>_)
-}
open import StdLibStuff
open import Syntax
data FSC-Ctx (n : ℕ) : Ctx n → Set where
ε : FSC-Ctx n ε
_∷_ : {Γ : Ctx n} → (t : Type n) → FSC-Ctx n Γ → FSC-Ctx n (t ∷ Γ)
_∷h_ : {Γ... |
algebraic-stack_agda0000_doc_5882 | -- Andreas, 2016-09-20, issue #2197 reported by m0davis
{-# OPTIONS --allow-unsolved-metas #-}
-- {-# OPTIONS -v tc.pos:20 -v tc.meta.eta:20 #-}
record R : Set where
inductive
field
foo : R
bar : R
bar = {!!}
-- This used to loop due to infinite eta-expansion.
-- Should check now.
|
algebraic-stack_agda0000_doc_5883 | module Common.Issue481ParametrizedModule (A : Set1) where
id : A → A
id x = x
postulate
Bla : Set
|
algebraic-stack_agda0000_doc_5884 | test = forall _⦇_ → Set
|
algebraic-stack_agda0000_doc_5885 | {-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
module lib.types.Sigma where
-- pointed [Σ]
⊙Σ : ∀ {i j} (X : Ptd i) → (de⊙ X → Ptd j) → Ptd (lmax i j)
⊙Σ ⊙[ A , a₀ ] Y = ⊙[ Σ A (de⊙ ∘ Y) , (a₀ , pt (Y a₀)) ]
-- Cartesian product
_×_ : ∀ {i j} (A : Type i) (B : Type j) → Type (lmax i j)
A × B = Σ A (... |
algebraic-stack_agda0000_doc_5886 | {-# OPTIONS --prop --without-K --rewriting #-}
-- The basic CBPV metalanguage, extended with parallelism.
open import Calf.CostMonoid
module Calf.ParMetalanguage (parCostMonoid : ParCostMonoid) where
open ParCostMonoid parCostMonoid
open import Calf.Prelude
open import Calf.Metalanguage
open import Calf.Step costM... |
algebraic-stack_agda0000_doc_5887 | {-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Lists.Lists
open import Numbers.BinaryNaturals.Definition
open import Maybe
open import Numbers.BinaryNaturals.SubtractionGo
module Numbers.BinaryNaturals.SubtractionGoPreservesCanonicalRight where
goPreservesCanonicalRightZer... |
algebraic-stack_agda0000_doc_128 | {-# OPTIONS --cubical --safe --postfix-projections #-}
module Data.Bool.Properties where
open import Prelude
open import Data.Bool
open import Data.Unit.Properties
T? : ∀ x → Dec (T x)
T? x .does = x
T? false .why = ofⁿ id
T? true .why = ofʸ tt
isPropT : ∀ x → isProp (T x)
isPropT false = isProp⊥
isPropT true = i... |
algebraic-stack_agda0000_doc_129 | {-# OPTIONS --without-K #-}
module P where
open import Data.Empty
open import Data.Unit
open import Data.Sum
open import Data.Product
open import Relation.Binary.PropositionalEquality
------------------------------------------------------------------------------
-- For now, a groupoid is just a set
G... |
algebraic-stack_agda0000_doc_130 | -- Basic intuitionistic logic of proofs, without ∨, ⊥, or +.
-- Gentzen-style formalisation of syntax with context pairs.
-- Normal forms and neutrals.
module BasicILP.Syntax.DyadicGentzenNormalForm where
open import BasicILP.Syntax.DyadicGentzen public
-- Derivations.
mutual
-- Normal forms, or introductions.
... |
algebraic-stack_agda0000_doc_131 | module EquationalTheory where
open import Library
open import Syntax
open import RenamingAndSubstitution
-- Single collapsing substitution.
sub1 : ∀{Γ σ τ} → Tm Γ σ → Tm (Γ , σ) τ → Tm Γ τ
sub1 {Γ}{σ}{τ} u t = sub (subId , u) t
-- Typed β-η-equality.
data _≡βη_ {Γ : Cxt} : ∀{σ} → Tm Γ σ → Tm Γ σ → Set where
-- ... |
algebraic-stack_agda0000_doc_132 | open import Relation.Binary.Core
module InsertSort.Impl2.Correctness.Order {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_) where
open import Data.List
open import Function using (_∘_)
open import InsertSort.Impl2 _≤_ tot≤
open import List.Sorted _≤_
open import OList _≤_
open imp... |
algebraic-stack_agda0000_doc_133 | {-# OPTIONS --prop #-}
open import Agda.Builtin.Nat
data T : Nat → Prop where
To : T zero
Tn : ∀ n → T n
ummm : ∀ n → T n → {! !}
ummm n t = {! t !}
|
algebraic-stack_agda0000_doc_134 | -- A variant of code reported by Andreas Abel.
{-# OPTIONS --guardedness --sized-types #-}
open import Common.Coinduction renaming (∞ to Delay)
open import Common.Size
open import Common.Product
data ⊥ : Set where
record Stream (A : Set) : Set where
inductive
constructor delay
field
force : Delay (A × Str... |
algebraic-stack_agda0000_doc_135 |
open import Oscar.Prelude
open import Oscar.Class
open import Oscar.Class.IsPrecategory
open import Oscar.Class.IsCategory
open import Oscar.Class.HasEquivalence
open import Oscar.Class.Reflexivity
open import Oscar.Class.Symmetry
open import Oscar.Class.Transextensionality
open import Oscar.Class.Transassociativity
o... |
algebraic-stack_agda0000_doc_136 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Floats
------------------------------------------------------------------------
module Data.Float where
open import Data.Bool hiding (_≟_)
open import Relation.Nullary.Decidable
open import Relation.Nullary
ope... |
algebraic-stack_agda0000_doc_137 | module Issue2447.Type-error where
import Issue2447.M
Rejected : Set
Rejected = Set
|
algebraic-stack_agda0000_doc_138 | {-# OPTIONS --safe --warning=error --without-K #-}
open import Groups.Homomorphisms.Definition
open import Groups.Definition
open import Setoids.Setoids
open import Rings.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
module Rings.Homomorphisms.Definition where
record RingHom {m n o p : _} {A... |
algebraic-stack_agda0000_doc_139 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Relation.Binary.Base where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundat... |
algebraic-stack_agda0000_doc_140 | module Thesis.SIRelBigStep.Types where
open import Data.Empty
open import Data.Product
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
open import Relation.Binary hiding (_⇒_)
data Type : Set where
_⇒_ : (σ τ : Type) → Type
pair : (σ τ : Type) → Type
nat : Type
infixr 20 _⇒_
open... |
algebraic-stack_agda0000_doc_141 | module MLib.Prelude where
open import MLib.Prelude.FromStdlib public
module Fin where
open import MLib.Prelude.Fin public
open Fin using (Fin; zero; suc) hiding (module Fin) public
|
algebraic-stack_agda0000_doc_142 | open import Agda.Builtin.Nat
data Vec (A : Set) : Nat → Set where
[] : Vec A 0
_∷_ : ∀ {n} → A → Vec A n → Vec A (suc n)
infixr 5 _∷_ _++_
_++_ : ∀ {A m n} → Vec A m → Vec A n → Vec A (m + n)
[] ++ ys = ys
(x ∷ xs) ++ ys = x ∷ xs ++ ys
T : ∀ {A n} → Vec A n → Set
T [] = Nat
T (x ∷ xs) = Vec Nat 0
foo : ... |
algebraic-stack_agda0000_doc_143 | module HelloWorld where
open import Common.IO
open import Common.Unit
main : IO Unit
main = putStr "Hello World"
|
algebraic-stack_agda0000_doc_17248 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Examples of decision procedures and how to use them
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module README.Decidability where
-- Reflects and ... |
algebraic-stack_agda0000_doc_17249 | {-# OPTIONS --cubical-compatible #-}
module WithoutK2 where
-- Equality defined with two indices.
data _≡_ {A : Set} : A → A → Set where
refl : ∀ x → x ≡ x
K : {A : Set} (P : {x : A} → x ≡ x → Set) →
(∀ x → P (refl x)) →
∀ {x} (x≡x : x ≡ x) → P x≡x
K P p (refl x) = p x
|
algebraic-stack_agda0000_doc_17250 |
open import SOAS.Common
open import SOAS.Families.Core
open import Categories.Object.Initial
open import SOAS.Coalgebraic.Strength
import SOAS.Metatheory.MetaAlgebra
-- Substitution structure by initiality
module SOAS.Metatheory.Substitution {T : Set}
(⅀F : Functor 𝔽amiliesₛ 𝔽amiliesₛ) (⅀:Str : Strength ⅀F)
(𝔛... |
algebraic-stack_agda0000_doc_17251 |
module BuiltinConstructorsNeededForLiterals where
data Nat : Set where
zero : Nat → Nat
suc : Nat → Nat
{-# BUILTIN NATURAL Nat #-}
data ⊥ : Set where
empty : Nat → ⊥
empty (zero n) = empty n
empty (suc n) = empty n
bad : ⊥
bad = empty 0
|
algebraic-stack_agda0000_doc_17252 | {-# OPTIONS --without-K #-}
open import HoTT
open import homotopy.HSpace renaming (HSpaceStructure to HSS)
open import homotopy.WedgeExtension
module homotopy.Pi2HSusp where
module Pi2HSusp {i} (A : Type i) (gA : has-level ⟨ 1 ⟩ A)
(cA : is-connected ⟨0⟩ A) (A-H : HSS A)
(μcoh : HSS.μe- A-H (HSS.e A-H) == HSS.μ-... |
algebraic-stack_agda0000_doc_17253 | open import Categories
open import Monads
open import Level
import Monads.CatofAdj
module Monads.CatofAdj.TermAdjHom
{c d}
{C : Cat {c}{d}}
(M : Monad C)
(A : Cat.Obj (Monads.CatofAdj.CatofAdj M {c ⊔ d}{c ⊔ d})) where
open import Library
open import Functors
open import Adjunctions
open import Monads.EM M
o... |
algebraic-stack_agda0000_doc_17254 | {-# OPTIONS --without-K --rewriting #-}
open import lib.Base
open import lib.PathFunctor
open import lib.PathGroupoid
open import lib.Equivalence
{- Structural lemmas about paths over paths
The lemmas here have the form
[↓-something-in] : introduction rule for the something
[↓-something-out] : elimination rule for... |
algebraic-stack_agda0000_doc_17255 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- The lifting of a strict order to incorporate a new supremum
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
-- This module is designed to be used with... |
algebraic-stack_agda0000_doc_17256 | module _ where
module A where
infix 2 _↑
infix 1 c
data D : Set where
● : D
_↑ : D → D
c : {x y : D} → D
syntax c {x = x} {y = y} = x ↓ y
module B where
infix 1 c
data D : Set where
c : {y x : D} → D
syntax c {y = y} {x = x} = y ↓ x
open A
open B
rejected : A.D
rejected = ● ↑ ↓... |
algebraic-stack_agda0000_doc_17257 | {-# OPTIONS --cubical --safe #-}
module Issue4949 where
open import Agda.Builtin.Cubical.Path
open import Agda.Primitive.Cubical renaming (primIMax to _∨_)
open import Agda.Builtin.Unit
open import Agda.Builtin.Sigma
open import Agda.Builtin.Cubical.Glue renaming (prim^glue to glue)
idIsEquiv : ∀ {ℓ} (A : Set ℓ) → i... |
algebraic-stack_agda0000_doc_17258 | -- Problem 4: ``50 shades of continuity''
{-
C(f) = ∀ c : X. Cat(f,c)
Cat(f,c) = ∀ ε > 0. ∃ δ > 0. Q(f,c,ε,δ)
Q(f,c,ε,δ) = ∀ x : X. abs(x - c) < δ ⇒ abs(f x - f c) < ε
C'(f) = ∃ getδ : X -> RPos -> RPos. ∀ c : X. ∀ ε > 0. Q(f,c,ε,getδ c ε)
4a: Define UC(f):
UC(f) = ∀ ε > 0. ∃ δ > 0. ∀ y : X.... |
algebraic-stack_agda0000_doc_17259 | -- {-# OPTIONS --show-implicit --show-irrelevant #-}
module Data.QuadTree.LensProofs.Valid-LensA where
open import Haskell.Prelude renaming (zero to Z; suc to S)
open import Data.Lens.Lens
open import Data.Logic
open import Data.QuadTree.InternalAgda
open import Agda.Primitive
open import Data.Lens.Proofs.LensLaws
ope... |
algebraic-stack_agda0000_doc_17260 | {- 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.Concrete.System
open imp... |
algebraic-stack_agda0000_doc_17261 | {- https://lists.chalmers.se/pipermail/agda/2013/006033.html http://code.haskell.org/~Saizan/unification/ 18-Nov-2013 Andrea Vezzosi -}
module UnifyProof2 where
open import Data.Fin using (Fin; suc; zero)
open import Data.Nat hiding (_≤_)
open import Relation.Binary.PropositionalEquality
open import Function
open impo... |
algebraic-stack_agda0000_doc_17262 | {-# OPTIONS --without-K #-}
module sets.fin.ordering where
open import equality.core
open import function.isomorphism
open import sets.core
open import sets.fin.core
open import sets.fin.properties
import sets.nat.ordering as N
_<_ : ∀ {n} → Fin n → Fin n → Set
i < j = toℕ i N.< toℕ j
infixr 4 _<_
ord-from-ℕ : ∀ {n}... |
algebraic-stack_agda0000_doc_17263 | module ComplexIMPORT where
{-# IMPORT Prelude as P #-}
|
algebraic-stack_agda0000_doc_16960 | module Impure.STLCRef.Properties.Soundness where
open import Data.Nat
open import Data.Sum
open import Data.Product as Pr
open import Data.List
open import Data.Vec hiding (_∷ʳ_)
open import Data.Star
open import Function
open import Extensions.List
open import Relation.Binary.PropositionalEquality as P
open import R... |
algebraic-stack_agda0000_doc_16961 | {-# OPTIONS --without-K --safe #-}
module Categories.Adjoint.Alternatives where
open import Level
open import Categories.Adjoint
open import Categories.Category
open import Categories.Functor renaming (id to idF)
open import Categories.NaturalTransformation
import Categories.Morphism.Reasoning as MR
private
vari... |
algebraic-stack_agda0000_doc_16962 | -- Trying to define ≤ as a datatype in Prop doesn't work very well:
{-# OPTIONS --enable-prop #-}
open import Agda.Builtin.Nat
data _≤'_ : Nat → Nat → Prop where
zero : (y : Nat) → zero ≤' y
suc : (x y : Nat) → x ≤' y → suc x ≤' suc y
≤'-ind : (P : (m n : Nat) → Set)
→ (pzy : (y : Nat) → P zero y)
... |
algebraic-stack_agda0000_doc_16963 |
module Lookup where
data Bool : Set where
false : Bool
true : Bool
data IsTrue : Bool -> Set where
isTrue : IsTrue true
data List (A : Set) : Set where
[] : List A
_::_ : A -> List A -> List A
data _×_ (A B : Set) : Set where
_,_ : A -> B -> A × B
module Map
(Key : Set)
(_==_ : Key -> Key -> B... |
algebraic-stack_agda0000_doc_16964 | -- Andreas, 2014-03-05, reported by xcycl.xoo, Mar 30, 2009
-- {-# OPTIONS -v tc.with:60 #-}
open import Common.Prelude renaming (Nat to ℕ; module Nat to ℕ)
data Nat : ℕ → Set where
i : (k : ℕ) → Nat k
toNat : (n : ℕ) → Nat n
toNat n = i n
fun : (n : ℕ) → ℕ
fun n with toNat n
fun .m | i m with toNat m
fun .Set | ... |
algebraic-stack_agda0000_doc_16965 | id : Set → Set
id A = A
|
algebraic-stack_agda0000_doc_16966 | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Correctness of differentiation with the Nehemiah plugin.
------------------------------------------------------------------------
module Nehemiah.Change.Correctness where
-- The denotational properties of the `der... |
algebraic-stack_agda0000_doc_16967 | {-# OPTIONS --safe --warning=error --without-K #-}
open import Groups.Definition
open import Setoids.Setoids
open import Sets.EquivalenceRelations
open import Groups.Homomorphisms.Definition
open import Groups.Homomorphisms.Lemmas
open import Groups.Subgroups.Definition
open import Groups.Lemmas
open import Groups.Abe... |
algebraic-stack_agda0000_doc_16968 | {-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.types.Bool
open import lib.types.Empty
open import lib.types.Lift
open import lib.types.Sigma
open import lib.types.Pi
module lib.types.Coproduct where
module _ {i j} {A : Type i} {B : Type j} where
Coprod-elim : ∀ {k} {C : A ⊔ B → Typ... |
algebraic-stack_agda0000_doc_16969 | module nat-to-string where
open import bool
open import char
open import eq
open import list
open import maybe
open import nat
open import nat-division
open import nat-thms
open import product
open import string
open import termination
ℕ-to-digitsh : (base : ℕ) → 1 < base ≡ tt → (x : ℕ) → ↓𝔹 _>_ x → 𝕃 ℕ
ℕ-to-digits... |
algebraic-stack_agda0000_doc_16970 | {-# OPTIONS --type-in-type #-}
module Compilation.Encode.Examples where
open import Context
open import Type.Core
open import Compilation.Data
open import Compilation.Encode.Core
open import Function
open import Data.Product
open import Data.List.Base
module ProdTreeTreeExample where
open ProdTreeTree
open prod... |
algebraic-stack_agda0000_doc_16971 | module FFI.Data.Bool where
{-# FOREIGN GHC import qualified Data.Bool #-}
data Bool : Set where
false : Bool
true : Bool
{-# COMPILE GHC Bool = data Data.Bool.Bool (Data.Bool.False|Data.Bool.True) #-}
|
algebraic-stack_agda0000_doc_16972 | module test where
|
algebraic-stack_agda0000_doc_16973 | module Data.Either.Equiv where
import Lvl
open import Data.Either as Either
open import Structure.Function.Domain
open import Structure.Function
open import Structure.Operator
open import Structure.Setoid
open import Type
private variable ℓ ℓₑ ℓₑ₁ ℓₑ₂ : Lvl.Level
private variable A B : Type{ℓ}
record Extensiona... |
algebraic-stack_agda0000_doc_16974 | {-# OPTIONS --without-K #-}
open import HoTT
open import homotopy.SuspProduct
open import homotopy.SuspSmash
open import homotopy.JoinSusp
open import cohomology.Theory
module cohomology.SphereProduct {i} (CT : CohomologyTheory i) where
open CohomologyTheory CT
open import cohomology.Wedge CT
module _ (n : ℤ) (m : ... |
algebraic-stack_agda0000_doc_16975 | ------------------------------------------------------------------------
-- A type soundness result
------------------------------------------------------------------------
module Lambda.Closure.Functional.Type-soundness where
import Category.Monad.Partiality as Partiality
open import Category.Monad.Partiality.All as... |
algebraic-stack_agda0000_doc_5952 | {-# OPTIONS --without-K --safe #-}
module Categories.Category.Instance.Properties.Setoids where
open import Level
open import Data.Product using (Σ; proj₁; proj₂; _,_; Σ-syntax; _×_; -,_)
open import Function.Equality using (Π)
open import Relation.Binary using (Setoid; Preorder; Rel)
open import Relation.Binary.Prop... |
algebraic-stack_agda0000_doc_5953 | open import Agda.Primitive
variable
ℓ : Level
A : Set ℓ
P : A → Set ℓ
f : (x : A) → P x
postulate
R : (a : Level) → Set (lsuc a)
r : (a : Level) → R a
Id : (a : Level) (A : Set a) → A → A → Set a
cong₂ : (a b c : Level) (A : Set a) (B : Set b) (C : Set c) (x y : A) (u v : B)
(f : A → B → C)... |
algebraic-stack_agda0000_doc_5954 |
open import Oscar.Prelude
open import Oscar.Class
open import Oscar.Class.Reflexivity
module Oscar.Class.Reflexivity.Function where
module _
{a}
where
instance
𝓡eflexivityFunction : Reflexivity.class Function⟦ a ⟧
𝓡eflexivityFunction .⋆ = ¡
|
algebraic-stack_agda0000_doc_5955 | -- https://github.com/idris-lang/Idris-dev/blob/4e704011fb805fcb861cc9a1bd68a2e727cefdde/libs/contrib/Data/Nat/Fib.idr
{-# OPTIONS --without-K --safe #-}
-- agda-stdlib
open import Algebra
module Math.NumberTheory.Fibonacci.Generic
{c e} (CM : CommutativeMonoid c e)
(v0 v1 : CommutativeMonoid.Carrier CM)
where... |
algebraic-stack_agda0000_doc_5956 |
module Lib.Maybe where
data Maybe (A : Set) : Set where
nothing : Maybe A
just : A -> Maybe A
{-# COMPILE GHC Maybe = data Maybe (Nothing | Just) #-}
|
algebraic-stack_agda0000_doc_5957 |
module Subst where
open import Prelude
open import Lambda
infix 100 _[_] _[_:=_] _↑
infixl 100 _↑_ _↑ˢ_ _↑ˣ_ _↓ˣ_
infixl 60 _-_
{-
_-_ : {τ : Type}(Γ : Ctx) -> Var Γ τ -> Ctx
ε - ()
Γ , τ - vz = Γ
Γ , τ - vs x = (Γ - x) , τ
wkˣ : {Γ : Ctx}{σ τ : Type}
(x : Var Γ σ) -> Var (Γ - x) τ -> Var Γ τ
wkˣ vz ... |
algebraic-stack_agda0000_doc_5958 | {-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.IdUniv {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.... |
algebraic-stack_agda0000_doc_5959 | {-# OPTIONS --cubical --safe --postfix-projections #-}
module Cardinality.Finite.Structure where
open import Prelude
open import Data.Fin
open import Data.Nat
open import Data.Nat.Properties
private
variable
n m : ℕ
liftˡ : ∀ n m → Fin m → Fin (n + m)
liftˡ zero m x = x
liftˡ (suc n) m x = fs (liftˡ n m x)... |
algebraic-stack_agda0000_doc_5960 | module Data.Signed where
open import Data.Bit using
(Bit
; b0
; b1
; Bits-num
; Bits-neg
; Overflowing
; _overflow:_
; result
; carry
; WithCarry
; _with-carry:_
; toBool
; tryToFinₙ
; !ₙ
; _⊕_
; _↔_
) renaming
( _+_ to bit+
; _-_ to bit-
; ! to bit!
; _&_ to bit&
; _~|_ to ... |
algebraic-stack_agda0000_doc_5961 | {-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Functions
open import Setoids.Setoids
open import Setoids.Subset
open import Graphs.Definition
open import Sets.FinSet.Definition
open import Numbers.Naturals.Semiring
o... |
algebraic-stack_agda0000_doc_5962 | {-# OPTIONS --sized-types #-}
module SizedTypesRigidVarClash where
postulate
Size : Set
_^ : Size -> Size
∞ : Size
{-# BUILTIN SIZE Size #-}
{-# BUILTIN SIZESUC _^ #-}
{-# BUILTIN SIZEINF ∞ #-}
data Nat : {size : Size} -> Set where
zero : {size : Size} -> Nat {size ^}
suc : {size : Size} -> Nat {s... |
algebraic-stack_agda0000_doc_5963 | -- Andreas, 2017-01-18, issue #2413
-- As-patterns of variable patterns
data Bool : Set where
true false : Bool
test : Bool → Bool
test x@y = {!x!} -- split on x
test1 : Bool → Bool
test1 x@_ = {!x!} -- split on x
test2 : Bool → Bool
test2 x@y = {!y!} -- split on y
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.