id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_16521 | open import Prelude
open import Nat
open import dynamics-core
module binders-disjoint-checks where
-- these are fairly mechanical lemmas that show that the
-- judgementally-defined binders-disjoint is really a type-directed
-- function
-- numbers
lem-bdσ-num : ∀{σ n} → binders-disjoint-σ σ (N n)
lem-bdσ-... |
algebraic-stack_agda0000_doc_16522 | {-
This file proves a variety of basic results about paths:
- refl, sym, cong and composition of paths. This is used to set up
equational reasoning.
- Transport, subst and functional extensionality
- J and its computation rule (up to a path)
- Σ-types and contractibility of singletons
- Converting PathP to and ... |
algebraic-stack_agda0000_doc_16523 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.DStructures.Structures.Group where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Structure
open import Cu... |
algebraic-stack_agda0000_doc_16524 | -- Hilbert-style formalisation of closed syntax.
-- Nested terms.
module OldBasicILP.UntypedSyntax.ClosedHilbert where
open import OldBasicILP.UntypedSyntax.Common public
-- Closed, untyped representations.
data Rep : Set where
APP : Rep → Rep → Rep
CI : Rep
CK : Rep
CS : Rep
BOX : Rep → Rep... |
algebraic-stack_agda0000_doc_16526 | {-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Setoids.Setoids
open import Setoids.Subset
open import Setoids.Functions.Definition
open import Sets.EquivalenceRelations
module Setoids.Functions.Lemmas {a b c d : _} ... |
algebraic-stack_agda0000_doc_16527 | ------------------------------------------------------------------------------
-- FOT (First-Order Theories)
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-... |
algebraic-stack_agda0000_doc_16518 | module RMonads where
open import Library
open import Categories
open import Functors
record RMonad {a b c d}{C : Cat {a}{b}}{D : Cat {c}{d}}(J : Fun C D) :
Set (a ⊔ b ⊔ c ⊔ d) where
constructor rmonad
open Cat
open Fun
field T : Obj C → Obj D
η : ∀{X} → Hom D (OMap J X) (T X)
bind :... |
algebraic-stack_agda0000_doc_16525 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Pairs of lists that share no common elements (setoid equality)
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
module Dat... |
algebraic-stack_agda0000_doc_13952 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Order morphisms
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary.Core
module Relation.Binary.Morphism.Structures
{a b} {... |
algebraic-stack_agda0000_doc_13953 | module CoInf where
open import Codata.Musical.Notation
-- Check that ∞ can be used as an "expression".
test : Set → Set
test = ∞
|
algebraic-stack_agda0000_doc_13954 | {-# OPTIONS --warning=error --safe --without-K #-}
open import Groups.Definition
open import Groups.Groups
open import Groups.Homomorphisms.Definition
open import Setoids.Setoids
open import Sets.EquivalenceRelations
open import Groups.Lemmas
open import Groups.Homomorphisms.Lemmas
module Groups.QuotientGroup.Definit... |
algebraic-stack_agda0000_doc_13955 |
module Prolegomenon where
open import Agda.Primitive
open import Relation.Binary
open import Algebra
open import Category.Applicative.Predicate
open import Algebra
open import Algebra.Structures
open import Category.Monad.Indexed
open import Algebra.FunctionProperties.Core
open import Function
PowerRightIdentity : ... |
algebraic-stack_agda0000_doc_13956 | module Int where
open import Agda.Builtin.FromNat
open import Agda.Builtin.FromNeg
open import Data.Char hiding (fromNat)
open import Data.Integer hiding (_≤_; suc)
open import Data.Integer.Literals
open import Data.List
open import Data.Nat hiding (_≤_)
open import Data.String
open import Data.Unit hiding (_≤_)
open ... |
algebraic-stack_agda0000_doc_13957 | {-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Sigma
open import lib.NType2
open import Preliminaries
open import Truncation_Level_Criteria
module Anonymous_Existence_CollSplit where
-- CHAPTER 4
-- SECTION 4.1
-- Lemma 4.1.2, part 1
constant-implies-path-constant : ∀ {i j} {X : Type i} ... |
algebraic-stack_agda0000_doc_13958 | {-# OPTIONS --without-K #-}
module PathStructure.Unit where
open import Equivalence
open import Types
split-path : {x y : ⊤} → x ≡ y → ⊤
split-path _ = _
merge-path : {x y : ⊤} → ⊤ → x ≡ y
merge-path _ = refl
split-merge-eq : {x y : ⊤} → (x ≡ y) ≃ ⊤
split-merge-eq
= split-path
, (merge-path , λ _ → refl)
, (m... |
algebraic-stack_agda0000_doc_13959 | -- Andreas, 2017-11-01, issue #2824
-- Allow built-ins that define a new name to be in parametrized module.
module Issue2824SizeU (A : Set) where -- This is the top-level module header.
{-# BUILTIN SIZEUNIV SizeU #-}
-- Should succeed.
|
algebraic-stack_agda0000_doc_13960 |
open import Agda.Builtin.Nat
data Vec (A : Set) : Nat → Set where
variable
A : Set
x : A
n : Nat
xs : Vec A n
postulate
IsNil : Vec A 0 → Set
foo : (xs : Vec A n) → IsNil xs
foo = {!!}
|
algebraic-stack_agda0000_doc_13962 | -- WARNING: This file was generated automatically by Vehicle
-- and should not be modified manually!
-- Metadata
-- - Agda version: 2.6.2
-- - AISEC version: 0.1.0.1
-- - Time generated: ???
{-# OPTIONS --allow-exec #-}
open import Vehicle
open import Vehicle.Data.Tensor
open import Data.Product
open import Data.I... |
algebraic-stack_agda0000_doc_13963 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import cohomology.Theory
open import groups.ExactSequence
open import groups.HomSequence
module cw.cohomology.grid.LongExactSequence {i} (CT : CohomologyTheory i)
{X Y Z : Ptd i} (n : ℤ) (f : X ⊙→ Y) (g : Y ⊙→ Z) where
open CohomologyTheory CT
open impo... |
algebraic-stack_agda0000_doc_13964 | -- Andreas, 2014-11-25, issue reported by Peter Divianski (divipp)
{-# OPTIONS --show-implicit #-}
-- {-# OPTIONS -v tc:10 #-}
-- {-# OPTIONS -v tc.inj:49 #-}
-- {-# OPTIONS -v tc.polarity:49 #-}
-- {-# OPTIONS -v tc.lhs:40 #-}
-- After loading the following Agda code, the last occurrence of 'one' is yellow.
-- Rema... |
algebraic-stack_agda0000_doc_13965 |
open import Agda.Builtin.Equality
_∋_ : ∀ {a} (A : Set a) → A → A
A ∋ x = x
cong : ∀ {a b} {A : Set a} {B : Set b}
(f : A → B) {x y} → x ≡ y → f x ≡ f y
cong f refl = refl
record IsRG (Node : Set) (Edge : Set) : Set where
field
src : Edge → Node
tgt : Edge → Node
rfl : Node → Edge
eq-src-rf... |
algebraic-stack_agda0000_doc_13966 | {- Jesper, 2019-07-05: At first, the fix to #3859 causes the line below to
raise a type error:
Cannot instantiate the metavariable _6 to solution Set
(Agda.Primitive.lsuc (Agda.Primitive.lsuc Agda.Primitive.lzero)
Agda.Primitive.⊔ Agda.Primitive.lsuc a) since it contains the
variable a which is not in scope of... |
algebraic-stack_agda0000_doc_13967 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Ints.DiffInt.Base where
open import Cubical.Foundations.Prelude
open import Cubical.HITs.SetQuotients
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Sigma
open import Cubical.Data.Nat hiding (+-comm ; +-assoc) renaming (_+_ ... |
algebraic-stack_agda0000_doc_13961 | module prelude.Stream where
open import prelude
open import Data.List as L using (List)
record Stream (a : Set) : Set where
constructor _∷_
coinductive
field
hd : a
tl : Stream a
open Stream
take : ∀ {a} → ℕ → Stream a → List a
take ℕz xs = L.[]
take (ℕs n) xs = hd xs L.∷ take n (tl xs)
|
algebraic-stack_agda0000_doc_16816 | ------------------------------------------------------------------------
-- Some definitions related to Dec
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Dec where
open import Logical-equivalence hiding (_∘_)
open import Prelude
private
variable... |
algebraic-stack_agda0000_doc_16817 | module System.Environment.Primitive where
open import IO.Primitive
open import Agda.Builtin.String
open import Agda.Builtin.List
open import Agda.Builtin.Unit
import Foreign.Haskell as FFI
open import System.FilePath.Posix
postulate
getArgs : IO (List String)
getProgName : IO String
getExecut... |
algebraic-stack_agda0000_doc_16819 | {-# OPTIONS --without-K #-}
module Data.Bits.Count where
open import Type hiding (★)
open import Data.Two hiding (_==_)
open import Data.Bits
open import Data.Bits.OperationSyntax
import Data.Bits.Search as Search
open Search.SimpleSearch
open import Data.Bits.Sum
open import Data.Bool.Properties using (not-involut... |
algebraic-stack_agda0000_doc_16820 | module Pi.Interp where
open import Data.Unit
open import Data.Product
open import Data.Sum
open import Pi.Syntax
open import Pi.Opsem
-- Big-step intepreter
interp : {A B : 𝕌} → (A ↔ B) → ⟦ A ⟧ → ⟦ B ⟧
interp unite₊l (inj₂ v) = v
interp uniti₊l v = inj₂ v
interp swap₊ (inj₁ v) = inj₂ ... |
algebraic-stack_agda0000_doc_16821 |
module Oscar.Data.Unit where
open import Agda.Builtin.Unit public using (⊤; tt)
|
algebraic-stack_agda0000_doc_16822 | {-# OPTIONS --without-K #-}
module hott.loop.core where
open import sum
open import equality
open import function.core
open import function.isomorphism.core
open import function.overloading
open import pointed.core
open import sets.nat.core
Ω₁ : ∀ {i} → PSet i → PSet i
Ω₁ (X , x) = ((x ≡ x) , refl)
ΩP : ∀ {i} → ℕ → ... |
algebraic-stack_agda0000_doc_16823 | {-# OPTIONS --without-K --rewriting --exact-split #-}
open import lib.Basics
open import lib.types.PushoutFmap
open import lib.types.Span
open import lib.types.Coproduct
open import lib.types.Paths
open import Graphs.Definition
open import Coequalizers.Definition
open import Util.Coproducts
{- We show that given equ... |
algebraic-stack_agda0000_doc_16824 | {-
Normalize Integer Matrices
-}
{-# OPTIONS --safe #-}
module Cubical.Experiments.IntegerMatrix where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat
open import Cubical.Data.Int
open import Cubical.Data.FinData
open import Cubical.Data.List
open import Cubical.Algebra.CommRing
open import C... |
algebraic-stack_agda0000_doc_16825 | ------------------------------------------------------------------------
-- Some properties related to the const function
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
module Const
{reflexive} (eq : ∀ {a p} → Equality-with-J a p ref... |
algebraic-stack_agda0000_doc_16826 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of membership of vectors based on propositional equality.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Vec.Membership.Propos... |
algebraic-stack_agda0000_doc_16827 | {-# OPTIONS --without-K --exact-split --safe #-}
module Fragment.Algebra.Free.Atoms where
open import Level using (Level; _⊔_)
open import Data.Nat using (ℕ)
open import Data.Fin using (Fin)
open import Relation.Binary using (Setoid; IsEquivalence)
open import Relation.Binary.PropositionalEquality as PE using (_≡_)... |
algebraic-stack_agda0000_doc_16828 | ------------------------------------------------------------------------
-- Validity of declarative kinding of Fω with interval kinds
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module FOmegaInt.Kinding.Declarative.Validity where
open import Data.Fin us... |
algebraic-stack_agda0000_doc_16829 | {-# OPTIONS --cubical #-}
module _ where
module _ where
import Agda.Primitive
open import Agda.Primitive.Cubical public
postulate
Path' : ∀ {ℓ} {A : Set ℓ} → A → A → Set ℓ
PathP : ∀ {ℓ} (A : I → Set ℓ) → A i0 → A i1 → Set ℓ
{-# BUILTIN PATH Path' #-}
{-# BUILTIN PATHP P... |
algebraic-stack_agda0000_doc_16831 | open import FRP.JS.Nat using ( ℕ ; zero ; suc ; _≤_ ; _<_ ; _≟_ ; _+_ )
open import FRP.JS.Nat.Properties using ( ≤-impl-≯ ; <-impl-s≤ ; ≤≠-impl-< ; ≤-bot )
open import FRP.JS.Bool using ( Bool ; true ; false ; _∧_ )
open import FRP.JS.Maybe using ( Maybe ; just ; nothing )
open import FRP.JS.True using ( True ; contr... |
algebraic-stack_agda0000_doc_16818 | module bool-thms where
open import bool
open import eq
open import sum
open import empty
open import level
~~-elim : ∀ (b : 𝔹) → ~ ~ b ≡ b
~~-elim tt = refl
~~-elim ff = refl
&&-idem : ∀ {b} → b && b ≡ b
&&-idem{tt} = refl
&&-idem{ff} = refl
||-idem : ∀{b} → b || b ≡ b
||-idem{tt} = refl
||-idem{ff} = refl
||≡ff₁... |
algebraic-stack_agda0000_doc_16830 | open import Relation.Binary using (IsDecEquivalence)
open import Agda.Builtin.Equality
module UnifyMguF (FunctionName : Set) ⦃ isDecEquivalenceA : IsDecEquivalence (_≡_ {A = FunctionName}) ⦄ where
{-
module UnifyMguF where
postulate
FunctionName : Set
instance isDecEquivalenceA : IsDecEquivalence (_≡_ {A = Funct... |
algebraic-stack_agda0000_doc_6432 | -- Proof: if we non-deterministically select an element
-- which is less-than-or-equal than all other elements,
-- such a result is the minimum of the list.
-- This holds for any non-deterministically selected element.
-- Basically, this is the translation of the Curry rule:
--
-- min-nd xs@(_++[x]++_) | all (x<=) x... |
algebraic-stack_agda0000_doc_6433 | {-
A Cubical proof of Blakers-Massey Theorem (KANG Rongji, Oct. 2021)
Based on the previous type-theoretic proof described in
Kuen-Bang Hou (Favonia), Eric Finster, Dan Licata, Peter LeFanu Lumsdaine,
"A Mechanization of the Blakers–Massey Connectivity Theorem in Homotopy Type Theory"
(https://arxiv.org/abs/160... |
algebraic-stack_agda0000_doc_6434 | {-# OPTIONS --rewriting #-}
open import Agda.Primitive
postulate
_↦_ : ∀{i j}{A : Set i}{B : Set j} → A → B → Set (i ⊔ j)
{-# BUILTIN REWRITE _↦_ #-} -- currently fails a sanity check
postulate
resize : ∀{i j} → Set i → Set j
resize-id : ∀{i} {j} {A : Set i} → resize {i} {j} A ↦ A
{-# REWRITE resize-id #-}
... |
algebraic-stack_agda0000_doc_6435 | module Data.Num.Increment where
open import Data.Num.Core
open import Data.Num.Bounded
open import Data.Num.Maximum
open import Data.Num.Next
open import Data.Nat
open import Data.Nat.Properties
open import Data.Nat.Properties.Simple
open import Data.Nat.Properties.Extra
open import Data.Fin as Fin
using (Fin; f... |
algebraic-stack_agda0000_doc_6436 | module Haskell.RangedSets.RangedSet where
open import Agda.Builtin.Equality
open import Haskell.Prim
open import Haskell.Prim.Ord
open import Haskell.Prim.Bool
open import Haskell.Prim.Maybe
open import Haskell.Prim.Enum
open import Haskell.Prim.Num
open import Haskell.Prim.Eq
open import Haskell.Prim.Foldable
open im... |
algebraic-stack_agda0000_doc_6437 | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Bags with negative multiplicities, for Nehemiah.
--
-- Instead of implementing bags (with negative multiplicities,
-- like in the paper) in Agda, we postulate that a group of such
-- bags exist. Note that integer ba... |
algebraic-stack_agda0000_doc_6438 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of functions, such as associativity and commutativity
------------------------------------------------------------------------
-- These properties can (for instance) be used to define algebraic
-- str... |
algebraic-stack_agda0000_doc_6439 | ------------------------------------------------------------------------------
-- Properties of the divisibility relation
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymo... |
algebraic-stack_agda0000_doc_6440 | {-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.NType2
open import lib.types.Pi
open import lib.types.Group
{-
The definition of G-sets. Thanks to Daniel Grayson.
-}
module lib.types.GroupSet {i} where
-- The right group action with respect to the group [grp].
record GsetStructure (grp :... |
algebraic-stack_agda0000_doc_6442 | {-# OPTIONS --cubical --safe #-}
module Cubical.Data.Maybe.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Empty
open import Cubical.Data.Unit
open import Cubical.Da... |
algebraic-stack_agda0000_doc_6443 | {-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Weakening {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped as U hiding (wk)
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.Weakeni... |
algebraic-stack_agda0000_doc_6444 | {-# OPTIONS --without-K #-}
module function.extensionality.strong where
open import level
open import sum
open import function.core
open import equality.core
open import function.isomorphism
open import function.extensionality.core
open import function.extensionality.proof
open import hott.level.core
open import hott.... |
algebraic-stack_agda0000_doc_6445 | module ConstructorsInstance where
record UnitRC : Set where
instance
constructor tt
data UnitD : Set where
instance
tt : UnitD
postulate
fRC : {{_ : UnitRC}} → Set
fD : {{_ : UnitD}} → Set
tryRC : Set
tryRC = fRC
tryD : Set
tryD = fD
data D : Set where
a : D
instance
b : D
c : D
post... |
algebraic-stack_agda0000_doc_6446 | {-# OPTIONS --cubical --safe #-}
module Cubical.HITs.Everything where
open import Cubical.HITs.Cylinder public
open import Cubical.HITs.Hopf public
open import Cubical.HITs.Interval public
open import Cubical.HITs.Ints.BiInvInt public hiding ( pred ; suc-pred ; pred-suc )
open import Cubical.HITs.Ints.DeltaInt public ... |
algebraic-stack_agda0000_doc_6447 | {-# OPTIONS -WShadowingInTelescope #-}
bad : Set → Set → Set
bad = λ x x → x
|
algebraic-stack_agda0000_doc_6441 | module StratSigma where
data Sigma0 (A : Set0) (B : A -> Set0) : Set0 where
_,_ : (x : A) (y : B x) -> Sigma0 A B
_*0_ : (A : Set0)(B : Set0) -> Set0
A *0 B = Sigma0 A \_ -> B
fst0 : {A : Set0}{B : A -> Set0} -> Sigma0 A B -> A
fst0 (a , _) = a
snd0 : {A : Set0}{B : A -> Set0} (p : Sigma0 A B) -> B (fst0 p)
snd... |
algebraic-stack_agda0000_doc_14848 | {-# OPTIONS --without-K #-}
data D : Set where
@0 c : D
data P : D → Set where
d : P c
|
algebraic-stack_agda0000_doc_14849 | ------------------------------------------------------------------------
-- Unary relations
------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K ... |
algebraic-stack_agda0000_doc_14850 | open import Prelude
open import Nat
module contexts where
-- variables are named with naturals in ė. therefore we represent
-- contexts as functions from names for variables (nats) to possible
-- bindings.
_ctx : Set → Set
A ctx = Nat → Maybe A
-- convenient shorthand for the (unique up to fun. ext.) emp... |
algebraic-stack_agda0000_doc_14851 | {-# OPTIONS --cubical --safe #-}
open import Algebra
module Algebra.Construct.OrderedMonoid {ℓ} (monoid : Monoid ℓ) where
open import Prelude
open import Relation.Binary
open import Path.Reasoning
open Monoid monoid
infix 4 _≤_ _≥_ _<_ _>_
_≤_ : 𝑆 → 𝑆 → Type ℓ
x ≤ y = ∃ z × (y ≡ x ∙ z)
_<_ : 𝑆 → 𝑆 → Type ℓ
x ... |
algebraic-stack_agda0000_doc_14852 | {-# OPTIONS --without-K #-}
open import lib.Basics
module lib.types.Empty where
⊥ = Empty
⊥-elim : ∀ {i} {A : ⊥ → Type i} → ((x : ⊥) → A x)
⊥-elim = Empty-elim
Empty-rec : ∀ {i} {A : Type i} → (Empty → A)
Empty-rec = Empty-elim
⊥-rec : ∀ {i} {A : Type i} → (⊥ → A)
⊥-rec = Empty-rec
Empty-is-prop : is-prop Empty
... |
algebraic-stack_agda0000_doc_14853 |
module UnequalSorts where
data One : Set where one : One
data One' : Set1 where one' : One'
err : One
err = one'
|
algebraic-stack_agda0000_doc_14854 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Functor.Bifunctor
module Categories.Diagram.Wedge {o ℓ e o′ ℓ′ e′} {C : Category o ℓ e} {D : Category o′ ℓ′ e′}
(F : Bifunctor (Category.op C) C D) where
private
module C = Category C
module D = Category D
open D
open... |
algebraic-stack_agda0000_doc_14856 | {-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Order
open import Numbers.Naturals.Naturals
open import Numbers.Naturals.EuclideanAlgorithm
open import Semirings.Definition
open import Orders.Total.Definition
module Numb... |
algebraic-stack_agda0000_doc_14857 | -- 2011-09-15 by Nisse
-- {-# OPTIONS -v tc.lhs.unify:15 #-}
module Issue292-17 where
data _≡_ {A : Set} (x : A) : A → Set where
refl : x ≡ x
record Σ (A : Set) (B : A → Set) : Set where
constructor _,_
field
proj₁ : A
proj₂ : B proj₁
open Σ
postulate
I : Set
U : I → Set
El : ∀ {i} → U i → Set... |
algebraic-stack_agda0000_doc_14858 | {-# OPTIONS --safe --cubical #-}
module Prelude where
open import Level public
open import Data.Sigma public
open import Function.Fiber public
open import Data.Empty public
open import Data.Unit public
open import Data.Nat public
using (ℕ; suc; zero)
open import Data.Bool public
using (Bool; true; false; bool; if... |
algebraic-stack_agda0000_doc_14859 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Various forms of induction for natural numbers
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Nat.Induction where
open import Function
o... |
algebraic-stack_agda0000_doc_14860 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category
import Categories.Category.Monoidal as M
-- Properties of Monoidal Categories
module Categories.Category.Monoidal.Properties
{o ℓ e} {C : Category o ℓ e} (MC : M.Monoidal C) where
open import Data.Product using (_,_; Σ; uncurry′)
open Category C
o... |
algebraic-stack_agda0000_doc_14861 | module NoSuchBuiltinName where
postulate X : Set
{-# BUILTIN FOOBAR X #-}
|
algebraic-stack_agda0000_doc_14862 | -- Andreas, 2020-06-24, issue #4775 reported by JakobBruenker
-- Non-record patterns in lets and lambdas lead to internal error
-- {-# OPTIONS -v tc.term.lambda:30 #-}
-- {-# OPTIONS -v tc.lhs:15 #-}
-- {-# OPTIONS -v tc.term.let.pattern:30 #-}
-- -- {-# OPTIONS -v tc.term.let.pattern:80 #-}
open import Agda.Builtin.... |
algebraic-stack_agda0000_doc_14863 | -- This file defines the Euclidean Domain structure.
{-# OPTIONS --without-K --safe #-}
module EuclideanDomain where
-- We comply to the definition format in stdlib, i.e. define an
-- IsSomething predicate then define the bundle.
open import Relation.Binary using (Rel; Setoid; IsEquivalence)
module Structures
... |
algebraic-stack_agda0000_doc_14855 | -- Andreas, 2016-10-11, AIM XXIV, issue #2248
-- COMPILED_TYPE should only work on postulates
data Unit : Set where
unit : Unit
postulate
IO : Set → Set
{-# BUILTIN IO IO #-}
{-# COMPILE GHC IO = type IO #-}
abstract
IO' : Set → Set
IO' A = A
doNothing : IO' Unit
doNothing = unit
{-# COMPILE GHC IO' =... |
algebraic-stack_agda0000_doc_3776 | postulate
Nat : Set
succ : Nat → Nat
Le : Nat → Nat → Set
Fin : Nat → Set
low : ∀ {m n} → Le m n → Fin n → Fin m
instance
Le-refl : ∀ {n} → Le n n
Le-succ : ∀ {m n} ⦃ _ : Le m n ⦄ → Le m (succ n)
Chk1 : ∀ {n} → Fin n → Set
Chk2 : ∀ {n} → Fin n → Fin n → Set
Chk3 : ∀ {m n} ⦃ _ : Le m n ⦄ → Fin ... |
algebraic-stack_agda0000_doc_3777 |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Data.FinData.Properties where
open import Cubical.Foundations.Function
open import Cubical.Foundations.Prelude
open import Cubical.Data.FinData.Base as Fin
import Cubical.Data.Nat as ℕ
open import Cubical.Data.Empty as Empty
open import Cubical.Relati... |
algebraic-stack_agda0000_doc_3778 | module Sandbox.IndRecIndexed where
-- Ornamental Algebras, Algebraic Ornaments, CONOR McBRIDE
-- https://personal.cis.strath.ac.uk/conor.mcbride/pub/OAAO/Ornament.pdf
-- A Finite Axiomtization of Inductive-Recursion definitions, Peter Dybjer, Anton Setzer
-- http://www.cse.chalmers.se/~peterd/papers/Finite_IR.pdf
open... |
algebraic-stack_agda0000_doc_3779 | {-# OPTIONS --without-K #-}
open import Type using (Type₀; Type₁)
open import Type.Identities
open import Data.Zero using (𝟘)
open import Data.One using (𝟙; 0₁)
open import Data.Two.Base using (𝟚; 0₂; 1₂)
open import Data.Product.NP using (Σ; _×_)
open import Data.Sum.NP using (_⊎_)
open import Data.Nat.Base using (... |
algebraic-stack_agda0000_doc_3780 |
module Oscar.Property.Preservativity where
open import Oscar.Level
open import Oscar.Relation
record Preservativity
{a} {A : Set a} {b} {B : A → Set b} {c} {C : (x : A) → B x → Set c}
(_▻₁_ : (x : A) → (y : B x) → C x y)
{d} {D : Set d} {e} {E : D → Set e} {f} {F : (x : D) → E x → Set f}
(_▻₂_ : (x : D) ... |
algebraic-stack_agda0000_doc_3781 | module Relation.Equality.Extensionality where
open import Relation.Equality
open import Data.Inductive.Higher.Interval
open import Relation.Path.Operation
funext : ∀ {a b}{A : Set a}{B : A → Set b}{f g : (x : A) → B x} → (∀ x → f x ≡ g x) → f ≡ g
funext {A = A}{B = B} {f = f}{g = g} p = ap {f = h} path-seg
where
... |
algebraic-stack_agda0000_doc_3782 | module Issue205 where
data ⊥ : Set where
data D : Set₁ where
d : (Set → Set) → D
_*_ : D → Set → Set
d F * A = F A
foo : (F : D) → F * ⊥
foo (d _) = ⊥
|
algebraic-stack_agda0000_doc_3783 |
postulate
A : Set
P : ..(_ : A) → Set
f : {x : A} → P x
g : ..(x : A) → P x
g x = f
|
algebraic-stack_agda0000_doc_3784 | {-# OPTIONS --without-K --safe #-}
open import Level
open import Categories.Category
module Categories.Category.Construction.Path {o ℓ e : Level} (C : Category o ℓ e) where
open import Function using (flip)
open import Relation.Binary hiding (_⇒_)
open import Relation.Binary.Construct.Closure.Transitive
open Catego... |
algebraic-stack_agda0000_doc_3785 | {-# OPTIONS --cubical #-}
module PathWithBoundary where
open import Agda.Builtin.Cubical.Path
open import Agda.Builtin.Nat
pred : Nat → Nat
pred (suc n) = n
pred 0 = 0
-- if the with abstraction correcly propagates the boundary the second
-- clause will not typecheck.
false : ∀ n {m} → (pred n + m) ≡ m
false n {... |
algebraic-stack_agda0000_doc_3786 | module Typing where
open import Data.Fin hiding (_≤_)
open import Data.List hiding (drop)
open import Data.List.All
open import Data.Maybe
open import Data.Nat
open import Data.Nat.Properties
open import Data.Product
open import Relation.Binary.PropositionalEquality
-- linearity indicator
data LU : Set where
LL UU... |
algebraic-stack_agda0000_doc_3787 | open import Level using () renaming (zero to ℓ₀)
open import Relation.Binary using (DecSetoid)
module CheckInsert (A : DecSetoid ℓ₀ ℓ₀) where
open import Data.Nat using (ℕ)
open import Data.Fin using (Fin)
open import Data.Fin.Properties using (_≟_)
open import Data.Maybe using (Maybe ; nothing ; just) renaming (seto... |
algebraic-stack_agda0000_doc_3788 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of First
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Relation.Unary.First.Properties where
open import Data.Empty
ope... |
algebraic-stack_agda0000_doc_3789 | {-# OPTIONS --safe --warning=error #-}
open import Sets.EquivalenceRelations
open import Functions.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_; Setω)
open import Setoids.Setoids
open import Groups.Definition
open import LogicalFormulae
open import Orders.WellFounded.Definition
open import Numb... |
algebraic-stack_agda0000_doc_3791 | {-# OPTIONS --without-K #-}
module Ch1 where
-- open import lib.Base
open import Base
-- warmup
module Eq-1-11-2 {i j} {A : Type i} {B : Type j} where
-- import lib.types.Coproduct
-- open import lib.types.Empty
-- open import lib.types.Sigma
-- If not A and not B, t... |
algebraic-stack_agda0000_doc_3790 | open import Function using (_∘_)
open import Data.List using (List; _++_) renaming (_∷_ to _,_; _∷ʳ_ to _,′_; [] to ∅)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Data.Product using (∃; _,_)
open import Relation.Nullary using (Dec; yes; no)
open import Relation.Nullary.Decidable using (True; toWitness)
ope... |
algebraic-stack_agda0000_doc_14960 | {-# OPTIONS --without-K #-}
open import HoTT.Base
open import HoTT.Identity
open import HoTT.Homotopy
module HoTT.Equivalence where
open variables
private variable C : 𝒰 i
module _ (f : A → B) where
qinv = Σ[ g ∶ (B → A) ] (g ∘ f ~ id) × (f ∘ g ~ id)
-- Bi-invertible map
linv = Σ[ g ∶ (B → A) ] g ∘ f ~ id
... |
algebraic-stack_agda0000_doc_14961 | module CTL.Modalities.EU where
-- TODO
|
algebraic-stack_agda0000_doc_14962 | module BBHeap.Last {A : Set}(_≤_ : A → A → Set) where
open import BBHeap _≤_
open import BBHeap.Compound _≤_
open import BBHeap.DropLast _≤_
open import Bound.Lower A
open import Data.Sum
last : {b : Bound}(h : BBHeap b) → Compound h → A
last (left {b} {x} {l} {r} b≤x l⋘r) (cl .b≤x .l⋘r)
with l | r | l⋘r | lemm... |
algebraic-stack_agda0000_doc_14963 | module Categories.Functor.Discrete where
open import Categories.Category
open import Categories.Functor
open import Categories.Agda
open import Categories.Categories
open import Categories.Support.PropositionalEquality
import Categories.Discrete as D
Discrete : ∀ {o} -> Functor (Sets o) (Categories o o _)
Discrete {o... |
algebraic-stack_agda0000_doc_14964 |
{-# OPTIONS --cubical --safe #-}
module Cubical.Data.Queue where
open import Cubical.Data.Queue.Base public
|
algebraic-stack_agda0000_doc_14965 | open import OutsideIn.Prelude
open import OutsideIn.X
module OutsideIn.Proof.Soundness(x : X) where
open import Data.Vec hiding (map; _>>=_)
open X(x)
import OutsideIn.Environments as EV
import OutsideIn.Expressions as E
import OutsideIn.TypeSchema as TS
import OutsideIn.TopLevel as TL
import OutsideIn.C... |
algebraic-stack_agda0000_doc_14966 |
open import SOAS.Common
open import SOAS.Families.Core
-- Algebras for a signature endofunctor
module SOAS.Metatheory.Algebra {T : Set} (⅀F : Functor (𝔽amiliesₛ {T}) (𝔽amiliesₛ {T})) where
module ⅀ = Functor ⅀F
⅀ : Familyₛ → Familyₛ
⅀ = ⅀.₀
⅀₁ : {𝒳 𝒴 : Familyₛ} → 𝒳 ⇾̣ 𝒴 → ⅀ 𝒳 ⇾̣ ⅀ 𝒴
⅀₁ = Functor.₁ ⅀F
|
algebraic-stack_agda0000_doc_14967 | -- Jesper, 2017-08-13: This test case now fails since instantiation
-- of metavariables during case splitting was disabled (see #2621).
{-# OPTIONS --allow-unsolved-metas #-}
record ⊤ : Set where
constructor tt
data I : Set where
i : ⊤ → I
data D : I → Set where
d : D (i tt)
postulate
P : (x : I) → D x → S... |
algebraic-stack_agda0000_doc_14968 | {-
Day 2 task of https://adventofcode.com/
-}
module a2 where
open import Agda.Builtin.IO using (IO)
open import Agda.Builtin.Unit using (⊤)
open import Agda.Builtin.String using (String; primShowNat; primStringAppend)
open import Agda.Builtin.Equality
open import Data.Nat
open import Data.Bool using (if_then_else_... |
algebraic-stack_agda0000_doc_14969 | {-# OPTIONS --prop #-}
module Miscellaneous.ClassicalWitness where
open import Agda.Primitive using (Prop)
open import Data
open import Data.Either
open import Functional
import Lvl
open import Type.Dependent
open import Type
private variable ℓ ℓ₁ ℓ₂ : Lvl.Level
private variable T A B Obj : Type{ℓ}
private var... |
algebraic-stack_agda0000_doc_14970 | {-# OPTIONS --warning=error --safe --without-K #-}
open import Orders.Total.Definition
open import LogicalFormulae
open import Maybe
module KeyValue.LinearStore.Definition {a b : _} (keySet : Set a) (valueSet : Set b) {c : _} (keyOrder : TotalOrder keySet {c}) where
open import KeyValue.KeyValue keySet valueSet
open... |
algebraic-stack_agda0000_doc_14971 | {-# OPTIONS --without-K --safe #-}
module Algebra.Linear.Construct where
import Algebra.Linear.Construct.Vector
import Algebra.Linear.Construct.Matrix
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.