id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_7268 | {-# OPTIONS -v treeless.opt:20 #-}
-- Tests for case-on-case simplification.
module _ where
open import Common.Prelude
open import Common.Integer
data Cmp : Set where
less equal greater : Cmp
isLess : Cmp → Bool
isLess less = true
isLess equal = false
isLess greater = false
{-# INLINE isLess #-}
postulate _-_ : I... |
algebraic-stack_agda0000_doc_7269 | -- Andreas, AIM XIII, 2011-04-07
-- {-# OPTIONS -v tc.rec.proj:50 #-}
module DependentIrrelevance where
open import Common.Irrelevance
ElimSq = {A : Set}(P : Squash A -> Set)
(ih : .(a : A) -> P (squash a)) ->
(a- : Squash A) -> P a-
elimSq : ElimSq
elimSq P ih (squash a) = ih a
elimSq' : ElimSq
el... |
algebraic-stack_agda0000_doc_7270 | {-# OPTIONS --without-K --safe #-}
module Categories.Functor.Properties where
-- Properties valid of all Functors
open import Level
open import Data.Product using (proj₁; proj₂; _,_; _×_; Σ)
open import Function.Surjection using (Surjective)
open import Function.Equivalence using (Equivalence)
open import Function.Equ... |
algebraic-stack_agda0000_doc_7271 | module RandomAccessList.Standard where
open import RandomAccessList.Standard.Core
open import RandomAccessList.Standard.Core.Properties
open import BuildingBlock.BinaryLeafTree using (BinaryLeafTree; Node; Leaf)
import BuildingBlock.BinaryLeafTree as BLT
open import Data.Empty using (⊥; ⊥-elim)
open import Data.Unit ... |
algebraic-stack_agda0000_doc_7272 | module LearnYouAn2 where
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
_+_ : ℕ → ℕ → ℕ
zero + n = n
(suc n) + n′ = suc (n + n′)
data _even : ℕ → Set where
ZERO : zero even
STEP : ∀ x → x even → (suc (suc x)) even
-- To prove four is even
proof₁ : suc (suc (suc (suc zero))) even
proof₁ = STEP (suc (suc zer... |
algebraic-stack_agda0000_doc_7273 | -- Andreas, 2019-08-10
record R : Set₁ where
indutive
field A : Set
-- The error message is strange:
-- This declaration is illegal in a record before the last field
-- when scope checking the declaration
-- record R where
-- indutive
-- field A : Set
|
algebraic-stack_agda0000_doc_7274 | {-# OPTIONS --cubical --safe --postfix-projections #-}
module Categories where
open import Prelude
open import Cubical.Foundations.HLevels
record PreCategory ℓ₁ ℓ₂ : Type (ℓsuc (ℓ₁ ℓ⊔ ℓ₂)) where
no-eta-equality
field
Ob : Type ℓ₁
Hom : Ob → Ob → Type ℓ₂
Id : ∀ {X} → Hom X X
Comp : ∀ {X Y... |
algebraic-stack_agda0000_doc_7275 | module hott.types.theorems where
open import hott.types.nat.theorems public
|
algebraic-stack_agda0000_doc_7277 |
module Issue117 where
Set′ = Set
record ⊤ : Set′ where
data ⊥ : Set′ where
|
algebraic-stack_agda0000_doc_7278 | module PiNF-semantics where
open import Data.Nat hiding (_⊔_; suc; _+_; _*_)
open import Data.Vec
open import Level
open import Algebra.Structures
open import PiNF-algebra
------------------------------------------------------------------------------
-- Define module over a ring (the types bot, top, disjoint union,... |
algebraic-stack_agda0000_doc_7279 | {-# OPTIONS --allow-unsolved-metas #-}
open import Agda.Builtin.Bool
open import Agda.Builtin.Nat
open import Agda.Primitive
record Graph ℓv ℓe : Set (lsuc (ℓv ⊔ ℓe)) where
field
Obj : Set ℓv
Hom : Obj → Obj → Set ℓe
open Graph public
postulate
t : Nat → Nat → Bool
ωGr : Graph lzero lzero
Obj ωGr = Nat... |
algebraic-stack_agda0000_doc_7276 | -- Issue #1130, test generation of helper function
-- {-# OPTIONS -v tc.with:40 #-}
id : (A : Set) → A → A
id A = {!id′!}
-- C-c C-h produces: id′ : ∀ {A} → A
-- when it should produce: id′ : ∀ {A} → A → A
f : (A : Set) (B : A → Set) (a : A) → B a
f A B a = {!g A a!}
-- Before: ∀ {A} {B : A → Set} A₁ (a : ... |
algebraic-stack_agda0000_doc_5488 |
-- Some basic stuff for Conor's talk.
module SomeBasicStuff where
infixr 40 _::_ _↦_∣_
infix 30 _∈_ _==_
infixr 10 _,_
data _==_ {A : Set}(x : A) : A -> Set where
refl : x == x
data Σ (A : Set)(B : A -> Set) : Set where
_,_ : (x : A) -> B x -> Σ A B
_×_ : Set -> Set -> Set
A × B = Σ A \_ -> B
fst : {A : Set}{... |
algebraic-stack_agda0000_doc_5489 | module sn-calculus-confluence.potpot where
open import utility
open import sn-calculus
open import context-properties
using (->pot-view)
open import Esterel.Lang
open import Esterel.Lang.CanFunction
using (Can ; Canₛ ; Canₛₕ ; Canθ ; Canθₛ ; Canθₛₕ)
open import Esterel.Lang.CanFunction.Properties
using ( canθₛ-... |
algebraic-stack_agda0000_doc_5490 | {-# OPTIONS --safe #-}
module Issue2487.d where
-- trying to import a two-level, non-safe module
open import Issue2487.e
|
algebraic-stack_agda0000_doc_5491 | {-# OPTIONS --universe-polymorphism #-}
module Categories.Support.EqReasoning where
open import Categories.Support.Equivalence using (Setoid; module Setoid)
open import Relation.Binary.PropositionalEquality using () renaming (_≡_ to _≣_; trans to ≣-trans; sym to ≣-sym; refl to ≣-refl)
module SetoidReasoning {s₁ s₂} (... |
algebraic-stack_agda0000_doc_5492 | {-
This file contains a summary of what remains for π₄(S³) ≡ ℤ/2ℤ to be proved.
See the module π₄S³ at the end of this file.
-}
{-# OPTIONS --safe #-}
module Cubical.Homotopy.Group.Pi4S3.Summary where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed
open import Cubical.Data.Nat.Base... |
algebraic-stack_agda0000_doc_5493 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- More efficient mod and divMod operations (require the K axiom)
------------------------------------------------------------------------
{-# OPTIONS --with-K --safe #-}
module Data.Nat.DivMod.WithK where
open i... |
algebraic-stack_agda0000_doc_5494 | {-# OPTIONS --cubical-compatible #-}
mutual
record R : Set₁ where
constructor c
field
@0 A : Set
x : _
_ : (@0 A : Set) → A → R
_ = c
|
algebraic-stack_agda0000_doc_5495 | {- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020, 2021, Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.Prelude
open import LibraBFT.Lemmas
open import Lib... |
algebraic-stack_agda0000_doc_5496 | module Coirc.Bot where
open import Coirc
open import Coirc.Network
open import Coinduction
open import IO
open import Data.String
server = "irc.freenode.org"
name = "coalgbot"
real = "Coalgebra Bot"
bot : Bot
bot =
put (nick name)
(♯ put (user name real)
(♯ loop)) where
loop = get f where
f : Event → Bot... |
algebraic-stack_agda0000_doc_5497 | {-# OPTIONS --cubical --safe #-}
open import Prelude
open import Relation.Binary
module LexPerm where
|
algebraic-stack_agda0000_doc_5498 | open import Prelude
module Implicits.Resolution.Finite.Resolution where
open import Coinduction
open import Data.Fin.Substitution
open import Data.List
open import Data.List.Any
open Membership-≡
open import Implicits.Syntax
open import Implicits.Substitutions
open import Implicits.Resolution.Termination
open import ... |
algebraic-stack_agda0000_doc_5499 | module Data.Fin.Sigma where
open import Prelude
open import Data.Nat
open import Data.Nat.Properties
Fin : ℕ → Type
Fin n = ∃ m × (m < n)
open import Data.List
_!!_ : (xs : List A) → Fin (length xs) → A
(x ∷ xs) !! (zero , p) = x
(x ∷ xs) !! (suc n , p) = xs !! (n , p)
|
algebraic-stack_agda0000_doc_5500 |
module VariableName where
open import OscarPrelude
record VariableName : Set
where
constructor ⟨_⟩
field
name : Nat
open VariableName public
instance EqVariableName : Eq VariableName
Eq._==_ EqVariableName _ = decEq₁ (cong name) ∘ (_≟_ on name $ _)
|
algebraic-stack_agda0000_doc_5501 | ------------------------------------------------------------------------
-- A self-interpreter (without correctness proof)
------------------------------------------------------------------------
module Self-interpreter where
open import Prelude hiding (const)
-- To simplify the development, let's work with actual n... |
algebraic-stack_agda0000_doc_5503 | {-# OPTIONS --without-K --safe #-}
module Categories.Adjoint.Equivalence where
open import Level
open import Categories.Adjoint
open import Categories.Adjoint.TwoSided
open import Categories.Adjoint.TwoSided.Compose
open import Categories.Category.Core using (Category)
open import Categories.Functor using (Functor; ... |
algebraic-stack_agda0000_doc_5502 | {-# OPTIONS --without-K --safe #-}
module Categories.Category.Core where
open import Level
open import Function.Base using (flip)
open import Relation.Binary using (Rel; IsEquivalence; Setoid)
import Relation.Binary.Reasoning.Setoid as SetoidR
-- Basic definition of a |Category| with a Hom setoid.
-- Also comes with... |
algebraic-stack_agda0000_doc_6752 | {-# OPTIONS --universe-polymorphism #-}
module Categories.Support.StarEquality where
open import Categories.Support.Equivalence
open import Data.Star
import Data.Star.Properties as Props
open import Level
open import Relation.Binary
using ( Rel
; Reflexive; Symmetric; Transitive
; IsEquivalence
... |
algebraic-stack_agda0000_doc_6753 | module LC.Confluence where
open import LC.Base
open import LC.Subst
open import LC.Reduction
open import Data.Product
open import Relation.Binary.Construct.Closure.ReflexiveTransitive
β→confluent : ∀ {M N O : Term} → (M β→ N) → (M β→ O) → ∃ (λ P → (N β→* P) × (O β→* P))
β→confluent (β-ƛ-∙ {M} {N}) β-ƛ-∙ = M [ N... |
algebraic-stack_agda0000_doc_6754 | -- This module closely follows a section of Martín Escardó's HoTT lecture notes:
-- https://www.cs.bham.ac.uk/~mhe/HoTT-UF-in-Agda-Lecture-Notes/HoTT-UF-Agda.html#funextfromua
{-# OPTIONS --without-K #-}
module Util.HoTT.FunctionalExtensionality where
open import Axiom.Extensionality.Propositional using
(Extensional... |
algebraic-stack_agda0000_doc_6755 | open import Prelude
module Nat where
data Nat : Set where
Z : Nat
1+ : Nat → Nat
{-# BUILTIN NATURAL Nat #-}
-- the succ operation is injective
1+inj : (x y : Nat) → (1+ x == 1+ y) → x == y
1+inj Z .0 refl = refl
1+inj (1+ x) .(1+ x) refl = refl
-- equality of naturals is decidable. we represe... |
algebraic-stack_agda0000_doc_6756 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
module homotopy.PathSetIsInitalCover {i} (X : Ptd i)
-- and an arbitrary covering
{k} (⊙cov : ⊙Cover X k) where
open Cover
private
univ-cover = path-set-cover X
module ⊙cov = ⊙Cover ⊙cov
-- Weak initiality by transport.
quotient-cover... |
algebraic-stack_agda0000_doc_6757 | import Lvl
open import Structure.Operator.Vector
open import Structure.Setoid
open import Type
module Structure.Operator.Vector.FiniteDimensional.Proofs
{ℓᵥ ℓₛ ℓᵥₑ ℓₛₑ}
{V : Type{ℓᵥ}} ⦃ equiv-V : Equiv{ℓᵥₑ}(V) ⦄
{S : Type{ℓₛ}} ⦃ equiv-S : Equiv{ℓₛₑ}(S) ⦄
{_+ᵥ_ : V → V → V}
{_⋅ₛᵥ_ : S → V → V}
{_+ₛ_ _⋅... |
algebraic-stack_agda0000_doc_6759 | module L.Base where
-- Reexport definitions
open import L.Base.Sigma public
open import L.Base.Coproduct public renaming (_+_ to _⊎_)
open import L.Base.Empty public
open import L.Base.Unit public
open import L.Base.Nat public
open import L.Base.Id public
|
algebraic-stack_agda0000_doc_6760 | open import Level
open import Relation.Binary.PropositionalEquality
open import Relation.Binary using (Setoid)
import Function.Equality
import Relation.Binary.Reasoning.Setoid as SetoidR
import Categories.Category
import Categories.Functor
import Categories.Category.Instance.Setoids
import Categories.Category.Cocarte... |
algebraic-stack_agda0000_doc_6761 | -- Andreas, 2017-12-13, issue #2867
-- Parentheses needed when giving module argument
module _ where
module M (A : Set) where
id : A → A
id x = x
test : (F : Set → Set) (A : Set) (x : F A) → F A
test F A = λ x → x
where open M {!F A!} -- Give this
-- Expected: M (F A)
|
algebraic-stack_agda0000_doc_6762 | ------------------------------------------------------------------------
-- Admissible rules are sometimes not "postulable"
------------------------------------------------------------------------
-- Even though a rule is admissible it may not be sound to postulate
-- it, i.e. add it as an inductive constructor. This ... |
algebraic-stack_agda0000_doc_6763 | {-# OPTIONS --universe-polymorphism #-}
open import Categories.Category
open import Categories.Object.BinaryProducts
module Categories.Object.Exponentiating {o ℓ e}
(C : Category o ℓ e)
(binary : BinaryProducts C) where
open Category C
open BinaryProducts binary
import Categories.Object.Product
open Categor... |
algebraic-stack_agda0000_doc_6764 |
{-# OPTIONS --safe #-}
module Cubical.Data.FinData.Properties where
open import Cubical.Foundations.Function
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Transport
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Powerset
open... |
algebraic-stack_agda0000_doc_6765 |
-- Currently imports are not allowed in mutual blocks.
-- This might change.
module ImportInMutual where
mutual
import Fake.Module
T : Set -> Set
T A = A
|
algebraic-stack_agda0000_doc_6766 | {-
A parameterized family of structures S can be combined into a single structure:
X ↦ (a : A) → S a X
This is more general than Structures.Function in that S can vary in A.
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Structures.Parameterized where
open import Cubical.Foundations.Prelude
op... |
algebraic-stack_agda0000_doc_6767 |
module Haskell.Prim.Bool where
open import Agda.Primitive
open import Agda.Builtin.Bool public
private
variable
ℓ : Level
--------------------------------------------------
-- Booleans
infixr 3 _&&_
_&&_ : Bool → Bool → Bool
false && _ = false
true && x = x
infixr 2 _||_
_||_ : Bool → Bool → Bool
false || ... |
algebraic-stack_agda0000_doc_6758 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Diagram.Pushout {o ℓ e} (C : Category o ℓ e) where
open Category C
open HomReasoning
open import Level
private
variable
A B X Y Z : Obj
h h₁ h₂ j : A ⇒ B
record Pushout (f : X ⇒ Y) (g : X ⇒ Z) : Set (o ⊔ ℓ ⊔ e) where
... |
algebraic-stack_agda0000_doc_13856 | module Common.UntypedContext where
open import Common.Context public
-- Naturals, as a projection of contexts.
ᴺ⌊_⌋ : ∀ {U} → Cx U → ℕ
ᴺ⌊ ∅ ⌋ = zero
ᴺ⌊ Γ , A ⌋ = suc ᴺ⌊ Γ ⌋
-- Inversion principle for naturals.
invsuc : ∀ {n n′} → ℕ.suc n ≡ suc n′ → n ≡ n′
invsuc refl = refl
-- Finite naturals, or nameless ... |
algebraic-stack_agda0000_doc_13857 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Foundations.HLevels' where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Data.Nat
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
open import Cubical.Foundation... |
algebraic-stack_agda0000_doc_13858 | {-# OPTIONS --allow-unsolved-metas #-}
module _ where
open import Agda.Primitive
postulate Applicative : ∀ {a b} (F : Set a → Set b) → Set (lsuc a ⊔ b)
record Traversable {a} (T : Set a) : Set (lsuc a) where
constructor mkTrav
field traverse : ∀ {F} {{AppF : Applicative F}} → T → F T
-- unsolved metas in typ... |
algebraic-stack_agda0000_doc_13860 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use Data.Vec.Recursive instead.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Product.N-ary where
{-#... |
algebraic-stack_agda0000_doc_13861 | -- Andreas, 2011-04-11 adapted from Data.Nat.Properties
{-# OPTIONS --universe-polymorphism #-}
module FrozenMVar2 where
open import Imports.Level
data _≡_ {a} {A : Set a} (x : A) : A → Set a where
refl : x ≡ x
{-# BUILTIN EQUALITY _≡_ #-}
{-# BUILTIN REFL refl #-}
cong : ∀ {a b} {A : Set a} {B : Set b}
... |
algebraic-stack_agda0000_doc_13862 | module Numeral.Natural.Inductions where
import Lvl
open import Logic
open import Logic.Propositional
open import Logic.Predicate
open import Functional
open import Numeral.Natural
import Numeral.Natural.Induction
open import Numeral.Natural.Oper
open import Numeral.Natural.Oper.Proofs
open import Numeral.Natural.... |
algebraic-stack_agda0000_doc_13863 | open import Prelude
module Implicits.Resolution.Deterministic.Resolution where
open import Data.Fin.Substitution
open import Data.List
open import Data.List.All
open import Implicits.Syntax
open import Implicits.Syntax.Type.Unification
open import Implicits.Substitutions
open import Extensions.ListFirst
infixl 4 _⊢... |
algebraic-stack_agda0000_doc_13864 |
module WrongNumberOfConstructorArguments where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
f : Nat -> Nat
f (zero n) = n
f suc = zero
|
algebraic-stack_agda0000_doc_13865 | {-# OPTIONS --subtyping #-}
open import Agda.Builtin.Equality
record _↠_ (A B : Set) : Set where
field
to : A → B
from : B → A
to∘from : ∀ x → to (from x) ≡ x
record Erased (@0 A : Set) : Set where
constructor [_]
field
@0 erased : A
open Erased
-- fails : {A : Set} → A ↠ Erased A
-- ... |
algebraic-stack_agda0000_doc_13866 | {-# OPTIONS --universe-polymorphism #-}
module Categories.Categories where
open import Level
open import Categories.Category
open import Categories.Functor
Categories : ∀ o ℓ e → Category (suc (o ⊔ ℓ ⊔ e)) (o ⊔ ℓ ⊔ e) (o ⊔ ℓ ⊔ e)
Categories o ℓ e = record
{ Obj = Category o ℓ e
; _⇒_ = Functor
; _≡_ = _≡_
;... |
algebraic-stack_agda0000_doc_13867 | ------------------------------------------------------------------------
-- A sequential colimit for which everything except for the "base
-- case" is erased
------------------------------------------------------------------------
{-# OPTIONS --erased-cubical --safe #-}
-- The definition of sequential colimits and th... |
algebraic-stack_agda0000_doc_13868 | open import Agda.Builtin.Nat
data Vec (A : Set) : Nat -> Set where
[] : Vec A 0
cons : {n : Nat} -> A -> Vec A n -> Vec A (suc n)
empty : Vec Nat 0
empty = []
|
algebraic-stack_agda0000_doc_13869 | ------------------------------------------------------------------------------
-- The unary numbers are FOTC total natural numbers
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-univer... |
algebraic-stack_agda0000_doc_13870 | {-# OPTIONS --without-K --exact-split --safe #-}
open import Fragment.Equational.Theory
module Fragment.Equational.Model (Θ : Theory) where
open import Fragment.Equational.Model.Base Θ public
open import Fragment.Equational.Model.Synthetic Θ public
open import Fragment.Equational.Model.Properties Θ public
open impor... |
algebraic-stack_agda0000_doc_13871 | {-
This file contains:
- Some alternative inductive definitions of James, and they give the same results.
The most relevant one is called `𝕁Red` because it is much simpler.
It has fewer constructors, among which the 2-dimensional constructor `coh`
has a form essentially more clearer, and it avoids indexes.
... |
algebraic-stack_agda0000_doc_13859 |
record _×_ (A B : Set) : Set where
constructor _,_
field
fst : A
snd : B
open _×_
app : {A B : Set} → (A → B) × A → B
app (f , x) = f x
data D : Set where d : D
postulate
P : {A : Set} → A → Set
p : (f : D → D) → P f → P (f d)
foo : (F : Set → Set) → F D
bar : (F : Set → Set) → P (foo F)
q... |
algebraic-stack_agda0000_doc_4512 |
module _ where
infixr 5 _⇒_
infixl 6 _▻_
infix 3 _⊢_ _∈_
infixr 5 vs_
infixr 4 ƛ_
infixl 6 _·_
data Type : Set where
ι : Type
_⇒_ : Type → Type → Type
data Con : Set where
ε : Con
_▻_ : Con → Type → Con
data _∈_ σ : Con → Set where
vz : ∀ {Γ} → σ ∈ Γ ▻ σ
vs_ : ∀ {Γ τ} → σ ∈ Γ → σ ∈ Γ ▻ τ
d... |
algebraic-stack_agda0000_doc_4514 | open import Data.Product using ( _×_ ; _,_ )
open import Web.Semantic.DL.ABox.Model using ( _⊨a_ ; ⊨a-resp-≲ )
open import Web.Semantic.DL.ABox.Interp using ( Interp ; ⌊_⌋ )
open import Web.Semantic.DL.ABox.Interp.Morphism using ( _≃_ ; ≃⌊_⌋ ; ≃-impl-≲ )
open import Web.Semantic.DL.KB using ( KB ; tbox ; abox )
open im... |
algebraic-stack_agda0000_doc_4515 | {-# OPTIONS --without-K #-}
{- The type of all types in some universe with a fixed truncation level
behaves almost like a universe itself. In this utility module, we develop
some notation for efficiently working with this pseudo-universe.
It will lead to considerably more briefer and more comprehensible proof... |
algebraic-stack_agda0000_doc_4516 | module plfa-code.Induction where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong; sym)
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_)
open import Data.Nat using (ℕ; zero; suc; _+_; _*_; _∸_)
open import Function
open import plfa-code.Reasoning-legacy
_ : (3 + 4) + 5 ≡ 3 + (4 + 5)
_ =
... |
algebraic-stack_agda0000_doc_4517 | {-# OPTIONS --without-K --safe #-}
module Categories.Category where
open import Level
-- The main definitions are in:
open import Categories.Category.Core public
-- Convenience functions for working over mupliple categories at once:
-- C [ x , y ] (for x y objects of C) - Hom_C(x , y)
-- C [ f ≈ g ] (for f g arrows ... |
algebraic-stack_agda0000_doc_4518 | module UselessPrivatePrivate where
private
private
postulate
A : Set
|
algebraic-stack_agda0000_doc_4519 | module NoBindingForBuiltin where
foo = 42
|
algebraic-stack_agda0000_doc_4520 | {-# OPTIONS --universe-polymorphism #-}
module TrustMe-with-doubly-indexed-equality where
open import Common.Level
infix 4 _≡_
data _≡_ {a} {A : Set a} : A → A → Set a where
refl : ∀ {x} → x ≡ x
{-# BUILTIN EQUALITY _≡_ #-}
{-# BUILTIN REFL refl #-}
sym : ∀ {a} {A : Set a} {x y : A} → x ≡ y → y ≡ x
sym ref... |
algebraic-stack_agda0000_doc_4521 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Primality
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Nat.Primality where
open import Data.Empty using (⊥)
open import Data.Fin using... |
algebraic-stack_agda0000_doc_4522 | module TestNat where
import PreludeNatType
import AlonzoPrelude
import PreludeNat
import PreludeString
import PreludeShow
import RTP
import PreludeList
open AlonzoPrelude
open PreludeShow
open PreludeNatType
open PreludeString
open PreludeNat
open PreludeList hiding(_++_)
one = suc zero
two = suc one
lines : (List St... |
algebraic-stack_agda0000_doc_4523 | {-# OPTIONS --without-K --safe #-}
-- Multicategories but over an 'index' type, rather than forcing Fin n
module Categories.Multi.Category.Indexed where
open import Level
open import Data.Fin.Base using (Fin)
open import Data.Product using (Σ; uncurry; curry; _×_; _,_; proj₁; proj₂)
open import Data.Product.Propertie... |
algebraic-stack_agda0000_doc_4524 | {-# OPTIONS --without-K #-}
open import HoTT
open import cohomology.FunctionOver
open import cohomology.FlipPushout
module cohomology.CofiberSequence {i} where
{- Lemma: pushing flip-susp through susp-fmap -}
⊙flip-susp-fmap : {X Y : Ptd i} (f : fst (X ⊙→ Y))
→ ⊙flip-susp Y ⊙∘ ⊙susp-fmap f == ⊙susp-fmap f ⊙∘ ⊙flip... |
algebraic-stack_agda0000_doc_4525 | {-# OPTIONS --safe --warning=error --without-K #-}
open import Functions.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import LogicalFormulae
open import Setoids.Subset
open import Setoids.Setoids
open import Setoids.Orders.Partial.Definition
open import Fields.Fields
open import Rings.Ord... |
algebraic-stack_agda0000_doc_4526 | {-# OPTIONS --cubical-compatible --show-implicit #-}
-- {-# OPTIONS -v tc.lhs.split.well-formed:100 #-}
-- Andreas, adapted from Andres Sicard, 2013-05-29
module WithoutKRestrictive where
open import Common.Level
open import Common.Equality
open import Common.Product
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
data... |
algebraic-stack_agda0000_doc_4527 | -- Run this test case in safe mode
-- {-# OPTIONS --safe #-} -- does not parse (2012-03-12 Andreas)
module Issue586 where
Foo : Set1
Foo = Set
|
algebraic-stack_agda0000_doc_4513 | -- TODO: use StrictTotalOrder for QName representation
module Syntax (QName : Set) where
open import Data.Nat.Base
open import Data.Nat.Properties using (+-suc; +-identityʳ)
open import Data.List.Base hiding (_∷ʳ_)
open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong; sym; trans)
-- Well-scoped d... |
algebraic-stack_agda0000_doc_16800 | module bstd.bign where
|
algebraic-stack_agda0000_doc_16801 | -- {-# OPTIONS -v tc.lhs.unify:100 #-}
-- Reported by project member adamgundry, 2012-10-26
-- I was trying to extend Conor's KIPLING technique (Outrageous but
-- Meaningful Coincidences, WGP 2010) which depends on indexing a
-- syntax by functions, when I hit this problem:
module Issue738 where
open import Common.E... |
algebraic-stack_agda0000_doc_16802 | module Functors where
open import Library
open import Categories
open Cat
record Fun {a b c d} (C : Cat {a}{b})(D : Cat {c}{d}) : Set (a ⊔ b ⊔ c ⊔ d)
where
constructor functor
field OMap : Obj C → Obj D
HMap : ∀{X Y} → Hom C X Y → Hom D (OMap X) (OMap Y)
fid : ∀{X} → HMap (iden C {X}) ≅ ide... |
algebraic-stack_agda0000_doc_16803 |
open import Oscar.Prelude
open import Oscar.Class.Successor₀
open import Oscar.Class.Injectivity
open import Oscar.Data.¶
open import Oscar.Data.Vec
open import Oscar.Data.Proposequality
import Oscar.Property.Thickandthin.FinFinProposequalityMaybeProposequality
module Oscar.Class.Injectivity.Vec where
instance
𝓘... |
algebraic-stack_agda0000_doc_16804 | {-# OPTIONS --without-K --safe #-}
-- Exact category (https://ncatlab.org/nlab/show/exact+category)
-- is a regular category
-- in which every internal equivalence is a kernel pair
module Categories.Category.Exact where
open import Level
open import Categories.Category.Core
open import Categories.Diagram.Pullback
o... |
algebraic-stack_agda0000_doc_16805 | module VecS where
open import Data.Empty
open import Data.Product hiding (map)
open import Data.Sum
open import Data.Vec
open import Data.Nat
open import Data.Bool
open import Data.Nat.Properties
import Homotopy as Pi
------------------------------------------------------------------------------
data B : Set where... |
algebraic-stack_agda0000_doc_16806 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Finite sets
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Fin where
-------------------------------------------------------------------... |
algebraic-stack_agda0000_doc_16807 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Function setoids and related constructions
------------------------------------------------------------------------
module Function.Equality where
open import Function as Fun using (_on_)
open import Level
impo... |
algebraic-stack_agda0000_doc_16808 | {-
Eilenberg–Mac Lane type K(G, 1)
-}
{-# OPTIONS --cubical --no-import-sorts --safe --experimental-lossy-unification #-}
module Cubical.HITs.EilenbergMacLane1.Properties where
open import Cubical.HITs.EilenbergMacLane1.Base
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import ... |
algebraic-stack_agda0000_doc_16810 | -- Andreas, 2016-11-11 issue #2301,
-- reported by stedolan and fredrikNorvallForsberg:
-- compareTelescope ignored relevance.
-- Faulty behavior probably existed since 2011.
module Issue2301 where
data Box (A : Set) : Set where
wrap : A → Box A
weird : ∀ A → .A → Box A
weird A = wrap
-- SHOULD FAIL with error:
-... |
algebraic-stack_agda0000_doc_16811 | mutual
_ : Set
_ : Set → Set
|
algebraic-stack_agda0000_doc_16812 | module Dipsy.Example.CLL where
open import Data.Nat using (ℕ)
open import Data.Vec using (Vec; _∷_; [])
open import Dipsy.Polarity using (Polarity; flip) renaming (pos to +; neg to -)
mutual
Op₀ : (r : Polarity) → Set
Op₀ r = Op [] r
Op₁ : (a r : Polarity) → Set
Op₁ a r = Op (a ∷ []) r
Op₂ : (a₁ a₂ r : Pola... |
algebraic-stack_agda0000_doc_16813 | -- Andreas, 2016-09-28, solve _ <= lzero.
-- {-# OPTIONS -v tc.conv.nat:40 #-}
open import Common.Level
data C : Set₁ where
c : Set _ → C -- This meta should be solved to lzero.
-- ERROR WAS:
-- Failed to solve the following constraints:
-- [0] lsuc _0 =< lsuc lzero
-- REASON:
-- Non-canonical lzero in level c... |
algebraic-stack_agda0000_doc_16815 | {-# OPTIONS --without-K --safe #-}
module Data.Quiver where
-- A Quiver, also known as a multidigraph, is the "underlying graph" of
-- a category. Note how a Quiver has a *setoid* of edges.
open import Level
open import Relation.Binary using (Rel; IsEquivalence; Setoid)
import Relation.Binary.Reasoning.Setoid as EqR... |
algebraic-stack_agda0000_doc_16809 | ------------------------------------------------------------------------
-- An up-to technique for CCS
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
open import Prelude hiding (step-→)
module Bisimilarity.Weak.Up-to.CCS {ℓ} {Name : Type ℓ} where
open import E... |
algebraic-stack_agda0000_doc_16814 | {-# OPTIONS --without-K --safe #-}
module Categories.Functor.Coalgebra where
-- Co-algebras of a Functor
open import Level
open import Function using (_$_)
open import Categories.Category using (Category)
open import Categories.Functor using (Functor; Endofunctor)
record F-Coalgebra {o ℓ e} {C : Category o ℓ e} (F :... |
algebraic-stack_agda0000_doc_16512 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Consequences of a monomorphism between orders
------------------------------------------------------------------------
-- See Data.Nat.Binary.Properties for examples of how this and similar
-- modules can be use... |
algebraic-stack_agda0000_doc_16513 | {-# OPTIONS --without-K --safe #-}
module Definition.Typed.Consequences.Reduction where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.EqRelInstance
open import Definition.LogicalRelation
open import Definition.LogicalRelation.Propertie... |
algebraic-stack_agda0000_doc_16514 | {-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Groups.Definition
open import Groups.Abelian.Definition
open import Setoids.Setoids
open import Rings.Definition
open import Modules.Definition
module Modules.DirectSum {a b : _} {A : Set a} {S : Setoid {a} {b} A} {_+R_ : A → ... |
algebraic-stack_agda0000_doc_16515 | ------------------------------------------------------------------------
-- There is a term without a corresponding syntactic type (given some
-- assumptions)
------------------------------------------------------------------------
import Level
open import Data.Universe
module README.DependentlyTyped.Term-without-typ... |
algebraic-stack_agda0000_doc_16516 |
module Scope where
{-
So this goes through (we don't actually check scope). But what could really
go wrong? This actually isn't captured by the main theorem, since we're type
checking multiple definitions. Maybe it should be strengthened.
Still nothing _bad_ happens here. Could we get some weird circular th... |
algebraic-stack_agda0000_doc_16517 | {-# OPTIONS --without-K --exact-split --rewriting #-}
open import Coequalizers.Definition
open import lib.Basics
open import lib.types.Paths
open import Graphs.Definition
module Coequalizers.EdgeCoproduct where
module CoeqCoprodEquiv {i j k : ULevel} (V : Type i) (E₁ : Type j) (E₂ : Type k) ⦃ gph : Graph (E₁ ⊔ E₂)... |
algebraic-stack_agda0000_doc_16519 | {-# OPTIONS --safe --without-K #-}
module Data.Fin.Subset.Properties.Dec where
open import Data.Nat as ℕ
open import Data.Fin as Fin
open import Data.Empty using (⊥-elim)
open import Data.Fin.Subset
open import Data.Fin.Subset.Dec
open import Data.Fin.Subset.Properties using (⊆⊤; p⊆p∪q; q⊆p∪q ; p∩q⊆p ; p∩q⊆q ; ⊆-pose... |
algebraic-stack_agda0000_doc_16520 | {-# OPTIONS --safe --without-K #-}
module Generics.Prelude where
open import Function.Base public
open import Data.Product public hiding (map; uncurry; uncurry′; curry′)
open import Level public using (Setω; Level; _⊔_; Lift; lift)
renaming (zero to lzero; suc ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.