id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_3264 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Core definitions for Functions
------------------------------------------------------------------------
-- The contents of this file should usually be accessed from `Function`.
{-# OPTIONS --without-K --safe #-... |
algebraic-stack_agda0000_doc_3265 | {-# OPTIONS --cubical --safe #-}
module Cubical.Foundations.Pointed.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed.Base
open import Cubical.Data.Prod
Π∙ : ∀ {ℓ ℓ'} (A : Type ℓ) (B∙ : A → Pointed ℓ') → Pointed (ℓ-max ℓ ℓ')
Π∙ A B∙ = (∀ a → typ (B∙ a)) , (λ a → pt (B∙ a... |
algebraic-stack_agda0000_doc_3266 | module FStream.Containers where
------------------------------------------------------------------------
-- Containers & their extension
------------------------------------------------------------------------
open import Data.Fin
open import Data.Maybe
open import Data.Unit
open import Library
ListC : Container ℓ₀... |
algebraic-stack_agda0000_doc_3267 | module MJ.Types where
open import Prelude hiding (_≟_)
open import Data.Fin.Properties as FinP using ()
open import Data.Vec
open import Data.List
open import Relation.Binary.Core
open import Relation.Nullary
open import Relation.Binary
data Cid (c : ℕ) : Set where
cls : Fin c → Cid c
Object : Cid c
_cid≟_ : ∀ ... |
algebraic-stack_agda0000_doc_3268 | {-# OPTIONS --without-K --safe #-}
module Math.NumberTheory.Summation.Generic where
-- agda-stdlib
open import Algebra
open import Data.Nat
module MonoidSummation {c e} (M : Monoid c e) where
open Monoid M renaming (Carrier to A)
-- Σ< n f = Σₖ₌₀ⁿ⁻¹[f k]
Σ< : ℕ → (ℕ → A) → A
Σ< 0 f = ε
Σ< (suc n) f ... |
algebraic-stack_agda0000_doc_3269 | module Type.Dependent where
import Lvl
open import Type
private
module Module where
-- Dependent product type (pi-type).
-- Also called: Dependent function type.
-- The right-hand side's type is a function type that uses the left-hand side's type as its "domain".
-- And then the type of the res... |
algebraic-stack_agda0000_doc_3270 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category.Core
module Categories.Object.Product.Limit {o ℓ e} (C : Category o ℓ e) where
open import Level
open import Data.Nat.Base using (ℕ)
open import Data.Fin.Base using (Fin)
open import Data.Fin.Patterns
open import Categories.Category.Lift
open import... |
algebraic-stack_agda0000_doc_3271 | module Scratch.FinDecEq1 where
open import Data.Bool.Base hiding (_≤_)
open import Data.Product
open import Data.Sum
open import Level renaming (suc to lsuc; _⊔_ to _⊔ℓ_; zero to lzero)
open import Relation.Nullary
open import Relation.Nullary.Decidable
open import Relation.Unary using (Decidable)
open import Relati... |
algebraic-stack_agda0000_doc_3272 | module Web.Semantic.DL.Signature where
infixr 4 _,_
-- a Signature is constructed from Concept Names and Role/Relation Names
data Signature : Set₁ where
_,_ : (CN RN : Set) → Signature
-- concept name (maps to Sets)
CN : Signature → Set
CN (CN , RN) = CN
-- Role Names (or relation names)
RN : Signature → Set
RN (... |
algebraic-stack_agda0000_doc_3273 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Every respectful binary relation induces a preorder. No claim is
-- made that this preorder is unique.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
... |
algebraic-stack_agda0000_doc_3274 | module regular-star where
open import Level renaming ( suc to Suc ; zero to Zero )
open import Data.List
open import Data.Nat hiding ( _≟_ )
open import Data.Fin hiding ( _+_ )
open import Data.Empty
open import Data.Unit
open import Data.Product
-- open import Data.Maybe
open import Relation.Nullary
open import ... |
algebraic-stack_agda0000_doc_3275 | -- Andreas, Ulf, 2022-05-06, AIM XXXV
-- Make sure you cannot trick Agda into admitting data types in IUniv.
-- The previous check let this exploit through.
-- Note: I : IUniv : SSet₁
open import Agda.Primitive.Cubical
mutual
Univ = _
data False : Univ where
I' : Univ
I' = I
-- Should fail.
-- Error:
-- Th... |
algebraic-stack_agda0000_doc_3276 | module Run where
open import Data.Bool
open import Data.Maybe
open import Data.Nat
open import Data.List
open import Data.List.All
open import Typing
open import Syntax
open import Global
open import Channel
open import Values
open import Session
open import Schedule
open import Examples
open import Aexamples
gas :... |
algebraic-stack_agda0000_doc_3277 | import Lvl
open import Type
module Type.Cardinality.Proofs {ℓₗ : Lvl.Level} where
open import Functional
import Logic.Predicate
import Logic.Predicate.Theorems
import Relator.Equals
import Relator.Equals.Proofs
import Type.Cardinality
import Type.Functions
import Type.Functions... |
algebraic-stack_agda0000_doc_3278 | -- Andreas, 2016-06-03, bug found by Ulf
-- {-# OPTIONS -v tc.cover:20 #-}
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
record Σ (A : Set) (B : A → Set) : Set where
constructor _,_
field fst : A
snd : B fst
open Σ
record ⊤ : Set where
data ⊥ : Set where
T : Bool → Set
T true = ⊤
T fal... |
algebraic-stack_agda0000_doc_3279 | module Data.List.Relation.Permutation where
import Data
open import Data.Boolean
open import Data.List
open import Data.List.Functions renaming (module LongOper to List)
open import Data.List.Relation
open import Functional using (id ; _∘_ ; const)
open import Logic.Propositional
open import Logic
import Lvl... |
algebraic-stack_agda0000_doc_15952 | {-# OPTIONS --safe #-}
module Definition.Conversion.Transitivity where
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.RedSteps
open import Definition.Conversion
open import Definition.Conversion... |
algebraic-stack_agda0000_doc_15953 | ------------------------------------------------------------------------
-- Mixfix operator grammars, and parsing of mixfix operators
--
-- Nils Anders Danielsson
------------------------------------------------------------------------
module Mixfix where
-- There are two separate developments here. One is very close... |
algebraic-stack_agda0000_doc_15954 | import Lvl
open import Functional
open import Logic.Propositional{Lvl.𝟎}
open import Logic.Predicate{Lvl.𝟎}{Lvl.𝟎}
open import Logic.Propositional.Theorems{Lvl.𝟎}
open import Relator.Equals{Lvl.𝟎}{Lvl.𝟎} renaming (_≡_ to _≡ₑ_)
open import Type{Lvl.𝟎}
-- Based on https://plato.stanford.edu/entries/set-theor... |
algebraic-stack_agda0000_doc_15955 | {-# OPTIONS --without-K --safe #-}
module Math.NumberTheory.Product.Generic.Properties where
-- agda-stdlib
open import Algebra
-- agda-misc
open import Math.NumberTheory.Summation.Generic.Properties
-- TODO add renamaings
module CommutativeMonoidProductProperties {c e} (CM : CommutativeMonoid c e) =
CommutativeM... |
algebraic-stack_agda0000_doc_15956 | -- Andreas, 2015-10-26, issue reported by Wolfram Kahl
-- {-# OPTIONS -v scope.mod.inst:30 -v tc.mod.check:10 -v tc.mod.apply:80 #-}
module _ where
module ModParamsRecord (A : Set) where
record R (B : Set) : Set where
field F : A → B
module ModParamsToLoose (A : Set) where
open ModParamsRecord
... |
algebraic-stack_agda0000_doc_15957 | {-# OPTIONS --without-K --safe #-}
open import Relation.Binary.Core
module Quasigroup.Definitions
{a ℓ} {A : Set a} -- The underlying set
(_≈_ : Rel A ℓ) -- The underlying equality
where
open import Algebra.Core
open import Data.Product
LatinSquareProperty₁ : Op₂ A → Set _
LatinSquareProperty₁ _*_ = ∀ a... |
algebraic-stack_agda0000_doc_15958 | {-# OPTIONS --cubical --safe #-}
module Cubical.Data.Universe.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Univalence
isInjectiveTransport : ∀ {ℓ : Level} {A B ... |
algebraic-stack_agda0000_doc_15959 | {-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Reflexivity {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.LogicalRelation.Properties
open import Definition.LogicalRelation.Substitution
open import Tools.Product... |
algebraic-stack_agda0000_doc_15960 | {-# OPTIONS --safe #-}
module Cubical.Algebra.RingSolver.RawRing where
open import Cubical.Foundations.Prelude
private
variable
ℓ : Level
record RawRing ℓ : Type (ℓ-suc ℓ) where
constructor rawring
field
Carrier : Type ℓ
0r : Carrier
1r : Carrier
_+_ : Carrier → Carrier → Ca... |
algebraic-stack_agda0000_doc_15961 | module Issue1760f where
-- Skipping a single record definition in an abstract block.
abstract
{-# NO_POSITIVITY_CHECK #-}
record U : Set where
field ap : U → U
|
algebraic-stack_agda0000_doc_15962 | {-# OPTIONS --verbose=10 #-}
module inorderF where
open import Data.Nat
open import Data.Vec
open import Agda.Builtin.Sigma
open import Data.Product
open import Data.Fin using (fromℕ)
open import trees
open import optics
open import lemmas
inorderTreeF : {A : Set} -> (t : Tree A) -> Vec A (#no... |
algebraic-stack_agda0000_doc_15963 | open import Common.Prelude
open import Common.Reflection
module TermSplicing1 where
x = unquote (give Set)
|
algebraic-stack_agda0000_doc_15964 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Some properties related to Data.Star
--
-- This module is DEPRECATED. Please use the
-- Relation.Binary.Construct.Closure.ReflexiveTransitive.Properties
-- module directly.
---------------------------------------... |
algebraic-stack_agda0000_doc_15965 | ------------------------------------------------------------------------------
-- Well-founded induction on the relation _◁_
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-pol... |
algebraic-stack_agda0000_doc_15966 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Lists defined in terms of the reflexive-transitive closure, Star
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Star.List where
open imp... |
algebraic-stack_agda0000_doc_15967 | module triple where
|
algebraic-stack_agda0000_doc_11328 | {-
Cubical Agda - A Dependently Typed PL with Univalence and HITs
==============================================================
Anders Mörtberg
Every Proof Assistant - September 17, 2020
Link to slides: https://staff.math.su.se/anders.mortberg/slides/EPA2020.pdf
Link to video: https://vi... |
algebraic-stack_agda0000_doc_11329 | module Structure.Sets.Relators where
|
algebraic-stack_agda0000_doc_11330 |
module Prelude.Monoid where
open import Prelude.Function
open import Prelude.Maybe
open import Prelude.List
open import Prelude.Semiring
open import Prelude.Applicative
open import Prelude.Functor
record Monoid {a} (A : Set a) : Set a where
infixr 6 _<>_
field
mempty : A
_<>_ : A → A → A
open Monoid {... |
algebraic-stack_agda0000_doc_11331 | {-# OPTIONS --safe #-}
module Cubical.Algebra.Group.Instances.NProd where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Data.Nat using (ℕ)
open import Cubical.Algebra.Group
private variable
ℓ : Level
open GroupStr
NProd-Group : (G : (n : ℕ) → Type ℓ) → (Gstr... |
algebraic-stack_agda0000_doc_11332 | ------------------------------------------------------------------------
-- An abstraction: term-like things
------------------------------------------------------------------------
open import Data.Universe.Indexed
module deBruijn.Context.Term-like
{i u e} (Uni : IndexedUniverse i u e) where
import Axiom.Extensio... |
algebraic-stack_agda0000_doc_11333 | module Logic.Propositional.Proofs.Structures where
import Data.Tuple as Tuple
import Lvl
open import Functional
open import Logic
open import Logic.Propositional
import Logic.Propositional.Theorems as Theorems
open import Structure.Operator.Properties
open import Structure.Relator.Equivalence
open impor... |
algebraic-stack_agda0000_doc_11334 | {-# OPTIONS --prop --rewriting #-}
module Examples.Sorting.Parallel where
open import Examples.Sorting.Parallel.Comparable
open import Calf costMonoid
open import Calf.Types.Nat
open import Calf.Types.List
open import Relation.Binary.PropositionalEquality as Eq using (_≡_)
open import Data.Product using (_,_)
open ... |
algebraic-stack_agda0000_doc_11335 |
module Day3 where
open import Data.String as String
open import Data.Maybe
open import Foreign.Haskell using (Unit)
open import Data.List as List hiding (fromMaybe)
open import Data.Nat
open import Data.Nat.DivMod
open import Data.Nat.Properties
import Data.Nat.Show as ℕs
open import Data.Char
open import Data.Vec a... |
algebraic-stack_agda0000_doc_11336 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
module experimental.NConnected where
lemma₁ : ∀ {i j} {A : Type i} {B : Type j} (f : A → B) {n : ℕ₋₂}
→ is-connected n A → is-connected (S n) B
→ has-conn-fibers n f
lemma₁ f cA cB = λ b → Σ-conn cA (λ a → path-conn cB)
lemma₂ : ∀ {i} {A B C : T... |
algebraic-stack_agda0000_doc_11337 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- The basic code for equational reasoning with a single relation
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
module Rel... |
algebraic-stack_agda0000_doc_11338 | {-# OPTIONS --universe-polymorphism #-}
module Issue227 where
open import Common.Level
data D (a p b : Level) (A : Set a) (P : A → Set p) : Set (p ⊔ a ⊔ b) where
d : ((x : A) → P x) → D a p b A P
-- Unsolved trivial constraint: Set (a ⊔ p) =< Set (p ⊔ a).
OK : ∀ {a} {A : Set a} → (A → Set) → A → Set _
OK P = P
N... |
algebraic-stack_agda0000_doc_11339 | ------------------------------------------------------------------------------
-- Induction principles for the total natural numbers inductive predicate
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{... |
algebraic-stack_agda0000_doc_11340 | {-# OPTIONS --without-K #-}
open import HoTT.Base
open import HoTT.Identity
module HoTT.Homotopy where
open variables
private variable f g : A → B
-- Lemma 2.4.3
~-natural : (α : f ~ g) {x y : A} (p : x == y) → α x ∙ ap g p == ap f p ∙ α y
~-natural α {x} refl rewrite α x = refl
~-natural-id : (α : f ~ id) {x y : A... |
algebraic-stack_agda0000_doc_11341 |
module UniDB.Morph.Unit where
open import UniDB.Spec
--------------------------------------------------------------------------------
data Unit : MOR where
unit : {γ : Dom} → Unit γ γ
instance
iUpUnit : Up Unit
_↑₁ {{iUpUnit}} unit = unit
_↑_ {{iUpUnit}} unit δ = unit
↑-zero {{iUpUnit}} unit = refl
↑-s... |
algebraic-stack_agda0000_doc_11342 | {-# OPTIONS --safe #-}
module Cubical.Categories.Functor.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Sigma
open import Cubical.Categories.Category
private
variable
ℓC ℓC' ℓD ℓD' : Level
record Functor (C : Category ℓC ℓC') (D : Category ℓD ℓD') :
Type (ℓ-max (ℓ-max ℓC... |
algebraic-stack_agda0000_doc_11343 | module Prelude.Monoid where
open import Prelude.Function
open import Prelude.Maybe
open import Prelude.List
open import Prelude.Semiring
open import Prelude.Semigroup public
open import Prelude.Applicative
open import Prelude.Functor
open import Prelude.Equality
open import Prelude.Variables
record Monoid {a} (A ... |
algebraic-stack_agda0000_doc_11664 | {-# OPTIONS --cubical #-}
module n2o.N2O where
open import proto.Base
open import proto.Core
open import proto.IO
open import n2o.Network.WebSocket
open import n2o.Network.Socket
open import n2o.Network.Core
open import n2o.Network.Internal
-- open import Infinity.Proto
postulate
terminationCheck : IO ⊤
{-#... |
algebraic-stack_agda0000_doc_11665 | module Syntax where
data S
(A₁ : Set)
(A₂ : A₁ → Set)
: Set
where
_,_
: (x₁ : A₁)
→ A₂ x₁
→ S A₁ A₂
syntax S A₁ (λ x → A₂)
= x ∈ A₁ × A₂
module M where
data S'
(A₁ : Set)
(A₂ : A₁ → Set)
: Set
where
_,'_
: (x₁ : A₁)
→ A₂ x₁
→ S' A₁ A₂
syntax S' A₁... |
algebraic-stack_agda0000_doc_11666 | -- Andreas, Issue 1944, Bengtfest Marsstrand 2016-04-28
-- A reason why issue 1098 (automatic opening of record modules)
-- cannot easily be fixed
data Bool : Set where
true false : Bool
if_then_else_ : ∀{A : Set} → Bool → A → A → A
if true then t else e = t
if false then t else e = e
record Testable (A : Set) :... |
algebraic-stack_agda0000_doc_11667 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Functors on indexed sets (predicates)
------------------------------------------------------------------------
-- Note that currently the functor laws are not included here.
{-# OPTIONS --without-K --safe #-}
... |
algebraic-stack_agda0000_doc_11668 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Monad.Duality {o ℓ e} (C : Category o ℓ e) where
open import Categories.Functor
open import Categories.NaturalTransformation
open import Categories.Monad
open import Categories.Comonad
private
module C = Category C
open C
ope... |
algebraic-stack_agda0000_doc_11669 | open import Reflection
open import Reflection.Term
open import Reflection.Universe
open import Reflection.Annotated
open import Agda.Builtin.Reflection using (withReconstructed; dontReduceDefs; onlyReduceDefs)
open import Relation.Nullary
open import Data.String as S
open import Data.Maybe hiding (_>>=_)
open import Da... |
algebraic-stack_agda0000_doc_11670 | ------------------------------------------------------------------------------
-- The relation of divisibility on partial natural numbers
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no... |
algebraic-stack_agda0000_doc_11671 | module FFI.IO where
import Lvl
open import Data
open import String
open import Type
postulate IO : ∀{a} → Type{a} → Type{a}
{-# BUILTIN IO IO #-}
{-# FOREIGN GHC type AgdaIO a b = IO b #-}
{-# COMPILE GHC IO = type AgdaIO #-}
{-# FOREIGN GHC import qualified Data.Text.IO #-}
postulate printStr : String → IO(Un... |
algebraic-stack_agda0000_doc_11672 | {-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NType2
-- [Subtype] is defined in lib.NType.
module lib.types.Subtype where
infix 40 _⊆_
_⊆_ : ∀ {i j₁ j₂} {A : Type i} → SubtypeProp A j₁ → SubtypeProp A j₂
→ Type (lmax i (lmax j₁ j₂))
P₁ ⊆ P₂ = ∀ a → SubtypeProp.prop P₁ a → SubtypeP... |
algebraic-stack_agda0000_doc_11673 | module _ where
module A where
postulate
Nat : Set
suc : Nat → Nat
open A
syntax suc x = ⟦ x ⟧
-- Error WAS:
-- Names out of scope in fixity declarations: suc
-- Error SHOULD BE something like:
-- Name 'suc' not declared in same scope as its syntax declaration.
|
algebraic-stack_agda0000_doc_11674 | {-# OPTIONS --sized-types --show-implicit #-}
-- {-# OPTIONS -v tc.size.solve:60 #-}
module Issue300 where
open import Common.Size
data Nat : {size : Size} -> Set where
zero : {size : Size} -> Nat {↑ size}
suc : {size : Size} -> Nat {size} -> Nat {↑ size}
-- Size meta used in a different context than the one c... |
algebraic-stack_agda0000_doc_11675 | module sn-calculus-compatconf.base where
open import sn-calculus
open import utility renaming (_U̬_ to _∪_)
open import Esterel.Lang
open import Esterel.Lang.Properties
open import Esterel.Lang.Binding
open import Esterel.Lang.CanFunction
using (Can ; Canₛ ; Canₛₕ ; Canₖ ; module CodeSet)
open import Esterel.Enviro... |
algebraic-stack_agda0000_doc_11676 | {- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2021, Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
import LibraBFT.Impl.OBM.Genesis as Genesis
open im... |
algebraic-stack_agda0000_doc_11677 | -- A simple word counter
open import Coinduction using ( ♯_ )
open import Data.Char.Classifier using ( isSpace )
open import Data.Bool using ( Bool ; true ; false )
open import Data.Natural using ( Natural ; show )
open import System.IO using ( Command )
open import System.IO.Transducers.Lazy using ( _⇒_ ; inp ; out ;... |
algebraic-stack_agda0000_doc_11678 |
module _ where
data D (@erased A : Set) : Set
-- The modality should not be repeated here
data D (@erased A) where
mkD : D A
|
algebraic-stack_agda0000_doc_11679 | {-# OPTIONS --guardedness #-}
module Class.Monad.IO where
open import Class.Monad
open import IO
open import Level
record MonadIO {a} (M : Set a → Set a) {{_ : Monad M}} : Set (suc a) where
field
liftIO : ∀ {A} → IO A → M A
open MonadIO {{...}} public
|
algebraic-stack_agda0000_doc_8896 | open import Function using ( _∘_ )
open import Data.Product using ( ∃ ; _×_ ; _,_ )
open import Data.Sum using ( _⊎_ ; inj₁ ; inj₂ )
open import Data.Empty using ( ⊥ ; ⊥-elim )
open import Data.Nat using ( ℕ ; zero ; suc ) renaming ( _+_ to _+ℕ_ ; _≤_ to _≤ℕ_ )
open import Relation.Binary.PropositionalEquality using
... |
algebraic-stack_agda0000_doc_8897 | open import MLib.Algebra.PropertyCode
open import MLib.Algebra.PropertyCode.Structures
module MLib.Matrix.Equality {c ℓ} (struct : Struct bimonoidCode c ℓ) where
open import MLib.Prelude
open import MLib.Matrix.Core
import Relation.Binary.Indexed as I
module S = Struct struct renaming (Carrier to S; _≈_ to _≈′_)
op... |
algebraic-stack_agda0000_doc_8898 | module Type.Identity.Heterogenous where
import Lvl
open import Type
data HId {ℓ} : ∀{A : Type{ℓ}}{B : Type{ℓ}} → A → B → Type{Lvl.𝐒(ℓ)} where
instance intro : ∀{T : Type{ℓ}}{x : T} → HId x x
|
algebraic-stack_agda0000_doc_8899 | {-# OPTIONS --cubical --safe #-}
module Data.Sigma.Properties where
open import Prelude hiding (B; C)
open import Cubical.Foundations.HLevels using (isOfHLevelΣ) public
open import Cubical.Data.Sigma.Properties using (Σ≡Prop) public
private
variable
B : A → Type b
C : Σ A B → Type c
reassoc : Σ (Σ A B) C ... |
algebraic-stack_agda0000_doc_8901 | {-# OPTIONS --allow-unsolved-metas --warning=error --without-K --guardedness #-}
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Setoids.Setoids
open import Rings.Definition
open import Rings.Lemmas
open import Rings.Orders.Partial.Definition
open import Rings.Orders.Total.Definition
open import... |
algebraic-stack_agda0000_doc_8902 | {-# OPTIONS --universe-polymorphism --allow-unsolved-metas --no-termination-check #-}
module Issue202 where
Foo : ∀ {A} → A → Set
Foo x = Foo x
-- Previously resulted in the following (cryptic) error:
-- Bug.agda:6,13-14
-- _5 !=< _5
-- when checking that the expression x has type _5 |
algebraic-stack_agda0000_doc_8903 | ------------------------------------------------------------------------
-- Operations and lemmas related to application of substitutions
------------------------------------------------------------------------
open import Data.Universe.Indexed
module deBruijn.Substitution.Data.Application.Application1
{i u e} {Uni... |
algebraic-stack_agda0000_doc_8904 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Pointers into star-lists
------------------------------------------------------------------------
{-# OPTIONS --with-K --safe #-}
module Data.Star.Pointer {ℓ} {I : Set ℓ} where
open import Data.Maybe.Base usin... |
algebraic-stack_agda0000_doc_8905 | -- (Pre)additive categories
{-# OPTIONS --safe #-}
module Cubical.Categories.Additive.Base where
open import Cubical.Algebra.AbGroup.Base
open import Cubical.Categories.Category.Base
open import Cubical.Categories.Limits.Initial
open import Cubical.Categories.Limits.Terminal
open import Cubical.Foundations.Prelude
p... |
algebraic-stack_agda0000_doc_8906 | -- Andreas, 2013-01-08, Reported by andres.sicard.ramirez, Jan 7
-- {-# OPTIONS -v term:10 -v term.matrices:40 #-}
-- The difference between @bar@ and @bar'@ is the position of the
-- hypothesis (n : ℕ). While @bar@ is accepted by the termination
-- checker, @bar'@ is rejected for it.
open import Common.Prelude renam... |
algebraic-stack_agda0000_doc_8907 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Diagram.Pullback
module Categories.Bicategory.Construction.Spans {o ℓ e} {𝒞 : Category o ℓ e}
(_×ₚ_ : ∀ {X Y Z} → (f : 𝒞 [ X , Z ]) (g : 𝒞 [ Y , Z ]) → Pullback 𝒞 f g) where
o... |
algebraic-stack_agda0000_doc_8908 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Categories.NaturalTransformation where
open import Cubical.Foundations.Prelude
open import Cubical.Categories.Category
open import Cubical.Categories.Functor
private
variable
ℓC ℓC' ℓD ℓD' : Level
module _ {C : Precategory ℓC ℓC'} {D : Precateg... |
algebraic-stack_agda0000_doc_8909 | {-
Part 3: Univalence and the SIP
- Univalence from ua and uaβ
- Transporting with ua (examples: ua not : Bool = Bool, ua suc : Z = Z, ...)
- Subst using ua
- The SIP as a consequence of ua
- Examples of using the SIP for math and programming (algebra, data
structures, etc.)
-}
{-# OPTIONS --cubical #-}
module Pa... |
algebraic-stack_agda0000_doc_8910 | {-# OPTIONS --cubical --safe #-}
module Fin where
open import Cubical.Core.Everything using (_≡_; Level; Type; Σ; _,_; fst; snd; _≃_; ~_)
open import Cubical.Foundations.Prelude using (refl; sym; _∙_; cong; transport; subst; funExt; transp; I; i0; i1)
open import Cubical.Foundations.Function using (_∘_)
open ... |
algebraic-stack_agda0000_doc_8911 | ----------------------------------------------------------------------
-- Functional big-step evaluation of terms in the partiality monad
-- (alternative version not productivity checker workarounds)
----------------------------------------------------------------------
module SystemF.Eval.NoWorkarounds where
open im... |
algebraic-stack_agda0000_doc_8900 | {-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Pi
module lib.types.Group where
record GroupStructure {i} (El : Type i) --(El-level : has-level 0 El)
: Type i where
constructor group-structure
field
ident : El
inv : El → El
comp : El → El → El
unitl : ∀ a → comp ident a... |
algebraic-stack_agda0000_doc_8464 | open import Data.Product using ( proj₁ ; proj₂ )
open import Data.Sum using ( _⊎_ ; inj₁ ; inj₂ )
open import Relation.Binary.PropositionalEquality using ( refl )
open import Web.Semantic.DL.ABox.Interp using ( ⌊_⌋ ; ind ; _*_ )
open import Web.Semantic.DL.ABox.Interp.Morphism using ( _,_ )
open import Web.Semantic.DL.... |
algebraic-stack_agda0000_doc_8465 | {-# OPTIONS --allow-unsolved-metas #-}
module ExtractDependent where
open import Agda.Builtin.Nat
open import Agda.Builtin.Bool
open import Agda.Builtin.String
apply : (A : Set) -> (B : A -> Set) ->
((x : A) -> B x) -> (a : A) -> B a
apply A B f a = f a
applySameName : (A : Set) -> (A : Set) -> (B : A ->... |
algebraic-stack_agda0000_doc_8466 | module FizzBuzz where
{-# IMPORT Data.Word #-}
{-# IMPORT FizzBuzz #-}
open import Data.Nat
open import IO.Primitive
open import Foreign.Haskell
postulate
ℕ′ : Set
zero′ : ℕ′
suc′ : ℕ′ → ℕ′
{-# COMPILED_TYPE ℕ′ Data.Word.Word32 #-}
{-# COMPILED zero′ 0 #-}
{-# COMPILED suc′ succ #-}
fromℕ : ℕ → ℕ′
fromℕ zer... |
algebraic-stack_agda0000_doc_8467 | --
-- Inspired by a blog post written by Arnaud Bailly
-- https://abailly.github.io/posts/dependently-typed-date.html
--
{-# OPTIONS --without-K #-}
module Date where
open import Data.Nat using (ℕ; zero; suc; _≡ᵇ_; _<_; _≤_; z≤n; s≤s; _≤?_; _<?_)
open import Data.Nat.DivMod using (_%_)
open import Data.Bool using (B... |
algebraic-stack_agda0000_doc_8468 | {-# OPTIONS --cubical --no-import-sorts --no-exact-split --safe #-}
module Cubical.Data.InfNat.Base where
open import Cubical.Data.Nat as ℕ using (ℕ)
open import Cubical.Core.Primitives
data ℕ+∞ : Type₀ where
∞ : ℕ+∞
fin : ℕ → ℕ+∞
suc : ℕ+∞ → ℕ+∞
suc ∞ = ∞
suc (fin n) = fin (ℕ.suc n)
zero : ℕ+∞
zero = fin ℕ.ze... |
algebraic-stack_agda0000_doc_8469 |
module MissingTypeSignatureInMutual where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
mutual
pred zero = zero
pred (suc n) = n
|
algebraic-stack_agda0000_doc_8470 | ------------------------------------------------------------------------
-- "Basic" infinite grammars
------------------------------------------------------------------------
-- For a larger and possibly more convenient, but equivalent, grammar
-- interface, see Grammar.Infinite.
{-# OPTIONS --guardedness #-}
module... |
algebraic-stack_agda0000_doc_8472 | module Effect where
open import Data.List
open import Data.List.All
open import Data.List.Any
open import Level
open import Relation.Binary.PropositionalEquality hiding ([_])
open import Function
open import Category.Monad
open import Data.Product
open import EffectUtil
open import Membership-equality hiding (_⊆_; set... |
algebraic-stack_agda0000_doc_8473 | -- Andreas, 2021-05-07, issue #5358 reported by ecavallo
-- Do not expand clauses with tactics attached to the target type!
open import Agda.Builtin.Unit
open import Agda.Builtin.Bool
open import Agda.Builtin.Reflection renaming (bindTC to _>>=_)
defaultTo : {A : Set} (x : A) → Term → TC ⊤
defaultTo x goal = do
`x ... |
algebraic-stack_agda0000_doc_8474 | -- Errors should precede warnings in info buffer
-- Reported by nad 2018-11-27
module Issue3416 where
A : Set
A = A
B : Set
B = Set
|
algebraic-stack_agda0000_doc_8475 | module ModuleMacro where
record ⊤
: Set
where
module M where
module N where
postulate
A
: Set
B
: Set
module O
= M
module P
= M
module Q
= P
module R
(x : ⊤)
= N
using (A)
module S
= N
renaming
( A
to A'
; B
to B'
)
y
: ⊤
y
= record {O}
C
: ⊤
... |
algebraic-stack_agda0000_doc_8476 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of operations on the Colist type
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --sized-types #-}
module Codata.Colist.Properties where
open ... |
algebraic-stack_agda0000_doc_8477 | module Cats.Category.Constructions.Epi where
open import Level
open import Cats.Category.Base
module Build {lo la l≈} (Cat : Category lo la l≈) where
private open module Cat = Category Cat
open Cat.≈-Reasoning
IsEpi : ∀ {A B} → A ⇒ B → Set (lo ⊔ la ⊔ l≈)
IsEpi {A} {B} f = ∀ {C} {g h : B ⇒ C} → g ∘ f ≈ h ∘... |
algebraic-stack_agda0000_doc_8478 | ------------------------------------------------------------------------
-- A library for working with dependently typed syntax
-- Nils Anders Danielsson
------------------------------------------------------------------------
-- This library is leaning heavily on two of Conor McBride's papers:
--
-- * Type-Preserving... |
algebraic-stack_agda0000_doc_8479 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties that are related to pointwise lifting of binary
-- relations to sigma types and make use of heterogeneous equality
------------------------------------------------------------------------
{-# OPTIONS ... |
algebraic-stack_agda0000_doc_8471 | open import Mockingbird.Forest using (Forest)
-- The Forest Without a Name
module Mockingbird.Problems.Chapter16 {b ℓ} (forest : Forest {b} {ℓ}) where
open import Data.Product using (_×_; _,_; ∃-syntax)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Function using (_$_; _⇔_; Equivalence)
open import Relatio... |
algebraic-stack_agda0000_doc_16832 | module main where
import parse
open import lib
open import huffman-types
import huffman
module parsem = parse huffman.gratr2-nt ptr
open parsem
open parsem.pnoderiv huffman.rrs huffman.huffman-rtn
open import run ptr
open noderiv {- from run.agda -}
{- imports for Huffman trees and also
Braun trees specialized t... |
algebraic-stack_agda0000_doc_16833 | {-# OPTIONS --safe #-} -- --without-K #-}
open import Relation.Binary.PropositionalEquality using (_≡_; _≢_; sym; refl; subst; trans; cong)
open import Relation.Nullary using (Dec; yes; no)
open import Relation.Nullary.Decidable using (True; toWitness; fromWitness)
open import Function using (_∘_)
import Data.Maybe a... |
algebraic-stack_agda0000_doc_16834 | module Examples where
open import Data.List using ([]; _∷_)
open import Data.Fin using () renaming (zero to fzero)
open import Relation.Binary using (Rel)
open import Level using () renaming (zero to lzero)
open import Syntax
open import Theory
module NatBool where
data Gr : Set where
nat : Gr
bool : Gr
... |
algebraic-stack_agda0000_doc_16835 | {-# OPTIONS --rewriting #-}
{-# OPTIONS --allow-unsolved-metas #-}
module NfCBPVLaws where
open import Library hiding (_×̇_)
open import NfCBPV
-- NB: mon⁺ is a comonad coalgebra
module MonIsComonadCoalgebra where
mon-id : ∀ (P : Ty⁺) {Γ} (a : ⟦ P ⟧⁺ Γ) → mon⁺ P a ⊆-refl ≡ a
mon-id (base o) x = {!mon... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.