id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_10416 | module Experiment.Expr.Expr where
open import Data.Fin
open import Data.Empty
open import Level
open import Data.Bool
open import Data.Nat hiding (_⊔_)
open import Data.Product
open import Data.List as List hiding (or; and)
data Expr {v} (V : Set v) : Set v where
var : V -> Expr V
or and : Expr V -> Expr V -> Exp... |
algebraic-stack_agda0000_doc_10417 | module UniDB.Subst.Sum where
open import UniDB.Subst.Core
open import UniDB.Morph.Sum
--------------------------------------------------------------------------------
module _
(T : STX) {{vrT : Vr T}} {{wkT : Wk T}}
(X : STX) {{wkX : Wk X}} {{apTX : Ap T X}} {{apRelTX : ApRel T X}}
(Ξ : MOR) {{lkTΞ : Lk T Ξ}} ... |
algebraic-stack_agda0000_doc_10418 | open import Prelude
open import Reflection renaming (Term to AgTerm; Type to AgType)
open import Data.String using (String)
open import RW.Language.RTerm
open import RW.Language.RTermUtils
open import RW.Language.FinTerm
open import RW.Language.GoalGuesser 1
open import RW.Strategy
module RW.RW (db : TStratDB) where... |
algebraic-stack_agda0000_doc_10419 | {-# OPTIONS --cubical --safe #-}
module Cardinality.Finite.SplitEnumerable.Inductive where
open import Data.List public
open import Data.List.Membership
open import Prelude
ℰ! : Type a → Type a
ℰ! A = Σ[ xs ⦂ List A ] ((x : A) → x ∈ xs)
|
algebraic-stack_agda0000_doc_10420 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
open import Cubical.Relation.Binary.Raw
module Cubical.Relation.Binary.Reasoning.Equivalence {c ℓ} {A : Type c} (E : Equivalence A ℓ) where
open Equivalence E
----------------------------------------------------------------------... |
algebraic-stack_agda0000_doc_10421 | {-# OPTIONS --without-K #-}
open import HoTT
open import homotopy.OneSkeleton
module homotopy.ConstantToSetFactorization
{i j} {A : Type i} {B : Type j} (B-is-set : is-set B)
(f : A → B) (f-is-const : ∀ a₁ a₂ → f a₁ == f a₂) where
private
Skel : Type i
Skel = Trunc ⟨0⟩ (OneSkeleton f)
abstract
... |
algebraic-stack_agda0000_doc_10422 | {-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.Id {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.Prop... |
algebraic-stack_agda0000_doc_10423 | {-# OPTIONS --cubical --safe #-}
open import Algebra
module Control.Monad.Weighted {ℓ} (rng : Semiring ℓ) where
open import Control.Monad.Weighted.Definition rng public
open import Control.Monad.Weighted.Union rng using (_∪_) public
open import Control.Monad.Weighted.Cond rng using (_⋊_) public
open impor... |
algebraic-stack_agda0000_doc_10424 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
module homotopy.TruncationLoopLadder where
⊙Ω-Trunc : ∀ {i} {n : ℕ₋₂} (X : Ptd i)
→ ⊙Ω (⊙Trunc (S n) X) ⊙≃ ⊙Trunc n (⊙Ω X)
⊙Ω-Trunc X = ≃-to-⊙≃ (Trunc=-equiv [ pt X ] [ pt X ]) idp
step : ∀ {i j} n {X : Ptd i} {Y : Ptd j} (f : X ⊙→ Y)
→ ⊙CommSqu... |
algebraic-stack_agda0000_doc_10425 | open import Relation.Binary.PropositionalEquality using (_≡_; refl; sym; cong; cong₂)
open import Data.Nat using (ℕ; zero; suc; _≤_; z≤n; s≤s)
open import Data.Nat.Properties using (≤-total)
open import Data.Fin using (Fin; zero; suc)
open import Data.Product using (∃; ∃-syntax; _×_; _,_)
open import Data.Sum using ([_... |
algebraic-stack_agda0000_doc_10426 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
module groups.Image where
module _ {i j k} {G : Group i} {H : Group j}
{K : Group k} (φ : H →ᴳ K) (ψ : G →ᴳ H) where
abstract
im-sub-im-∘ : is-surjᴳ ψ → im-propᴳ φ ⊆ᴳ im-propᴳ (φ ∘ᴳ ψ)
im-sub-im-∘ ψ-is-surj k = Trunc-rec Trunc-level
(λ{(h , ... |
algebraic-stack_agda0000_doc_10427 | {-# OPTIONS --allow-unsolved-metas #-}
open import Everything
module Test.ProblemWithLevelZero where
module _ (𝔓 : Ø₀) where
open Substitunction 𝔓
open Term 𝔓
fails : ∀ {m n} (f : Substitunction m n) → Substitunction m n
fails f = transitivity f ε -- FIXME
refl-works : ∀ {m} → Substitunction m m
re... |
algebraic-stack_agda0000_doc_10428 | {-# OPTIONS --safe #-}
module Cubical.HITs.Bouquet where
open import Cubical.HITs.Bouquet.Base public
open import Cubical.HITs.Bouquet.FundamentalGroupProof public
|
algebraic-stack_agda0000_doc_10429 |
module Issue224 where
data Maybe (A : Set) : Set where
nothing : Maybe A
just : A → Maybe A
data D (A : Set) : Maybe A → Set where
d₁ : (x : A) → D A (just x)
d₂ : ∀ {x} → D A x → D A x
data S : ∀ {A x} → D A x → Set₁ where
s : ∀ {A x} {d : D A x} → S d → S (d₂ d)
foo : {A : Set} → S (d₂ (d₁ (nothing ... |
algebraic-stack_agda0000_doc_10430 |
module Issue133 where
data Nat : Set where
zz : Nat
ss : Nat → Nat
data _==_ {X : Set}(x : X) : X → Set where
refl : x == x
data Zero : Set where
data Eq? (x : Nat) : Nat → Set where
same : Eq? x x
diff : {y : Nat} → (x == y → Zero) → Eq? x y
-- This failed before due to absurd lambda checking not getti... |
algebraic-stack_agda0000_doc_10431 | -- Andreas, 2017-01-18, issue #2408
-- DLubs were not serialized, thus, there was a problem with
-- level dependent on irrelevant values.
{-# OPTIONS --show-irrelevant #-}
-- {-# OPTIONS -v tc:70 #-}
open import Agda.Primitive
postulate
A : Set
l : .(a : A) → Level
F : .(a : A) → Set (l a)
-- checked type s... |
algebraic-stack_agda0000_doc_8992 | ------------------------------------------------------------------------------
-- The gcd is commutative
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OP... |
algebraic-stack_agda0000_doc_8993 | {-# OPTIONS --type-in-type #-}
module TooFewArgsWrongType where
open import AgdaPrelude
myFun : Vec Nat Zero -> Nat -> Nat
myFun x y = y
myApp : Nat
myApp = (myFun Zero)
|
algebraic-stack_agda0000_doc_8994 | module HoleFilling where
data Bool : Set where
false : Bool
true : Bool
_∧_ : Bool → Bool → Bool
false ∧ b = false
true ∧ b = b
|
algebraic-stack_agda0000_doc_8995 | open import Agda.Builtin.Nat
record R : Set where
field
x : Nat
open R {{...}}
f₁ f₂ : R
-- This is fine.
x ⦃ f₁ ⦄ = 0
-- WAS: THIS WORKS BUT MAKES NO SENSE!!!
f₂ ⦃ .x ⦄ = 0
-- Error:
-- Cannot eliminate type R with pattern ⦃ .x ⦄ (suggestion: write .(x)
-- for a dot pattern, or remove the braces for a pos... |
algebraic-stack_agda0000_doc_8996 |
module _ where
postulate
F : Set → Set
A : Set
module A (X : Set) where
postulate T : Set
module B where
private module M = A A
open M
postulate t : F T
postulate
op : {A : Set} → A → A → A
open A A
foo : F T
foo = op B.t {!!} -- ?0 : F .ReduceNotInScope.B.M.T
|
algebraic-stack_agda0000_doc_8997 | module Formalization.ClassicalPropositionalLogic.Syntax where
import Lvl
open import Functional
open import Sets.PredicateSet using (PredSet)
open import Type
private variable ℓₚ ℓ : Lvl.Level
module _ (P : Type{ℓₚ}) where
-- Formulas.
-- Inductive definition of the grammatical elements of the language of p... |
algebraic-stack_agda0000_doc_8998 | -- 2010-10-15
module Issue331 where
record ⊤ : Set where
constructor tt
data Wrap (I : Set) : Set where
wrap : I → Wrap I
data B (I : Set) : Wrap I → Set₁ where
b₁ : ∀ i → B I (wrap i)
b₂ : {w : Wrap I} → B I w → B I w
b₃ : (X : Set){w : Wrap I}(f : X → B I w) → B I w
ok : B ⊤ (wrap tt)
ok = b₂ (b₁ _)
-... |
algebraic-stack_agda0000_doc_8999 | open import guarded-recursion.prelude
module guarded-recursion.model where
-- ℂʷᵒᵖ (ℂ^{ω}^{op})
-- Notation:
-- For the category ℂ we use superscript 'c' to disambiguate (e.g. _→ᶜ_)
-- We use ᵖ for the presheaf category.
module Presheaf
{o m}
(Objᶜ : Type_ o)
(_→ᶜ_ : Objᶜ → Objᶜ → Type_ m)
(idᶜ : {A : Ob... |
algebraic-stack_agda0000_doc_9000 |
module Nat where
open import Prelude
open import Star
Nat : Set
Nat = Star One _ _
zero : Nat
zero = ε
suc : Nat -> Nat
suc n = _ • n
infixl 50 _+_ _-_
infixl 60 _*_
_+_ : Nat -> Nat -> Nat
_+_ = _++_
_*_ : Nat -> Nat -> Nat
x * y = bind id (\ _ -> y) x
_-_ : Nat -> Nat -> Nat
n - ε = n
ε - m... |
algebraic-stack_agda0000_doc_9001 | data N : Set where
Z : N
suc : N -> N
|
algebraic-stack_agda0000_doc_9002 | open import Prelude
module RW.Data.RTrie.Decl where
open import RW.Language.RTerm public
open import RW.Language.RTermIdx public
open import RW.Data.PMap (RTermᵢ ⊥) as IdxMap
data Rule : Set where
Gr : ℕ → Rule
Tr : ℕ → ℕ → Rule
Fr : ℕ → Name → Rule
mutual
Cell : Set
Cell = Idx... |
algebraic-stack_agda0000_doc_9003 | {-# OPTIONS --without-K #-}
module TypeEquivCat where
-- We will define a rig category whose objects are types and whose
-- morphisms are type equivalences; and where the equivalence of
-- morphisms ≋ is extensional
open import Level renaming (zero to lzero; suc to lsuc)
open import Data.Empty using (⊥)
... |
algebraic-stack_agda0000_doc_9004 |
module _ where
data X : Set where
data R (x : X) : Set where
module SUListSepElemTypes where
module M2 (Elem : Set) where
data InclWith : Set where
module M1 where
module InclZip1 (R : X → Set) where
open M2 X public
module InclZipUnion (Y : Set) where
module SepElemTypes = SUListSepElemTy... |
algebraic-stack_agda0000_doc_9005 |
open import Everything
module Test.Test5
{𝔵} {𝔛 : Ø 𝔵}
{𝔞} {𝔒₁ : 𝔛 → Ø 𝔞}
{𝔟} {𝔒₂ : 𝔛 → Ø 𝔟}
{ℓ}
{ℓ̇} (_↦_ : ∀ {x} → 𝔒₂ x → 𝔒₂ x → Ø ℓ̇)
⦃ _ : [ExtensibleType] _↦_ ⦄
⦃ _ : Smap!.class (Arrow 𝔒₁ 𝔒₂) (Extension 𝔒₂) ⦄
⦃ _ : Surjextensionality!.class (Arrow 𝔒₁ 𝔒₂) (Pointwise _↦_) (Extens... |
algebraic-stack_agda0000_doc_9006 |
module Div2 where
record True : Set where
data False : Set where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
NonZero : Nat -> Set
NonZero zero = False
NonZero (suc _) = True
divHelp : Nat -> Nat -> Nat -> Nat
divHelp zero zero c = suc zero
divHelp zero (suc y) c = zero
divHelp (suc x) zero ... |
algebraic-stack_agda0000_doc_9007 | {-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-}
module Agda.Builtin.IO where
postulate IO : ∀ {a} → Set a → Set a
{-# BUILTIN IO IO #-}
{-# FOREIGN GHC type AgdaIO a b = IO b #-}
{-# COMPILE GHC IO = type AgdaIO #-}
|
algebraic-stack_agda0000_doc_1584 | module calculus.properties where
open import utility
open import Esterel.Lang
open import Esterel.Lang.Binding
open import Esterel.Lang.Properties
open import Esterel.Lang.CanFunction
using (Canθₛ ; Canθₛₕ ; [S]-env)
open import Esterel.Environment as Env
using (Env ; Θ ; _←_ ; sig ; []env ; module SigMap ; modul... |
algebraic-stack_agda0000_doc_1585 | ------------------------------------------------------------------------
-- Groupoids
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
module Groupoid
{reflexive} (eq : ∀ {a p} → Equality-with-J a p reflexive) where
open import Prelud... |
algebraic-stack_agda0000_doc_1586 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties connecting left-scaling and right-scaling
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
-- The properties ar... |
algebraic-stack_agda0000_doc_1587 | {-# OPTIONS --without-K --safe #-}
module Categories.Category.Complete where
open import Level
open import Categories.Category
open import Categories.Category.Construction.Cones
open import Categories.Functor
open import Categories.Diagram.Cone.Properties
open import Categories.Diagram.Limit using (Limit)
Complete ... |
algebraic-stack_agda0000_doc_1588 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.EilenbergMacLane
open import homotopy.EilenbergMacLane1
open import homotopy.EilenbergMacLaneFunctor
open import homotopy.SmashFmapConn
open import homotopy.IterSuspSmash
open import cohomology.CupProduct.OnEM.InLowDegrees2
module cohomolog... |
algebraic-stack_agda0000_doc_1589 | open import Level using (_⊔_)
open import Function using (_$_)
open import Algebra using (CommutativeRing)
module AKS.Modular.Equivalence {c ℓ} (R : CommutativeRing c ℓ) where
open CommutativeRing R using (0#; 1#; _+_; _*_; -_; _-_)
renaming (Carrier to C)
open CommutativeRing R using (+-cong; +-congˡ; +-congʳ; +-i... |
algebraic-stack_agda0000_doc_1590 | {-# OPTIONS --prop --rewriting --confluence-check #-}
open import Agda.Primitive
open import Agda.Builtin.Equality
open import Agda.Builtin.Nat renaming (Nat to ℕ; _+_ to _+ℕ_)
infix 4 _≐_
data _≐_ {ℓ} {A : Set ℓ} (x : A) : A → Prop ℓ where
refl : x ≐ x
{-# BUILTIN REWRITE _≐_ #-}
variable
ℓ : Level
A B C : S... |
algebraic-stack_agda0000_doc_1591 | open import Nat
open import Prelude
open import core
module judgemental-inconsistency where
data incon : τ̇ → τ̇ → Set where
ICNumArr1 : {t1 t2 : τ̇} → incon num (t1 ==> t2)
ICNumArr2 : {t1 t2 : τ̇} → incon (t1 ==> t2) num
ICArr1 : {t1 t2 t3 t4 : τ̇} →
incon t1 t3 →
incon (t... |
algebraic-stack_agda0000_doc_1592 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import stash.modalities.Orthogonality
module stash.modalities.NullifyFamily where
module _ {ℓ} {I : Type ℓ} (X : I → Type ℓ) (A : Type ℓ) where
private
data #NullifyAll : Type ℓ where
#inj : A → #NullifyAll
#apex : (i : I) →... |
algebraic-stack_agda0000_doc_1593 | open import Data.Bool using ( Bool ; true ; false ; if_then_else_ )
open import Data.Empty using ( ⊥-elim )
open import Data.Product using ( _×_ ; _,_ )
open import Data.Sum using ( inj₁ ; inj₂ )
open import Relation.Unary using ( _∈_ ; _∉_ )
open import Web.Semantic.DL.Concept using ( neg )
open import Web.Semantic.DL... |
algebraic-stack_agda0000_doc_1594 | module examplesPaperJFP.CatTerm where
open import examplesPaperJFP.BasicIO hiding (main)
open import examplesPaperJFP.Console hiding (main)
open import examplesPaperJFP.NativeIOSafe
cat : IO ConsoleInterface Unit
force cat =
exec′ getLine λ{ nothing → return unit ; (just line) → delay (
exec′ (putStrLn l... |
algebraic-stack_agda0000_doc_1595 | open import Prelude
open import Nat
open import core
open import contexts
open import disjointness
-- this module contains lemmas and properties about the holes-disjoint
-- judgement that double check that it acts as we would expect
module holes-disjoint-checks where
-- these lemmas are all structurally recursive ... |
algebraic-stack_agda0000_doc_1596 | {-# OPTIONS --universe-polymorphism #-}
module Categories.Agda.ISetoids.Cocomplete.Helpers where
open import Level
open import Relation.Binary using (Setoid; module Setoid; Preorder; module Preorder; Rel; _=[_]⇒_)
open import Data.Product using (Σ; _,_; Σ-syntax)
-- import Relation.Binary.EqReasoning as EqReasoning
o... |
algebraic-stack_agda0000_doc_1597 | {-# OPTIONS --without-K #-}
open import HoTT
open import homotopy.JoinComm
open import homotopy.JoinAssocCubical
module homotopy.JoinSusp where
module _ {i} {A : Type i} where
private
module Into = JoinRec {A = Bool} {B = A}
{D = Suspension A}
(if_then north else south)
(λ _ → south... |
algebraic-stack_agda0000_doc_1598 | {-# OPTIONS --safe --warning=error --without-K --guardedness #-}
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Setoids.Setoids
open import Rings.Definition
open import Rings.Orders.Partial.Definition
open import Rings.Orders.Total.Definition
open import Groups.Definition
open import Groups.Lem... |
algebraic-stack_agda0000_doc_1599 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Morphism.Duality {o ℓ e} (C : Category o ℓ e) where
open Category C
import Categories.Morphism as M
private
module Op = M op
open M C
open import Categories.Morphism.Properties C
private
variable
A B X Y : Obj
f g h :... |
algebraic-stack_agda0000_doc_1472 | module #3 where
open import Relation.Binary.PropositionalEquality
{-
Exercise 2.3 Give a fourth, different, proof of Lemma 2.1.2, and prove that it is equal to the others.
-}
based-ind₌ : ∀ {i} {A : Set i}{a : A} → (C : (x : A) → (a ≡ x) → Set i) → C a refl → {x : A} → (p : a ≡ x) → C x p
based-ind₌ C c p rewrite ... |
algebraic-stack_agda0000_doc_1473 | module plfa-code.Isomorphism where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong; cong-app)
open Eq.≡-Reasoning
open import Data.Nat using (ℕ; zero; suc; _+_)
open import Data.Nat.Properties using (+-comm)
_∘_ : ∀ {A B C : Set} → (B → C) → (A → B) → (A → C)
(g ∘ f) x = g (f x)
_... |
algebraic-stack_agda0000_doc_1474 | module Base where
open import Relation.Binary.PropositionalEquality
is-prop : Set → Set
is-prop X = (x y : X) → x ≡ y
_∼_ : {A B : Set} → (f g : A → B) → Set
f ∼ g = ∀ a → f a ≡ g a
|
algebraic-stack_agda0000_doc_1475 | {-# OPTIONS --without-K --exact-split --safe #-}
open import Fragment.Algebra.Signature
module Fragment.Algebra.Free (Σ : Signature) where
open import Fragment.Algebra.Free.Base Σ public
open import Fragment.Algebra.Free.Properties Σ public
open import Fragment.Algebra.Free.Monad Σ public
open import Fragment.Algebr... |
algebraic-stack_agda0000_doc_1476 | {-
Half adjoint equivalences ([HAEquiv])
- Iso to HAEquiv ([iso→HAEquiv])
- Equiv to HAEquiv ([equiv→HAEquiv])
- Cong is an equivalence ([congEquiv])
-}
{-# OPTIONS --cubical --safe #-}
module Cubical.Foundations.HAEquiv where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import ... |
algebraic-stack_agda0000_doc_1477 | module monad-instances where
open import lib
open import general-util
instance
IO-monad : monad IO
IO-monad = record {returnM = return; bindM = _>>=_}
instance
id-monad : monad id
id-monad = record {returnM = id; bindM = λ a f → f a}
|
algebraic-stack_agda0000_doc_1478 | {-# OPTIONS --cubical --safe #-}
module Relation.Nullary.Discrete where
open import Relation.Nullary.Discrete.Base public
|
algebraic-stack_agda0000_doc_1479 | {-# OPTIONS --cubical-compatible #-}
module Issue712 where
data _≡_ {A : Set} : A → A → Set where
refl : (x : A) → x ≡ x
record _×_ (A B : Set) : Set where
field
p1 : A
p2 : B
open _×_
lemma : {A B : Set} {u v : A × B} (p : u ≡ v) → p1 u ≡ p1 v
lemma (refl _) = refl _
|
algebraic-stack_agda0000_doc_1480 | data ⊥ : Set where
_ : @0 ⊥ → Set
_ = λ @0 { () }
|
algebraic-stack_agda0000_doc_1481 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Zero-cost coercion to cross the FFI boundary
------------------------------------------------------------------------
{-# OPTIONS --without-K #-}
module Foreign.Haskell.Coerce where
---------------------------... |
algebraic-stack_agda0000_doc_1482 | ------------------------------------------------------------------------------
-- The gcd program is correct
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-... |
algebraic-stack_agda0000_doc_1483 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Basic types related to coinduction
------------------------------------------------------------------------
module Coinduction where
import Level
---------------------------------------------------------------... |
algebraic-stack_agda0000_doc_1484 | module tree-test where
open import tree
open import nat
open import bool
open import bool-to-string
open import list
test-tree = node 2 ( (leaf 3) :: (node 4 ( (leaf 5) :: (leaf 7) :: [] )) :: (leaf 6) :: (leaf 7) :: [])
perfect3 = perfect-binary-tree 3 tt
perfect3-string = 𝕋-to-string 𝔹-to-string perfect3 |
algebraic-stack_agda0000_doc_1485 | {-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.types.Bool
open import lib.types.Coproduct
open import lib.types.Paths
open import lib.types.Span
open import lib.types.Pushout
open import lib.types.Cofiber
open import lib.types.Sigma
open import lib.types.Wedge
module lib.types.Smash {i... |
algebraic-stack_agda0000_doc_1486 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Foundations.Structure where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
private
variable
ℓ ℓ' ℓ'' : Level
S : Type ℓ → Type ℓ'
-- A structure is a type-family S : Type ℓ → Type ℓ', i.e. for X : Type ℓ and s : ... |
algebraic-stack_agda0000_doc_1487 | {-# OPTIONS --type-in-type #-}
open import Agda.Primitive
test : Set
test = Setω
|
algebraic-stack_agda0000_doc_3360 | infix -3.14 _+_
postulate
_+_ : Set → Set → Set
|
algebraic-stack_agda0000_doc_3361 | -- Andreas, 2017-07-25, issue #2649, reported by gallais
-- Serialization killed range needed for error message.
-- {-# OPTIONS -v scope.clash:60 #-}
module Issue2649 where
open import Issue2649-1
open import Issue2649-2
id : (A : Set) → A → A
id A x = M.foo
where
module M = MyModule A x
-- Expected:
-- Duplic... |
algebraic-stack_agda0000_doc_3362 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Unsigned divisibility
------------------------------------------------------------------------
-- For signed divisibility see `Data.Integer.Divisibility.Signed`
{-# OPTIONS --without-K --safe #-}
module Data.In... |
algebraic-stack_agda0000_doc_3363 | -- Binary products
{-# OPTIONS --safe #-}
module Cubical.Categories.Limits.BinProduct where
open import Cubical.Categories.Category.Base
open import Cubical.Data.Sigma.Base
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Prelude
open import Cubical.HITs.PropositionalTruncation.Base
private
... |
algebraic-stack_agda0000_doc_3364 | module _ where
open import Agda.Builtin.Cubical.Glue hiding (primGlue)
primitive
primGlue : _
|
algebraic-stack_agda0000_doc_3365 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Printing Strings During Evaluation
------------------------------------------------------------------------
{-# OPTIONS --without-K --rewriting #-}
-- see README.Debug.Trace for a use-case
module Debug.Trace w... |
algebraic-stack_agda0000_doc_3366 | ------------------------------------------------------------------------------
-- Common stuff used by the gcd example
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorph... |
algebraic-stack_agda0000_doc_3367 | -- Andreas, 2013-10-21 reported by Christian Sattler
{-# OPTIONS --allow-unsolved-metas #-}
module Issue922 where
import Common.Level
f : Set → Set → Set
f x _ = x -- Note: second argument is unused
module _ (_ : f ? ?) where
g = f
-- Here an instance search for the unused argument (2nd ?)
-- is triggered.
... |
algebraic-stack_agda0000_doc_3368 | -- Andreas, 2018-10-27, issue #3323, reported by Guillaume Brunerie
--
-- Mismatches between original and repeated parameter list
-- should not lead to internal errors.
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
data T .(b : Bool) : Set
data T b where -- Omission of relevance info allowed
c : ... |
algebraic-stack_agda0000_doc_3369 | {-# OPTIONS --rewriting #-}
{- Lower can be a record if using type-in-type or allowing large eliminations:
{-# OPTIONS --type-in-type #-}
record Lower (A : Set₁) : Set where
constructor lower
field raise : A
open Lower
-}
postulate
_≡_ : ∀ {A : Set₁} → A → A → Set
Lower : (A : Set₁) → Set
lower : ∀ {A} → A ... |
algebraic-stack_agda0000_doc_3370 | module bstd.bash where
|
algebraic-stack_agda0000_doc_3371 | module Cats.Category.Constructions.Product where
open import Relation.Binary.PropositionalEquality as PropEq using (_≡_ ; refl)
open import Data.Bool using (Bool ; true ; false ; not; if_then_else_)
open import Relation.Binary.Core using (IsEquivalence)
open import Level
open import Cats.Category.Base
open import Cat... |
algebraic-stack_agda0000_doc_3372 | {-# OPTIONS --without-K --safe #-}
module Experiment.Applicative where
open import Function.Base
open import Relation.Binary.PropositionalEquality
record Functor (F : Set → Set) : Set₁ where
field
fmap : ∀ {A B} → (A → B) → F A → F B
field
fmap-id : ∀ {A} (x : F A) → fmap id x ≡ x
fmap-∘ : ∀ {A B ... |
algebraic-stack_agda0000_doc_3373 | {-# OPTIONS --prop #-}
open import Agda.Builtin.Equality
postulate
A : Set
P : Prop
p : P
f : P → A
mutual
X : A
X = _
test₁ : (x : P) → X ≡ f x
test₁ x = refl
test₂ : X ≡ f p
test₂ = refl
|
algebraic-stack_agda0000_doc_3374 | -- Andreas, 2016-12-15, issue #2341
-- `with` needs to abstract also in sort of target type.
-- {-# OPTIONS -v tc.with:100 #-}
open import Agda.Primitive
data _≡_ {a}{A : Set a} (x : A) : A → Set a where
refl : x ≡ x
{-# BUILTIN EQUALITY _≡_ #-}
postulate
equalLevel : (x y : Level) → x ≡ y
id : ∀ {a} {A : Set... |
algebraic-stack_agda0000_doc_3375 | module Thesis.SIRelBigStep.DSyntax where
open import Thesis.SIRelBigStep.Syntax public
-- data DType : Set where
-- _⇒_ : (σ τ : DType) → DType
-- int : DType
DType = Type
import Base.Syntax.Context
module DC = Base.Syntax.Context DType
Δτ : Type → DType
Δτ (σ ⇒ τ) = σ ⇒ Δτ σ ⇒ Δτ τ
Δτ (pair τ1 τ2) = pair (Δτ τ... |
algebraic-stack_agda0000_doc_10400 | module TakeDropDec where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; sym; trans; cong; cong₂; _≢_)
open import Data.Empty using (⊥; ⊥-elim)
open import Data.List using (List; []; _∷_)
open import Data.List.All using (All; []; _∷_)
open import Data.Bool using (Bool; true; false; T)
open... |
algebraic-stack_agda0000_doc_10401 | module PLRTree.Compound {A : Set} where
open import PLRTree {A}
data Compound : PLRTree → Set where
compound : {t : Tag}{x : A}{l r : PLRTree} → Compound (node t x l r)
|
algebraic-stack_agda0000_doc_10402 | module Class.Monoid where
open import Level
open import Data.List using (List; []; _∷_)
record Monoid {a} (M : Set a) : Set (suc a) where
infixl 6 _+_
field
mzero : M
_+_ : M -> M -> M
open Monoid {{...}} public
concat : ∀ {a} {M : Set a} {{_ : Monoid M}} -> List M -> M
concat [] = mzero
concat (x ∷ l) ... |
algebraic-stack_agda0000_doc_10403 |
module Oscar.Data.Nat where
open import Agda.Builtin.Nat public using (Nat; zero; suc)
|
algebraic-stack_agda0000_doc_10404 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Category.Slice.Properties {o ℓ e} (C : Category o ℓ e) where
open import Categories.Category.Equivalence using (StrongEquivalence)
open import Categories.Functor
open import Categories.Object.Product
open import Categories.Diagram.P... |
algebraic-stack_agda0000_doc_10405 | module Generic.Lib.Prelude where
open import Generic.Lib.Intro public
open import Generic.Lib.Equality.Propositional public
open import Generic.Lib.Equality.Coerce public
open import Generic.Lib.Equality.Heteroindexed public
open import Generic.Lib.Equality.Congn public
open import Gene... |
algebraic-stack_agda0000_doc_10406 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of the pointwise lifting of a predicate to a binary tree
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Tree.Binary.Relation.U... |
algebraic-stack_agda0000_doc_10407 | {-# OPTIONS --guarded #-}
module _ where
primitive
primLockUniv : _
postulate
A B : primLockUniv
c : A → B
foo : (@tick x y : B) → Set
bar : (@tick x y : A) → Set
bar x y = foo (c x) (c y)
|
algebraic-stack_agda0000_doc_10408 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Core definition of divisibility
------------------------------------------------------------------------
-- The definition of divisibility is split out from
-- `Data.Nat.Divisibility` to avoid a dependency cycle... |
algebraic-stack_agda0000_doc_10409 | {-# OPTIONS --without-K --safe #-}
-- We do not parameterize this module since we do not have access to _+_ or _*_
-- for the fields that we want (real numbers)
open import Level using (Level)
open import Relation.Binary.PropositionalEquality hiding (Extensionality)
open ≡-Reasoning
open import Data.Nat using (ℕ) re... |
algebraic-stack_agda0000_doc_10410 | -- Occurs when different mixfix patterns use similar names.
module Issue147b where
data X : Set where
f : X -> X
f_ : X -> X
x : X
bad : X -> X
bad (f x) = x
bad _ = x
|
algebraic-stack_agda0000_doc_10411 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Bisimilarity for M-types
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --sized-types #-}
module Codata.M.Bisimilarity where
open import Level
open impo... |
algebraic-stack_agda0000_doc_10412 | ------------------------------------------------------------------------
-- Least upper bounds
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
module Delay-monad.Least-upper-bound where
open import Equality.Propositional
open import Prelude hiding (_⊔_)
open imp... |
algebraic-stack_agda0000_doc_10413 | module Normalize where
open import Data.List
open import Data.Product
open import PiLevel0
-- We are going to use all the coherence as follows; make the right
-- hand side canonical and rewrite the left hand side to the right
-- hand side. Brute force below cannot work!
-- Use the same structure as
-- https://agda... |
algebraic-stack_agda0000_doc_10414 |
module Prelude.Maybe where
open import Prelude.Unit
open import Prelude.Empty
open import Prelude.Function
open import Prelude.Functor
open import Prelude.Applicative
open import Prelude.Monad
open import Prelude.Equality
open import Prelude.Decidable
data Maybe {a} (A : Set a) : Set a where
nothing : Maybe A
ju... |
algebraic-stack_agda0000_doc_10415 | {-# OPTIONS --without-K --safe #-}
module Categories.Functor.Properties where
-- Properties valid of all Functors
open import Level
open import Data.Product using (proj₁; proj₂; _,_)
open import Function.Surjection using (Surjective)
open import Function.Equivalence using (Equivalence)
open import Function.Equality hi... |
algebraic-stack_agda0000_doc_7872 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.Vec.Relation.Binary.Equality.DecPropositional directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
... |
algebraic-stack_agda0000_doc_7873 | -- Andreas, 2016-05-19, issue 1986, after report from Nisse
-- Andreas, 2016-06-02 fixed
-- This has been reported before as issue 842
-- {-# OPTIONS -v tc.cover:20 #-}
-- {-# OPTIONS -v tc.cc:20 -v reduce.compiled:100 #-}
open import Common.Equality
data Bool : Set where
true false : Bool
not : Bool → Bool
not t... |
algebraic-stack_agda0000_doc_7874 | module Cats.Category.Constructions.Unique where
open import Data.Unit using (⊤)
open import Level
open import Cats.Category.Base
open import Cats.Util.Conv
module Build {lo la l≈} (Cat : Category lo la l≈) where
open Category Cat
IsUniqueSuchThat : ∀ {lp A B} → (A ⇒ B → Set lp) → A ⇒ B → Set (la ⊔ l≈ ⊔ lp)
... |
algebraic-stack_agda0000_doc_7875 |
module Oscar.Category.Functor where
open import Oscar.Category.Setoid
open import Oscar.Category.Category
open import Oscar.Category.Semifunctor
open import Oscar.Level
record Categories 𝔬₁ 𝔪₁ 𝔮₁ 𝔬₂ 𝔪₂ 𝔮₂ : Set (lsuc (𝔬₁ ⊔ 𝔪₁ ⊔ 𝔮₁ ⊔ 𝔬₂ ⊔ 𝔪₂ ⊔ 𝔮₂)) where
constructor _,_
field
category₁ : Category ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.