id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_7876 | module Impossible where
{-# IMPOSSIBLE #-}
|
algebraic-stack_agda0000_doc_7877 |
module _ where
open import Agda.Builtin.Equality
open import Agda.Builtin.Bool
open import Agda.Builtin.Unit
open import Agda.Builtin.List
open import Agda.Builtin.Nat
open import Agda.Builtin.Reflection renaming (returnTC to return; bindTC to _>>=_)
_>>_ : {A B : Set} → TC A → TC B → TC B
m >> m' = m >>= λ _ → m'
... |
algebraic-stack_agda0000_doc_7878 |
open import Agda.Builtin.Nat
data Sing : Nat → Set where
i : (k : Nat) → Sing k
toSing : (n : Nat) → Sing n
toSing n = i n
fun : (n : Nat) → Nat
fun n with toSing n
fun .n | i n with toSing n
fun .(n + n) | i .n | i n = {!!}
|
algebraic-stack_agda0000_doc_7879 | module PrintNat where
import PreludeShow
open PreludeShow
mainS = showNat 42
|
algebraic-stack_agda0000_doc_7880 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- The sublist relation over propositional equality.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Relation.Binary.Subset.Propositiona... |
algebraic-stack_agda0000_doc_7881 | open import Common.Prelude renaming (Nat to ℕ; _+_ to _+ℕ_)
open import Common.Product
open import Common.Equality
postulate
_≤ℕ_ : (n m : ℕ) → Set
maxℕ : (n m : ℕ) → ℕ
When : (b : Bool) (P : Set) → Set
When true P = P
When false P = ⊤
infix 30 _⊕_
infix 20 _+_
infix 10 _≤_
infix 10 _<_
infixr 4 _,_
mutual
... |
algebraic-stack_agda0000_doc_7882 | open import Categories
open import Functors
open import RMonads
module RMonads.RKleisli.Functors {a b c d}{C : Cat {a}{b}}{D : Cat {c}{d}}
{J : Fun C D}(M : RMonad J) where
open import Library
open import RMonads.RKleisli M
open import RAdjunctions
open Cat
open Fun
open RMonad M
RK... |
algebraic-stack_agda0000_doc_7883 |
postulate B : Set
module M where
record ⊤ : Set where
module P (A : Set) where
open M public
module PB = P B
|
algebraic-stack_agda0000_doc_7884 | {-# OPTIONS --experimental-irrelevance #-}
{-# OPTIONS --sized-types #-}
open import Agda.Primitive
public using (lzero; lsuc)
open import Agda.Builtin.Size
public using (Size; ↑_) renaming (∞ to oo)
open import Agda.Builtin.Nat
public using (suc) renaming (Nat to ℕ)
_+_ : Size → ℕ → Size
s + 0 = s
s + suc n ... |
algebraic-stack_agda0000_doc_7885 |
import Oscar.Class.Reflexivity.Function
import Oscar.Class.Transextensionality.Proposequality -- FIXME why not use the instance here?
open import Oscar.Class
open import Oscar.Class.Category
open import Oscar.Class.HasEquivalence
open import Oscar.Class.IsCategory
open import Oscar.Class.IsPrecategory
open import Osca... |
algebraic-stack_agda0000_doc_7886 | open import MLib.Algebra.PropertyCode
open import MLib.Algebra.PropertyCode.Structures
module MLib.Matrix.SemiTensor.Core {c ℓ} (struct : Struct bimonoidCode c ℓ) where
open import MLib.Prelude
open import MLib.Matrix.Core
open import MLib.Matrix.Equality struct
open import MLib.Matrix.Mul struct
open import MLib.Mat... |
algebraic-stack_agda0000_doc_7887 | {-# OPTIONS --safe #-}
module Cubical.Data.Int.MoreInts.BiInvInt where
open import Cubical.Data.Int.MoreInts.BiInvInt.Base public
open import Cubical.Data.Int.MoreInts.BiInvInt.Properties public
|
algebraic-stack_agda0000_doc_9120 |
open import Agda.Primitive
variable
a : Level
A : Set a
x : A
postulate
P : ∀ {a b} {A : Set a} {B : Set b} → (A → B) → Set
p : P x
postulate
H : ∀ a (A : Set a) (x : A) → Set
Id : ∀ {a} (A : Set a) → A → A → Set a
h : (i : H _ _ x) (j : H a _ _) → Id (H _ A _) i j
|
algebraic-stack_agda0000_doc_9121 | {-
The sheaf property of a presheaf on a distributive lattice or a basis thereof
can be expressed as preservation of limits over diagrams defined in this file.
-}
{-# OPTIONS --safe #-}
module Cubical.Categories.DistLatticeSheaf.Diagram where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.I... |
algebraic-stack_agda0000_doc_9122 | module list-thms where
-- see list-thms2 for more
open import bool
open import bool-thms
open import functions
open import list
open import nat
open import nat-thms
open import product-thms
open import logic
++[] : ∀{ℓ}{A : Set ℓ} → (l : 𝕃 A) → l ++ [] ≡ l
++[] [] = refl
++[] (x :: xs) rewrite ++[] xs = refl
++-a... |
algebraic-stack_agda0000_doc_9123 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Pointwise lifting of relations to vectors
------------------------------------------------------------------------
module Relation.Binary.Vec.Pointwise where
open import Category.Applicative.Indexed
open import... |
algebraic-stack_agda0000_doc_9124 | -- Andreas, 2017-01-26. Testing the --no-eta-equality option.
-- Records in files without the option (unless Agda runs with this
-- option globally), should have eta.
module HaveEtaForImportedRecords.EtaRecord where
open import Agda.Builtin.Equality public
record ⊤ : Set where
private
test : ∀{x y : ⊤} → x ≡ y
... |
algebraic-stack_agda0000_doc_9125 |
module _ where
open import Agda.Builtin.Nat
module Postulates where
infixl 5 _<*>_
postulate
F : Set → Set
pure : ∀ {A} → A → F A
_<*>_ : ∀ {A B} → F (A → B) → F A → F B
test₀ : F Nat → F Nat → F Nat
test₀ a b = (| a + b |)
test₁ : F Nat
test₁ = (| 5 |)
test₂ : F Nat → F Nat
tes... |
algebraic-stack_agda0000_doc_9126 | open import Data.Boolean
open import Type
module Data.List.Sorting.HeapSort {ℓ} {T : Type{ℓ}} (_≤?_ : T → T → Bool) where
import Lvl
open import Data.List
import Data.List.Functions as List
open import Data.BinaryTree
import Data.BinaryTree.Heap as Heap
open import Functional using (_∘_)
heapSort : Li... |
algebraic-stack_agda0000_doc_9127 | module Lemmachine.Default.Lemmas where
open import Lemmachine
import Lemmachine.Default
import Lemmachine.Lemmas
open Lemmachine.Lemmas Lemmachine.Default.resource
open import Relation.Binary.PropositionalEquality
open import Data.Empty
open import Data.Maybe
open import Data.Product hiding (map)
open import Data.Funct... |
algebraic-stack_agda0000_doc_9128 | -- Andreas, 2020-03-27, issue #3684
-- Warn about duplicate fields instead of hard error.
module DuplicateFields where
postulate X : Set
record D : Set where
field x : X
d : X → X → D
d x y = record{ x = x; x = y }
|
algebraic-stack_agda0000_doc_9129 | {-# OPTIONS --without-K --exact-split --allow-unsolved-metas #-}
module 14-image where
import 13-propositional-truncation
open 13-propositional-truncation public
{- We introduce the image inclusion of a map. -}
precomp-emb :
{ l1 l2 l3 l4 : Level} {X : UU l1} {A : UU l2} (f : A → X)
{B : UU l3} ( i : B ↪ X) (q ... |
algebraic-stack_agda0000_doc_9130 | module Builtin where
data Bool : Set where
false : Bool
true : Bool
not : Bool -> Bool
not true = false
not false = true
_||_ : Bool -> Bool -> Bool
true || _ = true
false || x = x
_&&_ : Bool -> Bool -> Bool
true && x = x
false && _ = false
{-# BUILTIN BOOL Bool #-}
{-# BUILTIN TRUE true #-}
{-# BUILTI... |
algebraic-stack_agda0000_doc_9131 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category using (Category)
-- 'Heterogeneous' identity morphism and some laws about them.
module Categories.Morphism.HeterogeneousIdentity {o ℓ e} (C : Category o ℓ e) where
open import Level
open import Relation.Binary.PropositionalEquality
import Categories... |
algebraic-stack_agda0000_doc_9132 | {-# OPTIONS --allow-unsolved-metas #-}
open import Oscar.Class
open import Oscar.Class.Smap
open import Oscar.Class.Transitivity
open import Oscar.Class.Reflexivity
open import Oscar.Class.Transleftidentity
open import Oscar.Class.Symmetry
open import Oscar.Class.Hmap
open import Oscar.Data.Proposequality
open import ... |
algebraic-stack_agda0000_doc_9133 | open import Level
open import Ordinals
module VL {n : Level } (O : Ordinals {n}) where
open import zf
open import logic
import OD
open import Relation.Nullary
open import Relation.Binary
open import Data.Empty
open import Relation.Binary
open import Relation.Binary.Core
open import Relation.Binary.PropositionalEqu... |
algebraic-stack_agda0000_doc_9134 | {-# OPTIONS --without-K --safe #-}
module Categories.Category.Discrete where
-- Discrete Category.
-- https://ncatlab.org/nlab/show/discrete+category
-- says:
-- A category is discrete if it is both a groupoid and a preorder. That is,
-- every morphism should be invertible, any two parallel morphisms should be equal.
... |
algebraic-stack_agda0000_doc_9135 | module Issue417 where
data _≡_ (A : Set₁) : Set₁ → Set₂ where
refl : A ≡ A
abstract
A : Set₁
A = Set
unfold-A : A ≡ Set
unfold-A = refl
-- The result of inferring the type of unfold-A is the following:
--
-- Set ≡ Set
|
algebraic-stack_agda0000_doc_11056 | -- The debug output should include the text "Termination checking
-- mutual block MutId 0" once, not three times.
{-# OPTIONS -vterm.mutual.id:40 #-}
record R : Set₁ where
constructor c
field
A : Set
_ : A → A
_ = λ x → x
_ : A → A
_ = λ x → x
_ : A → A
_ = λ x → x
-- Included in order to make... |
algebraic-stack_agda0000_doc_11057 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Decidable equality over lists parameterised by some setoid
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
module Data.Li... |
algebraic-stack_agda0000_doc_11058 | module Everything where
import Relation.Ternary.Separation
-- The syntax and interpreter of LTLC
import Typed.LTLC
-- The syntax and interpreter of LTLC with strong updatable references
import Typed.LTLCRef
-- The syntax of a session typed language
import Sessions.Syntax
-- ... and its semantics
import Sessions.Se... |
algebraic-stack_agda0000_doc_11059 | {-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Functions.Definition
open import Lists.Definition
open import Lists.Monad
open import Boolean.Definition
module Lists.Filter.AllTrue where
allTrue : {a b : _} {A : Set a} (f : A → Set b) (l : List A) → Set b
allTrue f [] = Tru... |
algebraic-stack_agda0000_doc_11060 | module _ (A : Set) where
record R : Set where
field f : A
test : R → R
test r = {!r!}
|
algebraic-stack_agda0000_doc_11061 | module Text.Greek.SBLGNT.Rom where
open import Data.List
open import Text.Greek.Bible
open import Text.Greek.Script
open import Text.Greek.Script.Unicode
ΠΡΟΣ-ΡΩΜΑΙΟΥΣ : List (Word)
ΠΡΟΣ-ΡΩΜΑΙΟΥΣ =
word (Π ∷ α ∷ ῦ ∷ ∙λ ∷ ο ∷ ς ∷ []) "Rom.1.1"
∷ word (δ ∷ ο ∷ ῦ ∷ ∙λ ∷ ο ∷ ς ∷ []) "Rom.1.1"
∷ word (Χ ∷ ρ ∷ ι ∷ ... |
algebraic-stack_agda0000_doc_11062 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Examples showing how the case expressions can be used
------------------------------------------------------------------------
module README.Case where
open import Data.Fin hiding (pred)
open import Data.Mayb... |
algebraic-stack_agda0000_doc_11063 | {-# OPTIONS --universe-polymorphism #-}
module Categories.FunctorCategory where
open import Data.Product
open import Categories.Category
import Categories.Functor as Cat
open import Categories.Functor hiding (equiv; id; _∘_; _≡_)
open import Categories.NaturalTransformation
open import Categories.Product
open import ... |
algebraic-stack_agda0000_doc_11064 | {-# OPTIONS --without-K #-}
open import library.Basics hiding (Type ; Σ)
open import library.types.Sigma
open import Sec2preliminaries
module Sec3hedberg where
-- Lemma 3.2
discr→pathHasConst : {X : Type} → has-dec-eq X → pathHasConst X
discr→pathHasConst dec x₁ x₂ with (dec x₁ x₂)
discr→pathHasConst dec x₁ x₂ |... |
algebraic-stack_agda0000_doc_11065 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Relation.Binary.Raw where
open import Cubical.Relation.Binary.Base public
open import Cubical.Relation.Binary.Raw.Definitions public
open import Cubical.Relation.Binary.Raw.Structures public
open import Cubical.Relation.Binary.Raw.Bundles public
|
algebraic-stack_agda0000_doc_11066 | {-# OPTIONS --allow-unsolved-metas #-}
postulate
Nat : Set
variable
A : _
F : _ → _
|
algebraic-stack_agda0000_doc_11067 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties related to Fin, and operations making use of these
-- properties (or other properties not available in Data.Fin)
------------------------------------------------------------------------
{-# OPTIONS --... |
algebraic-stack_agda0000_doc_11068 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.HSpace renaming (HSpaceStructure to HSS)
open import homotopy.Freudenthal
open import homotopy.IterSuspensionStable
open import homotopy.Pi2HSusp
open import homotopy.EM1HSpace
open import homotopy.EilenbergMacLane1
module homotopy.Eilenber... |
algebraic-stack_agda0000_doc_11069 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Core definitions for Characters
------------------------------------------------------------------------
module Data.Char.Core where
open import Data.Nat using (ℕ)
open import Data.Bool using (Bool; true; false... |
algebraic-stack_agda0000_doc_11070 |
module Imports.Bool where
data Bool : Set where
true false : Bool
|
algebraic-stack_agda0000_doc_11071 | module AKS.Rational where
open import AKS.Rational.Base public
open import AKS.Rational.Properties public
|
algebraic-stack_agda0000_doc_10144 | ------------------------------------------------------------------------
-- Properties related to negation
------------------------------------------------------------------------
module Relation.Nullary.Negation where
open import Relation.Nullary
open import Relation.Unary
open import Data.Empty
open import Data.Fun... |
algebraic-stack_agda0000_doc_10145 | open import Common.Prelude
open import Common.Reflection
open import Common.Equality
` : Term → Term
` (def f []) = con (quote def) (vArg (lit (qname f)) ∷ vArg (con (quote []) []) ∷ [])
` _ = lit (string "other")
macro
primQNameType : QName → Tactic
primQNameType f hole =
bindTC (getType f) λ a →
bindTC ... |
algebraic-stack_agda0000_doc_10146 | -- Andreas, 2017-11-01, issue #2824
-- allow built-in pragmas in parametrized modules
{-# OPTIONS --rewriting #-}
open import Agda.Builtin.Equality
module _ (A : Set) where -- This is the top-level module header.
{-# BUILTIN REWRITE _≡_ #-}
postulate
P : A → Set
a b : A
a→b : a ≡ b
{-# REWRITE a→b #-}
tes... |
algebraic-stack_agda0000_doc_10147 | -- Andreas, 2019-11-06 issue #4168, version with shape-irrelevance.
-- Eta-contraction of records with all-irrelevant fields is unsound.
-- In this case, it lead to a compilation error.
{-# OPTIONS --irrelevant-projections #-}
-- {-# OPTIONS -v tc.cc:20 #-}
open import Agda.Builtin.Unit
open import Common.IO using ... |
algebraic-stack_agda0000_doc_10148 | open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
open import Agda.Builtin.List
open import Agda.Builtin.Reflection renaming (bindTC to _>>=_)
open import Agda.Builtin.Unit
postulate
@0 A : Set
@0 _ : @0 Set → (Set → Set) → Set
_ = λ @0 where
A G → G A
@0 _ : @0 Set → (Set → Set) → Set
_ = λ @0 { A... |
algebraic-stack_agda0000_doc_10149 |
-- Category of □-coalgebras
module SOAS.Abstract.Coalgebra {T : Set} where
open import SOAS.Common
open import SOAS.Construction.Structure as Structure
open import SOAS.Context
open import SOAS.ContextMaps.Combinators
open import SOAS.ContextMaps.CategoryOfRenamings {T}
open import SOAS.Sorting
open import SOAS.Famil... |
algebraic-stack_agda0000_doc_10150 | {-# OPTIONS --without-K --safe #-}
-- The identity pseudofunctor
module Categories.Pseudofunctor.Identity where
open import Data.Product using (_,_)
open import Categories.Bicategory using (Bicategory)
import Categories.Bicategory.Extras as BicategoryExt
open import Categories.Category using (Category)
open import ... |
algebraic-stack_agda0000_doc_10151 | {-# OPTIONS --cubical --safe #-}
module Data.Binary.Equatable where
open import Prelude
open import Data.Binary.Definition
open import Data.Bits.Equatable public
|
algebraic-stack_agda0000_doc_10152 | -- Andreas, 2012-02-14, issue reported by Wolfram Kahl
-- {-# OPTIONS -v scope.top:10 #-}
module Issue562 where
data Bool : Set where true false : Bool
f : Bool → Bool
f b with b
f true | _ = b
-- WAS: panic unbound variable b
-- should be: Not in scope: b |
algebraic-stack_agda0000_doc_10153 | -- 2010-11-21
-- testing correct implementation of eta for records with higher-order fields
module Issue366 where
data Bool : Set where
true false : Bool
record R (A : Set) : Set where
constructor r
field
unR : A
open R
foo : Bool
foo = unR (r (unR (r (λ (_ : Bool) → false))
true))
-- befor... |
algebraic-stack_agda0000_doc_10154 | module TerminationMixingTupledCurried where
data Nat : Set where
zero : Nat
succ : Nat -> Nat
data _×_ (A B : Set) : Set where
_,_ : A -> B -> A × B
good : Nat × Nat -> Nat -> Nat
good (succ x , y) z = good (x , succ y) (succ z)
good (x , succ y) z = good (x , y) x
good xy (succ z) = good xy z
good _ _ =... |
algebraic-stack_agda0000_doc_10155 | {-# OPTIONS --safe #-}
module Cubical.Algebra.Group where
open import Cubical.Algebra.Group.Base public
open import Cubical.Algebra.Group.Properties public
|
algebraic-stack_agda0000_doc_10156 | data Nat : Set where
zero : Nat
suc : Nat → Nat
test : ∀{N M : Nat} → Nat → Nat → Nat
test N M = {!.N N .M!}
-- Andreas, 2016-07-10, issue 2088
-- Changed behavior:
-- The hidden variables .N and .M are made visible
-- only the visible N is split.
|
algebraic-stack_agda0000_doc_10157 |
postulate
A : Set
f : A → A
mutual
F : A → Set
F x = D (f x)
data D : A → Set where
c : (x : A) → F x
G : (x : A) → D x → Set₁
G _ (c _) = Set
|
algebraic-stack_agda0000_doc_10158 | {-# OPTIONS --copatterns #-}
module Issue950b where
postulate
A : Set
record R : Set where
field
x : A
record S : Set where
field
y : A
open R
f : ?
x f = ?
-- Good error:
-- Cannot eliminate type ?0 with projection pattern x
-- when checking that the clause x f = ? has type ?0
|
algebraic-stack_agda0000_doc_10159 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
module groups.KernelSndImageInl {i j k}
(G : Group i) {H : Group j} {K : Group k}
-- the argument [φ-snd], which is intended to be [φ ∘ᴳ ×-snd],
-- gives the possibility of making the second part
-- (the proof of being a group homomorphism) abstract.
... |
algebraic-stack_agda0000_doc_9936 | module OldBasicILP.UntypedSyntax.Common where
open import Common.UntypedContext public
-- Types parametrised by closed, untyped representations.
module ClosedSyntax
(Proof : Set)
where
infixr 10 _⦂_
infixl 9 _∧_
infixr 7 _▻_
data Ty : Set where
α_ : Atom → Ty
_▻_ : Ty → Ty → Ty
_⦂_ : Pro... |
algebraic-stack_agda0000_doc_9937 | open import Nat
open import Prelude
open import core
open import disjointness
module elaboration-generality where
mutual
elaboration-generality-synth : {Γ : tctx} {e : hexp} {τ : htyp} {d : ihexp} {Δ : hctx} →
Γ ⊢ e ⇒ τ ~> d ⊣ Δ →
Γ ⊢ e => τ
elaboration... |
algebraic-stack_agda0000_doc_9938 | open import Functional using (id)
import Structure.Logic.Constructive.NaturalDeduction
module Structure.Logic.Constructive.Functions.Properties {ℓₗ} {Formula} {ℓₘₗ} {Proof} {ℓₒ} {Domain} ⦃ constructiveLogicSign : _ ⦄ where
open Structure.Logic.Constructive.NaturalDeduction.ConstructiveLogicSignature {ℓₗ} {Formula... |
algebraic-stack_agda0000_doc_9939 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Finite maps with indexed keys and values, based on AVL trees
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Data.Product as Prod
open imp... |
algebraic-stack_agda0000_doc_9940 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Showing booleans
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Bool.Show where
open import Data.Bool.Base using (Bool; false; true)
ope... |
algebraic-stack_agda0000_doc_9941 | {-# OPTIONS --cubical --safe #-}
open import Algebra
module Algebra.SemiringLiterals {r} (rng : Semiring r) where
open Semiring rng
open import Literals.Number
open import Data.Nat.Literals
open import Data.Unit
import Data.Unit.UniversePolymorphic as Poly
open import Data.Nat.DivMod
open import Data.Nat using (ℕ; ... |
algebraic-stack_agda0000_doc_9942 | {-# OPTIONS --without-K --safe #-}
module Util.Relation.Binary.PropositionalEquality where
open import Relation.Binary.PropositionalEquality public
open import Data.Product using (uncurry)
open import Util.Prelude
private
variable
α β γ γ′ δ : Level
A B C A′ B′ C′ : Set α
trans-unassoc : {a b c d : A} ... |
algebraic-stack_agda0000_doc_9943 | {-# OPTIONS --without-K #-}
module MidiEvent where
open import Data.Fin using (Fin; #_)
open import Data.List using (List; _∷_; []; concat; map)
open import Data.Nat using (ℕ; _+_; _⊔_)
open import Data.Product using (_×_; _,_; proj₁)
open import Data.String using (String)
open import Data.Vec using (... |
algebraic-stack_agda0000_doc_9944 | {-# OPTIONS --without-K --safe #-}
module TypeTheory.HoTT.Data.Empty.Properties where
-- agda-stdlib
open import Data.Empty
-- agda-misc
open import TypeTheory.HoTT.Base
isProp-⊥ : isProp ⊥
isProp-⊥ x = ⊥-elim x
|
algebraic-stack_agda0000_doc_9945 | {-# OPTIONS --without-K --safe #-}
module Math.Combinatorics.Function.Properties.Lemma where
open import Data.Unit using (tt)
open import Data.Product
open import Data.Sum
open import Data.Nat
open import Data.Nat.Properties
open import Data.Nat.DivMod
open import Data.Nat.Solver using (module +-*-Solver)
open import... |
algebraic-stack_agda0000_doc_9946 | module Semantics where
open import Syntax public
-- Kripke models.
record Model : Set₁ where
infix 3 _⊩ᵅ_
field
World : Set
_≤_ : World → World → Set
refl≤ : ∀ {w} → w ≤ w
trans≤ : ∀ {w w′ w″} → w ≤ w′ → w′ ≤ w″ → w ≤ w″
idtrans≤ : ∀ {w w′} → (p : w ≤ w′) → trans≤ refl≤ p ≡... |
algebraic-stack_agda0000_doc_9947 | {- 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
-}
{-# OPTIONS --allow-unsolved-metas #-}
-- This module proves the two "V... |
algebraic-stack_agda0000_doc_9948 | -- Andreas, 2017-01-26
-- A hopefully exhaustive list of reasons why a function cannot
-- be projection-like. The correctness is ensured by triggering
-- a crash if any of the functions in this file is projection-like.
{-# OPTIONS -v tc.proj.like.crash:1000 #-}
data ⊥ : Set where
record ⊤ : Set where
data Bool : S... |
algebraic-stack_agda0000_doc_9949 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Experiments.CohomologyGroups where
open import Cubical.ZCohomology.Base
open import Cubical.ZCohomology.Properties
open import Cubical.ZCohomology.MayerVietorisUnreduced
open import Cubical.ZCohomology.Groups.Unit
open import Cubical.ZCohomology.KcompPr... |
algebraic-stack_agda0000_doc_9950 | module Sec2 where
open import Sec4
data Bool : Set where
T : Bool
F : Bool
_∣∣_ : Bool → Bool → Bool
_ ∣∣ F = F
_ ∣∣ T = T
_&_ : Bool → Bool → Bool
_ & F = F
F & T = F
T & T = T
_==>_ : Bool → Bool → Bool
F ==> _ = T
T ==> F = F
T ==> T = T
not : Bool -> Bool
not T = F
not F = T
data ℕ : Set where
Z : ... |
algebraic-stack_agda0000_doc_9951 | {-# OPTIONS --without-K #-}
module algebra.monoid where
open import algebra.monoid.core public
open import algebra.monoid.morphism public
open import algebra.monoid.mset public
|
algebraic-stack_agda0000_doc_7520 | module x02induction where
-- prove properties of inductive naturals and operations on them via induction
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong; sym)
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_; step-≡; _∎)
open import Data.Nat using (ℕ; zer... |
algebraic-stack_agda0000_doc_7521 |
-- Helper operations to construct and build signatures
module SOAS.Syntax.Build (T : Set) where
open import SOAS.Common
open import SOAS.Families.Build {T}
open import SOAS.Context {T}
open import Data.List.Base
open import SOAS.Syntax.Signature T
-- Syntactic sugar to construct arity - sort mappings
⟼₀_ : T → List... |
algebraic-stack_agda0000_doc_7522 |
module ANF where
open import Data.Nat
open import Data.Vec
open import Data.Fin
open import Data.String
open import Data.Rational
open import Data.Sum
open import Data.Unit
open import Binders.Var
record DataConApp (universe a : Set) : Set where
constructor _#_◂_
-- theres probably room for a... |
algebraic-stack_agda0000_doc_7523 | {-# OPTIONS --postfix-projections #-}
module StateSized.cellStateDependent where
open import Data.Product
open import Data.String.Base
{-
open import SizedIO.Object
open import SizedIO.ConsoleObject
-}
open import SizedIO.Console hiding (main)
open import SizedIO.Base
open import NativeIO
open import StateSizedI... |
algebraic-stack_agda0000_doc_7524 | module Logic.Propositional.Xor where
open import Logic.Propositional
open import Logic
import Lvl
-- TODO: Is it possible write a general construction for arbitrary number of xors? Probably by using rotate₃Fn₃Op₂?
data _⊕₃_⊕₃_ {ℓ₁ ℓ₂ ℓ₃} (P : Stmt{ℓ₁}) (Q : Stmt{ℓ₂}) (R : Stmt{ℓ₃}) : Stmt{ℓ₁ Lvl.⊔ ℓ₂ Lvl.⊔ ℓ₃} w... |
algebraic-stack_agda0000_doc_7525 |
module _ where
open import Agda.Builtin.Bool
postulate Eq : Set → Set
it : {A : Set} → ⦃ A ⦄ → A
it ⦃ x ⦄ = x
module M1 (A : Set) ⦃ eqA : Eq A ⦄ where
postulate B : Set
variable n : B
postulate P : B → Set
module M2 (A : Set) ⦃ eqA : Eq A ⦄ where
open M1 A
postulate
p₁ : P n
p₂ : P ⦃ it ⦄ n
... |
algebraic-stack_agda0000_doc_7526 |
record R : Set₁ where
field
A : Set
module _ (r : R) where
open R r
data D : Set where
c : A → D
data P : D → Set where
d : (x : A) → P (c x)
postulate
f : D → A
g : (x : D) → P x → D
g x (d y) with Set
g x (d y) | _ = x
|
algebraic-stack_agda0000_doc_7527 | postulate
A : Set
f : A → A → A → A → A → A → A → A → A → A → A
test : A
test = {!f!}
|
algebraic-stack_agda0000_doc_7528 | {-# OPTIONS --without-K --safe #-}
open import Level
open import Categories.Category using (Category; _[_,_])
-- Various conclusions that can be drawn from Yoneda
-- over a particular Category C
module Categories.Yoneda.Properties {o ℓ e : Level} (C : Category o ℓ e) where
open import Function using (_$_; Inverse) -... |
algebraic-stack_agda0000_doc_7529 | ------------------------------------------------------------------------
-- A virtual machine
------------------------------------------------------------------------
open import Prelude
import Lambda.Virtual-machine.Instructions
module Lambda.Virtual-machine
{Name : Type}
(open Lambda.Virtual-machine.Instructio... |
algebraic-stack_agda0000_doc_7530 |
module Rewrite where
open import Common.Equality
data _≈_ {A : Set}(x : A) : A → Set where
refl : ∀ {y} → x ≈ y
lem : ∀ {A} (x y : A) → x ≈ y
lem x y = refl
thm : {A : Set}(P : A → Set)(x y : A) → P x → P y
thm P x y px rewrite lem x y = {!!}
|
algebraic-stack_agda0000_doc_7531 | module Issue3818.M where
|
algebraic-stack_agda0000_doc_7532 | {-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.Polynomials.Multivariate.EquivCarac.An[Am[X]]-Anm[X] where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Nat renaming (_+_ to _+n_; _·_ to _·n_)
open import Cubical.Data.Vec
op... |
algebraic-stack_agda0000_doc_7533 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Some defined operations (multiplication by natural number and
-- exponentiation)
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Algebra
... |
algebraic-stack_agda0000_doc_7534 | {-# OPTIONS --cubical --safe --postfix-projections #-}
open import Prelude
open import Relation.Binary
module Data.AVLTree.Internal {k} {K : Type k} {r₁ r₂} (totalOrder : TotalOrder K r₁ r₂) where
open import Relation.Binary.Construct.Bounded totalOrder
open import Data.Nat using (_+_)
open TotalOrder totalOrder usi... |
algebraic-stack_agda0000_doc_7535 | {-# OPTIONS --guardedness #-}
module Stream where
import Lvl
open import Data.Boolean
open import Data.List as List using (List)
import Data.List.Functions as List
import Data.List.Proofs as List
import Data.List.Equiv.Id as List
open import Functional
open import Function.Iteration
open import Fu... |
algebraic-stack_agda0000_doc_11408 | {-# OPTIONS --without-K #-}
module Lecture8 where
import Lecture7
open Lecture7 public
-- Section 8.1 Propositions
is-prop : {i : Level} (A : UU i) → UU i
is-prop A = (x y : A) → is-contr (Id x y)
is-prop-empty : is-prop empty
is-prop-empty ()
is-prop-unit : is-prop unit
is-prop-unit = is-prop-is-contr is-contr-u... |
algebraic-stack_agda0000_doc_11409 | module MLib.Fin.Parts.Nat where
open import MLib.Prelude
open import MLib.Fin.Parts.Core
open Nat using (_*_; _+_; _<_)
open Fin using (fromℕ≤)
open Table
module Impl where
tryLookup : ∀ {n} {a} {A : Set a} → A → Table A n → ℕ → A
tryLookup {n = zero} z t _ = z
tryLookup {n = suc n} z t zero = lookup t zero
... |
algebraic-stack_agda0000_doc_11410 |
Type-of : {A : Set} → A → Set
Type-of {A = A} _ = A
module _ (A : Set) where
Foo : A → Set
Foo a with Type-of a
... | B = B
|
algebraic-stack_agda0000_doc_11411 | module RecordPatternMatching where
record _×_ (A B : Set) : Set where
constructor _,_
field
proj₁ : A
proj₂ : B
data Unit : Set where
unit : Unit
foo : Unit × Unit → Unit
foo (x , y) = {!!}
record Box (A : Set) : Set where
constructor [_]
field
proj : A
bar : Box Unit → Unit
bar [ x ] = {!!}
|
algebraic-stack_agda0000_doc_11412 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Unary relations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Relation.Unary where
open import Data.Empty
open import Data.Unit.Base using (... |
algebraic-stack_agda0000_doc_11413 | -- Andreas, 2016-06-20, issue #1891
-- Computation of which variables are splittable was wrong
-- in the presence of a where-module.
-- {-# OPTIONS -v interaction.case:20 #-}
data D : Set where
c : D
test : (x : D) → D
test x = {!x!} -- C-c C-c
where
y = c
-- WAS:
-- Splitting on x reports:
-- Not a (split... |
algebraic-stack_agda0000_doc_11414 | open import Data.Nat using (ℕ; _+_) renaming (_≤?_ to _≤?ₙ_)
open import Data.Bool using (Bool; true; false; not; _∧_)
open import Data.String using (String; _≟_)
open import Data.Sum using (_⊎_; [_,_]′; inj₁; inj₂)
open import Data.Product using (_×_; _,_)
open import Relation.Nullary u... |
algebraic-stack_agda0000_doc_11415 | module Category.Monoidal where
open import Category.NatIsomorphism
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.