id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_16924 |
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
data Ix : Set where
ix : .(i : Nat) (n : Nat) → Ix
data D : Ix → Set where
mkD : ∀ n → D (ix n n)
data ΣD : Set where
_,_ : ∀ i → D i → ΣD
foo : ΣD → Nat
foo (i , mkD n) = n
d : ΣD
d = ix 0 6 , mkD 6
-- Check that we pick the right (the non-ir... |
algebraic-stack_agda0000_doc_16925 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Reverse view
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Reverse where
open import Data.List.Base as L hiding (reverse)
open imp... |
algebraic-stack_agda0000_doc_16926 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Decidable propositional membership over vectors
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (Decidable)
open imp... |
algebraic-stack_agda0000_doc_16927 | ------------------------------------------------------------------------
-- Encodings and properties of higher-order extrema and intervals in
-- Fω with interval kinds
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module FOmegaInt.Typing.Encodings where
o... |
algebraic-stack_agda0000_doc_16720 | module Relation.Ternary.Separation.Monad.Identity where
open import Level
open import Function
open import Function using (_∘_; case_of_)
open import Relation.Binary.PropositionalEquality
open import Relation.Unary
open import Relation.Unary.PredicateTransformer hiding (_⊔_)
open import Relation.Ternary.Separation
ope... |
algebraic-stack_agda0000_doc_16721 |
module Data.Nat where
import Prelude
import Data.Bool as Bool
open Prelude
open Bool
data Nat : Set where
zero : Nat
suc : Nat -> Nat
{-# BUILTIN NATURAL Nat #-}
{-# BUILTIN SUC suc #-}
{-# BUILTIN ZERO zero #-}
infix 40 _==_ _<_ _≤_ _>_ _≥_
infixl 60 _+_ _-_
infixl 70 _*_
infixr 80 _^_
infix 100 _!
_+_ : N... |
algebraic-stack_agda0000_doc_16722 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Lists with fast append
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.DifferenceList where
open import Data.List.Base as L using (List)
... |
algebraic-stack_agda0000_doc_16723 | module Issue665 where
postulate
A : Set
record I : Set where
constructor i
field
f : A
data Wrap : (j : I) → Set where
con : ∀ {j} → Wrap j
postulate
C : Set
anything : C
works1 : ∀ {X} -> Wrap X -> C
works1 (con {i _}) with anything
... | z = z
works2 : ∀ {X} -> Wrap X -> C
works2 (con {_}) with ... |
algebraic-stack_agda0000_doc_16724 | {-# OPTIONS --without-K #-}
module F1 where
open import Data.Unit
open import Data.Sum hiding (map)
open import Data.Product hiding (map)
open import Data.List
open import Data.Nat
open import Data.Bool
{--
infixr 90 _⊗_
infixr 80 _⊕_
infixr 60 _∘_
infix 30 _⟷_
--}
------------------------------------------------... |
algebraic-stack_agda0000_doc_16725 | module Generic.Reflection.ReadData where
open import Generic.Core
open import Generic.Function.FoldMono
‵π : ArgInfo -> String -> Term -> Term -> Term
‵π i s a b = sate π (reify i) (sate refl) ∘ sate coerce ∘ sate _,_ a $
appDef (quote appRel) (implRelArg (reify (relevance i)) ∷ explRelArg (explLam s b) ∷ [])
quot... |
algebraic-stack_agda0000_doc_16726 |
-- Context extension of presheaves
module SOAS.Families.Delta {T : Set} where
open import SOAS.Common
open import SOAS.Context
open import SOAS.Variable
open import SOAS.Sorting
open import SOAS.Construction.Structure
open import SOAS.Families.Core {T}
-- | General context extension by a context Θ
module Unsorted ... |
algebraic-stack_agda0000_doc_16727 | module CombinatoryLogic.Syntax where
open import Data.String using (String; _++_)
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
-- Kapitel 1, Abschnitt C, §4 (Symbolische Festsetzungen), Def. 1
infixl 6 _∙_
data Combinator : Set where
-- Kapitel 1, Abschnitt C, §3 (Die formalen Grundbegriffe)... |
algebraic-stack_agda0000_doc_16729 | module Schedule where
open import Data.Bool
open import Data.Fin
open import Data.Empty
open import Data.List
open import Data.List.All
open import Data.Maybe
open import Data.Nat
open import Data.Product
open import Data.Sum
open import Data.Unit
open import Function using (_$_)
open import Relation.Nullary
open impo... |
algebraic-stack_agda0000_doc_16730 | {-# OPTIONS --without-K --safe #-}
module Dodo.Unary.Empty where
-- Stdlib imports
open import Level using (Level; _⊔_)
open import Data.Product using (∃-syntax)
open import Relation.Nullary using (¬_)
open import Relation.Unary using (Pred)
-- # Definitions
Empty₁ : ∀ {a ℓ : Level} {A : Set a} → Pred A ℓ → Set (a... |
algebraic-stack_agda0000_doc_16731 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Ints.BiInvInt.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat hiding (_+_; +-comm)
open import Cubical.Data.Int
open import Cubical.Data.Bool
open import Cubical.HITs.Ints... |
algebraic-stack_agda0000_doc_16732 | -- Useless abstract
module Issue476b where
abstract
data A : Set
data A where
|
algebraic-stack_agda0000_doc_16733 | ------------------------------------------------------------------------
-- Compiler correctness
------------------------------------------------------------------------
{-# OPTIONS --cubical --safe #-}
module Lambda.Simplified.Partiality-monad.Inductive.Compiler-correctness
where
open import Equality.Propositiona... |
algebraic-stack_agda0000_doc_16734 | {-# OPTIONS --without-K --safe #-}
-- In this module, we define F<:⁻, F<:ᵈ (F<: deterministic defined in Pierce92) and
-- show that F<:⁻ subtyping is undecidable.
module FsubMinus where
open import Data.List as List
open import Data.Nat
open import Data.Maybe as Maybe
open import Data.Product
open import Data.Vec as ... |
algebraic-stack_agda0000_doc_16735 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category
-- The core of a category.
-- See https://ncatlab.org/nlab/show/core
module Categories.Category.Construction.Core {o ℓ e} (𝒞 : Category o ℓ e) where
open import Level using (_⊔_)
open import Function using (flip)
open import Categories.Category.Gr... |
algebraic-stack_agda0000_doc_16728 | open import Sec4
data ℕ : Set where
Z : ℕ
S : ℕ → ℕ
-- Now ≥ relation
_≥_ : ∀ (m : ℕ) → ∀ (n : ℕ) → Prop
Z ≥ Z = ⊤
S m ≥ Z = ⊤
Z ≥ S n = ⊥
S m ≥ S n = m ≥ n
-- Example proof
-- eqqr : ((S (S (S Z))) ≥ (S (S Z))) → ((S (S Z)) ≥ (S (S (S Z))))
-- eqqr ()
-- -- Now is ≥ equivalence relation?
-- relfexivity
reflex... |
algebraic-stack_agda0000_doc_5664 |
module _ where
module M where
record S : Set₁ where
open M
field
F1 : Set
F2 : {!!}
|
algebraic-stack_agda0000_doc_5665 | {-# OPTIONS --without-K --no-pattern-matching #-}
module Ch2-9 where
open import Level hiding (lift)
open import Ch2-1
open import Ch2-2
open import Ch2-3
open import Ch2-4
open import Ch2-5
open import Ch2-6
open import Ch2-7
open import Ch2-8
open import Data.Product
open import Function using (id; _∘_)
-- happl... |
algebraic-stack_agda0000_doc_5666 |
module Unique where
open import Category
module Uniq (ℂ : Cat) where
private open module C = Cat ℂ
-- We say that f ∈! P iff f is the unique arrow satisfying P.
data _∈!_ {A B : Obj}(f : A ─→ B)(P : A ─→ B -> Set) : Set where
unique : (forall g -> P g -> f == g) -> f ∈! P
itsUnique : {A B : Obj}{f : A... |
algebraic-stack_agda0000_doc_5667 | module MLib.Fin.Parts.Nat.Simple.Properties where
open import MLib.Prelude
open import MLib.Fin.Parts.Nat
import MLib.Fin.Parts.Nat.Simple as S
module P a b = Partsℕ (S.repl a b)
open Nat using (_*_; _+_; _<_)
open Fin using (toℕ; fromℕ≤)
open List
fromAny : ∀ a b → Any Fin (S.repl a b) → ℕ × ℕ
fromAny zero b ()
f... |
algebraic-stack_agda0000_doc_5668 | module Luau.Substitution where
open import Luau.Syntax using (Expr; Stat; Block; nil; addr; var; function_is_end; _$_; block_is_end; local_←_; _∙_; done; return; _⟨_⟩ ; name; fun; arg; number; binexp)
open import Luau.Value using (Value; val)
open import Luau.Var using (Var; _≡ⱽ_)
open import Properties.Dec using (Dec... |
algebraic-stack_agda0000_doc_5670 | {-# OPTIONS --without-K #-}
module Model.Product where
open import Cats.Category
open import Data.Product using (<_,_>)
open import Model.Type.Core
open import Util.HoTT.HLevel
open import Util.Prelude hiding (_×_)
infixr 5 _×_
_×_ : ∀ {Γ} (T U : ⟦Type⟧ Γ) → ⟦Type⟧ Γ
T × U = record
{ ObjHSet = λ δ → T .ObjHSet ... |
algebraic-stack_agda0000_doc_5671 | {-
This file contains:
Properties of the FreeGroup:
- FreeGroup A is Set, SemiGroup, Monoid, Group
- Recursion principle for the FreeGroup
- Induction principle for the FreeGroup on hProps
- Condition for the equality of Group Homomorphisms from FreeGroup
- Equivalence of the types (A → Group .fst) (GroupHom (freeGro... |
algebraic-stack_agda0000_doc_5672 | -- Andreas, 2013-11-11 Better error for wrongly named implicit arg.
module Issue949 where
postulate
S : Set
F : {A : Set} → Set
ok : F {A = S}
err : F {B = S}
-- Old error:
--
-- Set should be a function type, but it isn't
-- when checking that {B = S} are valid arguments to a function of
-- type Set
--... |
algebraic-stack_agda0000_doc_5673 | open import Common.Prelude
open import Common.Reflect
module TermSplicingLooping where
mutual
f : Set -> Set
f = unquote (def (quote f) [])
|
algebraic-stack_agda0000_doc_5674 | module Lec1Start where
-- the -- mark introduces a "comment to end of line"
------------------------------------------------------------------------------
-- some basic "logical" types
------------------------------------------------------------------------------
data Zero : Set where
-- to give a value in a data... |
algebraic-stack_agda0000_doc_5675 | {-# OPTIONS --without-K --safe #-}
module Categories.Comonad.Relative where
open import Level
open import Categories.Category using (Category)
open import Categories.Functor using (Functor; Endofunctor; _∘F_) renaming (id to idF)
import Categories.Morphism.Reasoning as MR
open import Categories.NaturalTransformation ... |
algebraic-stack_agda0000_doc_5676 | -- This is an implementation of the equality type for Sets. Agda's
-- standard equality is more powerful. The main idea here is to
-- illustrate the equality type.
module Equality where
open import Level
-- The equality of two elements of type A. The type a ≡ b is a family
-- of types which captures the statement of e... |
algebraic-stack_agda0000_doc_5677 | {-# OPTIONS --copatterns --sized-types #-}
open import Level
open import Algebra.Structures
open import Relation.Binary
open import Algebra.FunctionProperties
module Comb (K : Set) (_≈_ : Rel K zero)
(_+_ _⋆_ : Op₂ K) (-_ : Op₁ K) (0# 1# : K)
(isRing : IsRing _≈_ _+_ _⋆_ -_ 0# 1#) where
open import... |
algebraic-stack_agda0000_doc_5678 | -- We apply the theory of quasi equivalence relations (QERs) to finite multisets and association lists.
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Relation.ZigZag.Applications.MultiSet where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundatio... |
algebraic-stack_agda0000_doc_5679 | {-# OPTIONS --warning=error #-}
{-# POLARITY F #-}
{-# POLARITY G #-}
|
algebraic-stack_agda0000_doc_5669 | {-# OPTIONS --without-K #-}
open import M-types.Base.Core
open import M-types.Base.Sum
open import M-types.Base.Prod
open import M-types.Base.Eq
module M-types.Base.Contr where
IsContr : ∏[ X ∈ Ty ℓ ] Ty ℓ
IsContr X = ∑[ x ∈ X ] ∏[ x′ ∈ X ] x′ ≡ x
Contr : Ty (ℓ-suc ℓ)
Contr {ℓ} = ∑[ X ∈ Ty ℓ ] IsCon... |
algebraic-stack_agda0000_doc_5745 | open import Function using (case_of_; _∘_)
open import Data.List using (List; _++_; map) renaming (_∷_ to _,_; _∷ʳ_ to _,′_; [] to ∅)
open import Data.List.Properties using (map-++-commute)
open import Data.Product using () renaming (_×_ to _x'_)
open import Relation.Binary.PropositionalEquality as PropEq using (_≡_; r... |
algebraic-stack_agda0000_doc_5746 | module Issue564 where
postulate
Level : Set
zero : Level
{-# BUILTIN LEVEL Level #-}
{-# BUILTIN LEVELZERO zero #-}
postulate
A : Level → Set
module M ℓ where
postulate a : A ℓ
postulate
P : A zero → Set
open M zero
p : P a
p = {!!}
|
algebraic-stack_agda0000_doc_5747 | {-# OPTIONS --without-K --safe #-}
-- This module primarily deals with expressions for pretty-printing,
-- for the step-by-step output from the solver.
open import Algebra
open import Relation.Binary
open import Relation.Binary.PropositionalEquality
open import Data.String using (String)
open import EqBool
open impor... |
algebraic-stack_agda0000_doc_5748 | module Data.Lens.Lens where
open import Haskell.Prelude
{-# FOREIGN AGDA2HS
{-# LANGUAGE Rank2Types #-}
#-}
---- Functors
-- The const functor, for which fmap does not change its value
data Const (a : Set) (b : Set) : Set where
CConst : a -> Const a b
getConst : {a : Set} {b : Set} -> Const a b -> a
getConst (C... |
algebraic-stack_agda0000_doc_5749 | module Postulate where
postulate
f
: {A : Set}
→ A
→ A
g
: {A : Set}
→ A
→ A
h
: {A : Set}
→ A
→ A
h x
= f x
|
algebraic-stack_agda0000_doc_5750 | {-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Variable.Other {ℓ} (𝕒 : Set ℓ) where
variable a b c d e f g h i j k l m : 𝕒
variable n o p q r s t u v w x y z : 𝕒
|
algebraic-stack_agda0000_doc_5751 | open import slots.imports
open import slots.defs
module slots.packed {cfg : config}(g : game cfg) where
open config cfg
open game g
LineCombinations = Vec ℕ n
ReelCombinations = Vec LineCombinations m
PackedLine = Fruit × ReelNo
PackedReel = Vec ℕ m
PackedReels = Vec PackedReel n
packReel : Reel → PackedReel
packR... |
algebraic-stack_agda0000_doc_5752 | module plfa.part1.Equality where
data _≡_ {A : Set} (x : A) : A → Set where
refl : x ≡ x
infix 4 _≡_
sym : ∀ {A : Set} {x y : A} → x ≡ y → y ≡ x
sym refl = refl
trans : ∀ {A : Set} {x y z : A} → x ≡ y → y ≡ z → x ≡ z
trans refl refl = refl
cong : ∀ {A B : Set} (f : A → B) {x y : A} → x ≡ y → f x ≡ f y
cong f ref... |
algebraic-stack_agda0000_doc_5753 | module Class.Monad.Writer where
open import Class.Monad
open import Data.Product
open import Data.Unit.Polymorphic
open import Level
open import Function
private
variable
a : Level
A : Set a
record MonadWriter (M : Set a → Set a) {{_ : Monad M}} (W : Set a) : Set (suc a) where
field
tell : W → M ⊤
... |
algebraic-stack_agda0000_doc_5754 | {-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.Snd {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped as U hiding (wk)
open import Definition.Untyped.Properties
open import Definition.Typed
open import Def... |
algebraic-stack_agda0000_doc_5755 | module plfa.part1.Naturals where
import Relation.Binary.PropositionalEquality as Eq
-- import Data.Nat using (ℕ; zero; suc; _+_; _*_; _^_; _∸_)
open Eq using (_≡_; refl)
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_; _∎)
-- 'refl' - the name for evidence that two terms are equal
-- Agda uses underbars to indicate where... |
algebraic-stack_agda0000_doc_5756 | module FunctionsInIndices where
open import Prelude
open import Eq
data Tree (a : Set) : ℕ -> Set where
leaf : a -> Tree a 1
node : forall n₁ n₂ -> Tree a n₁ -> Tree a n₂ -> Tree a (n₁ + n₂)
-- This does not work:
-- leftmost : forall {a} n -> Tree a (suc n) -> a
-- leftmost .0 (leaf x) ... |
algebraic-stack_agda0000_doc_5757 | {-# OPTIONS --experimental-irrelevance #-}
-- {-# OPTIONS -v tc.lhs:20 #-}
module ShapeIrrelevantIndex where
data Nat : Set where
Z : Nat
S : Nat → Nat
data Good : ..(_ : Nat) → Set where
goo : .(n : Nat) → Good (S n)
bad : .(n : Nat) → Good n → Nat
bad .(S n) (goo n) = n
|
algebraic-stack_agda0000_doc_5758 | {-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
-- From: Peter Dybjer. Comparing integrated and external logics of
-- functional programs. Science of Computer Programming, 14:59–79,
-- 1990
modu... |
algebraic-stack_agda0000_doc_5759 | module Ferros.Resource.CNode where
open import Ferros.Resource.CNode.Base public
|
algebraic-stack_agda0000_doc_5744 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.List.Relation.Unary.Any.Properties directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data... |
algebraic-stack_agda0000_doc_8784 | -- There was a problem with module instantiation if a definition
-- was in scope under more than one name. For instance, constructors
-- or non-private local modules being open publicly. In this case
-- the module instantiation incorrectly generated two separate names
-- for this definition.
module Issue263 where
modu... |
algebraic-stack_agda0000_doc_8785 | -- Basic intuitionistic propositional calculus, without ∨ or ⊥.
-- Kripke-style semantics with contexts as concrete worlds, and glueing for α and ▻.
-- Implicit syntax.
module BasicIPC.Semantics.KripkeConcreteGluedImplicit where
open import BasicIPC.Syntax.Common public
open import Common.Semantics public
open Concr... |
algebraic-stack_agda0000_doc_8786 | {-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Group
open import lib.types.Pi
open import lib.types.Sigma
open import lib.types.Truncation
open import lib.groups.GroupProduct
open import lib.groups.Homomorphisms
module lib.groups.TruncationGroup where
module _ {i} {El : Type i} (GS : GroupS... |
algebraic-stack_agda0000_doc_8787 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use the
-- Relation.Binary.Reasoning.MultiSetoid module directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
mo... |
algebraic-stack_agda0000_doc_8788 | module Prelude.Bool where
data Bool : Set where
true : Bool
false : Bool
{-# BUILTIN BOOL Bool #-}
{-# BUILTIN TRUE true #-}
{-# BUILTIN FALSE false #-}
not : Bool -> Bool
not true = false
not false = true
notnot : Bool -> Bool
notnot true = not (not true)
notnot false = not (not false)
infix 90 if_then... |
algebraic-stack_agda0000_doc_8789 | ------------------------------------------------------------------------
-- Many properties which hold for _∼_ also hold for _∼_ on₁ f
------------------------------------------------------------------------
open import Relation.Binary
module Relation.Binary.On {A B : Set} (f : B → A) where
open import Data.Function... |
algebraic-stack_agda0000_doc_8790 | {-# OPTIONS --cubical --omega-in-omega #-}
open import Agda.Primitive.Cubical
open import Agda.Builtin.Bool
-- With --omega-in-omega we are allowed to split on Setω datatypes.
-- Andrea 22/05/2020: in the future we might be allowed even without --omega-in-omega.
-- This test makes sure the interval I is still specia... |
algebraic-stack_agda0000_doc_8791 | {-# OPTIONS --without-K #-}
module sets.fin.properties where
open import sum
open import decidable
open import equality
open import function.core
open import function.extensionality
open import function.isomorphism
open import function.overloading
open import sets.core
open import sets.nat.core
hiding (_≟_; pred)
o... |
algebraic-stack_agda0000_doc_8792 | module StateSizedIO.IOObject where
open import Data.Product
open import Size
open import SizedIO.Base
open import StateSizedIO.Object
-- ---
-- ---
-- --- FILE IS DELETED !!!
-- ---
-- ---
-- An IO object is like a simple object,
-- but the method returns IO applied to the result type of a simple object
-- whi... |
algebraic-stack_agda0000_doc_8793 | module A.B where
{-# NON_TERMINATING #-}
easy : (A : Set) → A
easy = easy
|
algebraic-stack_agda0000_doc_8794 |
data D : Set where
zero : D
suc : D → D
postulate
f : D → D
{-# COMPILE GHC f = \ x -> x #-}
|
algebraic-stack_agda0000_doc_8796 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Instantiates the ring solver, using the natural numbers as the
-- coefficient "ring"
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Algeb... |
algebraic-stack_agda0000_doc_8797 | module BBHeap.Complete.Alternative {A : Set}(_≤_ : A → A → Set) where
open import BBHeap _≤_
open import Bound.Lower A
open import BTree.Equality {A} renaming (_≃_ to _≃'_)
open import BTree.Complete.Alternative {A} renaming (_⋘_ to _⋘'_ ; _⋙_ to _⋙'_ ; _⋗_ to _⋗'_)
lemma-forget≃ : {b b' : Bound}{l : BBHeap b}{r : ... |
algebraic-stack_agda0000_doc_8798 | ------------------------------------------------------------------------------
-- Existential quantifier on the inductive PA universe
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-uni... |
algebraic-stack_agda0000_doc_8799 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties related to setoid list membership
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Membership.Setoid.Properties where
open... |
algebraic-stack_agda0000_doc_8795 | {-# OPTIONS --cubical --safe #-}
module Algebra.Construct.Free.Semilattice.Eliminators where
open import Algebra.Construct.Free.Semilattice.Definition
open import Prelude
open import Algebra
record _⇘_ {a p} (A : Type a) (P : 𝒦 A → Type p) : Type (a ℓ⊔ p) where
no-eta-equality
constructor elim
field
⟦_⟧-s... |
algebraic-stack_agda0000_doc_112 | {-# OPTIONS --safe #-}
module Definition.Typed.EqRelInstance where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.Weakening
open import Definition.Typed.Properties
open import Definition.Typed.Reduction
open import Definition.Typed.Equa... |
algebraic-stack_agda0000_doc_113 | {- 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.Abstract.Types
open import LibraBFT.Abstract.Types... |
algebraic-stack_agda0000_doc_115 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Category.Construction.Spans {o ℓ e} (𝒞 : Category o ℓ e) where
open import Level
open import Categories.Category.Diagram.Span 𝒞
open import Categories.Morphism.Reasoning 𝒞
open Category 𝒞
open HomReasoning
open Equiv
open Spa... |
algebraic-stack_agda0000_doc_116 |
{- Definition of join for ◇ and associated lemmas. -}
module TemporalOps.Diamond.JoinLemmas where
open import CategoryTheory.Categories
open import CategoryTheory.Instances.Reactive
open import CategoryTheory.Functor
open import CategoryTheory.NatTrans
open import CategoryTheory.Monad
open import TemporalOps.Common
o... |
algebraic-stack_agda0000_doc_117 | {-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Subtyping where
open import Light.Level using (_⊔_ ; ++_)
open import Light.Variable.Levels
open import Light.Variable.Sets
record DirectSubtyping (𝕒 : Set aℓ) (𝕓 : Set bℓ) : Set (aℓ ⊔ bℓ) where
constructor #_
... |
algebraic-stack_agda0000_doc_118 |
module Issue561 where
open import Common.Char
open import Common.Prelude
primitive
primIsDigit : Char → Bool
postulate
IO : Set → Set
return : ∀ {A} → A → IO A
{-# BUILTIN IO IO #-}
main : IO Bool
main = return true |
algebraic-stack_agda0000_doc_119 | {-# OPTIONS --without-K #-}
module library.types.Types where
open import library.Basics
open import library.types.Empty public
open import library.types.Unit public
open import library.types.Bool public
open import library.types.Nat public
open import library.types.Int public
open import library.types.TLevel public
o... |
algebraic-stack_agda0000_doc_120 |
record Unit : Set where
constructor tt
postulate
C : Set
c : C
g : C
f : Unit → C
f tt = c
record R : Set where
constructor r
g = c
|
algebraic-stack_agda0000_doc_121 | -- A variant of code reported by Andreas Abel (who suggested that this
-- way to trigger the bug might have been due to NAD).
{-# OPTIONS --guardedness --sized-types #-}
open import Agda.Builtin.Sigma
open import Agda.Builtin.Size
data ⊥ : Set where
record Delay (A : Set) : Set where
coinductive
constructor ♯
... |
algebraic-stack_agda0000_doc_122 | test = forall _let_ → Set
|
algebraic-stack_agda0000_doc_123 | module SystemF.BigStep.Types where
open import Prelude
-- types are indexed by the number of open tvars
infixl 10 _⇒_
data Type (n : ℕ) : Set where
Unit : Type n
ν : (i : Fin n) → Type n
_⇒_ : Type n → Type n → Type n
∀' : Type (suc n) → Type n
open import Data.Fin.Substitution
open import Data.Vec
mo... |
algebraic-stack_agda0000_doc_124 | record R (A : Set) : Set where
constructor c₂
field
f : A → A
open module R′ (A : Set) (r : R A) = R {A = A} r
renaming (f to f′)
_ : (@0 A : Set) → R A → A → A
_ = λ A → f′ {A = A}
|
algebraic-stack_agda0000_doc_125 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Magma.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Algebra
open import Cubical.Algebra.Magma.Morphism
open import Cubical.Algebra.Magma... |
algebraic-stack_agda0000_doc_126 | module Numeral.Natural.Oper.Summation.Range where
import Lvl
open import Data.List
open import Data.List.Functions
open import Numeral.Natural
open import Type
_‥_ : ℕ → ℕ → List(ℕ)
_ ‥ 𝟎 = ∅
𝟎 ‥ 𝐒 b = 𝟎 ⊰ map 𝐒(𝟎 ‥ b)
𝐒 a ‥ 𝐒 b = map 𝐒(a ‥ b)
‥_ : ℕ → List(ℕ)
‥ b = 𝟎 ‥ b
_‥₌_ : ℕ → ℕ → List(ℕ)... |
algebraic-stack_agda0000_doc_127 | {-# OPTIONS --without-K --safe #-}
module Dodo.Unary.Equality where
-- Stdlib imports
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl)
open import Level using (Level; _⊔_)
open import Function using (_∘_)
open import Relation.Unary using (Pred)
-- # Definitions
infix 4 _⊆₁'_ _⊆₁_ _⇔₁_
... |
algebraic-stack_agda0000_doc_114 | module Data.List.First.Properties {ℓ}{A : Set ℓ} where
open import Data.Product
open import Data.List
open import Data.List.Any
open import Relation.Binary.PropositionalEquality
open import Function
open import Data.Empty
open import Data.List.First
open import Data.List.Membership.Propositional
first⟶∈ : ∀ {B : A → ... |
algebraic-stack_agda0000_doc_64 | {-# OPTIONS --without-K #-}
module Model.Term where
open import Cats.Category
open import Model.Size as MS using (_<_ ; ⟦_⟧Δ ; ⟦_⟧n ; ⟦_⟧σ)
open import Model.Type as MT
open import Util.HoTT.Equiv
open import Util.Prelude hiding (id ; _∘_ ; _×_)
open import Source.Size as SS using (v0 ; v1 ; ⋆)
open import Source.Siz... |
algebraic-stack_agda0000_doc_65 | ------------------------------------------------------------------------------
-- Co-inductive natural numbers
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
... |
algebraic-stack_agda0000_doc_66 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- An equality postulate which evaluates
------------------------------------------------------------------------
module Relation.Binary.PropositionalEquality.TrustMe where
open import Relation.Binary.Propositiona... |
algebraic-stack_agda0000_doc_67 | {-# OPTIONS --safe #-}
module Cubical.Categories.Instances.Semilattice where
open import Cubical.Foundations.Prelude
open import Cubical.Algebra.Semilattice
open import Cubical.Categories.Category
open import Cubical.Categories.Instances.Poset
open Category
module _ {ℓ} (L : Semilattice ℓ) where
-- more convenie... |
algebraic-stack_agda0000_doc_68 | {-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Functions.Definition
open import Setoids.Setoids
open import Setoids.Subset
open import Graphs.Definition
open import Sets.FinSet.Definition
open import Sets.FinSet.Lemm... |
algebraic-stack_agda0000_doc_70 | -- There was a problem with reordering telescopes.
module Issue234 where
postulate
A : Set
P : A → Set
data List : Set where
_∷ : A → List
data _≅_ {x : A}(p : P x) : ∀ {y} → P y → Set where
refl : p ≅ p
data _≡_ (x : A) : A → Set where
refl : x ≡ x
data Any (x : A) : Set where
here : P x → Any x
it :... |
algebraic-stack_agda0000_doc_71 | {-# OPTIONS --without-K #-}
open import HoTT
module lib.Quaternions where
data Sign : Type₀ where
plus : Sign
minus : Sign
opposite : Sign → Sign
opposite plus = minus
opposite minus = plus
_·_ : Sign → Sign → Sign
plus · x = x
minus · x = opposite x
·unitr : (x : Sign) → x · plus == x
·unitr plus = idp
·unit... |
algebraic-stack_agda0000_doc_72 |
open import SOAS.Metatheory.Syntax
-- Initial (⅀, 𝔛)-meta-algebra 𝕋 𝔛 is the free ⅀-monoid on 𝔛
module SOAS.Metatheory.FreeMonoid {T : Set} (Syn : Syntax {T}) where
open Syntax Syn
open import SOAS.Common
open import SOAS.Families.Core {T}
open import SOAS.Context {T}
open import SOAS.Variable {T}
open import S... |
algebraic-stack_agda0000_doc_73 | {- Name: Bowornmet (Ben) Hudson
--Type safety and meaning functions for L{⇒,+,×,unit}--
-}
open import Preliminaries
open import Preorder
open import Preorder-repackage
module L where
-- => and + and × and unit
data Typ : Set where
_⇒_ : Typ → Typ → Typ
_×'_ : Typ → Typ → Typ
_+'_ : Typ → Typ → Typ... |
algebraic-stack_agda0000_doc_74 | {-# OPTIONS --cubical --safe #-}
module Data.Nat where
open import Data.Nat.Base public
|
algebraic-stack_agda0000_doc_75 |
open import Common.Prelude
open import Common.Reflection
open import Common.Equality
open import Agda.Builtin.Sigma
magic₁ : ⊥ → Nat
magic₁ = λ ()
magic₂ : ⊥ → Nat
magic₂ = λ { () }
magic₃ : ⊥ → Nat
magic₃ ()
data Wrap (A : Set) : Set where
wrap : A → Wrap A
magic₄ : Wrap ⊥ → Nat
magic₄ (wrap ())
data OK : Set... |
algebraic-stack_agda0000_doc_76 | import cedille-options
open import general-util
module untyped-spans (options : cedille-options.options) {F : Set → Set} {{monadF : monad F}} where
open import lib
open import ctxt
open import cedille-types
open import spans options {F}
open import syntax-util
open import to-string options
untyped-term-spans : term... |
algebraic-stack_agda0000_doc_77 |
data unit : Set where tt : unit
record Y (A : Set) : Set where field y : A
record Z (A : Set) : Set where field z : A
instance
-- Y[unit] : Y unit
-- Y.y Y[unit] = tt
Z[unit] : Z unit
Z.z Z[unit] = tt
foo : ∀ (A : Set) {{YA : Y A}} {{ZA : Z A}} → unit
foo A = tt
foo[unit] : unit
foo[unit] = foo unit -- {{Z... |
algebraic-stack_agda0000_doc_78 | module L.Base.Empty where
-- Reexport definitions
open import L.Base.Empty.Core public
|
algebraic-stack_agda0000_doc_79 | {-# OPTIONS --without-K --rewriting #-}
open import lib.Base
open import lib.Equivalence
open import lib.PathGroupoid
open import lib.NType
open import lib.Univalence
open import lib.path-seq.Concat
open import lib.path-seq.Split
module lib.path-seq.Reasoning where
infix 30 _=↯=_
_=↯=_ : ∀ {i} {A : Type i} {a a' : A... |
algebraic-stack_agda0000_doc_69 | -- Care needs to be taken to distinguish between instance solutions with and
-- without leftover constraints.
module _ where
_∘_ : ∀ {A B C : Set} → (B → C) → (A → B) → A → C
(f ∘ g) x = f (g x)
postulate
Functor : (Set → Set) → Set₁
fmap : ∀ {F} {{_ : Functor F}} {A B} → (A → B) → F A → F B
List : Set → Set
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.