id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_8505 | {-# OPTIONS --with-K #-}
open import Axiom.Extensionality.Propositional using (Extensionality)
open import Relation.Nullary.Negation using (contradiction)
open import Relation.Binary using (Irrelevant)
open import Relation.Binary.PropositionalEquality using (_≡_; _≢_)
open import Relation.Binary.PropositionalEquality.W... |
algebraic-stack_agda0000_doc_8506 | module _ where
module A where
postulate
!_ : Set₂ → Set₃
infix 1 !_
module B where
postulate
!_ : Set₀ → Set₁
infix 3 !_
open A
open B
postulate
#_ : Set₁ → Set₂
infix 2 #_
ok₁ : Set₁ → Set₃
ok₁ X = ! # X
ok₂ : Set₀ → Set₂
... |
algebraic-stack_agda0000_doc_8507 | module foldl where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; sym; trans; cong)
open Eq.≡-Reasoning
open import lists using (List; []; _∷_; [_,_,_])
foldl : ∀ {A B : Set} → (B → A → B) → B → List A → B
foldl _⊗_ e [] = e
foldl _⊗_ e (x ∷ xs) = foldl _⊗_ (e ⊗ x) xs
test-foldl ... |
algebraic-stack_agda0000_doc_8508 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- The extensional sublist relation over setoid equality.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
module Data.List.R... |
algebraic-stack_agda0000_doc_8509 | open import MJ.Types
import MJ.Classtable.Core as Core
import MJ.Classtable.Code as Code
import MJ.Syntax as Syntax
module MJ.Semantics.Objects.Flat {c}(Ct : Core.Classtable c)(ℂ : Code.Code Ct) where
open import Prelude
open import Level renaming (suc to lsuc; zero to lzero)
open import Data.Vec hiding (_++_; looku... |
algebraic-stack_agda0000_doc_8510 | -- Andreas, 2020-05-01, issue #4631
--
-- We should not allow @-patterns to shadow constructors!
open import Agda.Builtin.Bool
test : Set → Set
test true@_ = true
-- WAS: succees
-- EXPECTED:
--
-- Bool !=< Set
-- when checking that the expression true has type Set
--
-- ———— Warning(s) ————————————————————————————... |
algebraic-stack_agda0000_doc_8511 | ------------------------------------------------------------------------------
-- Propositional equality on inductive PA
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymor... |
algebraic-stack_agda0000_doc_8503 | {-# OPTIONS --without-K --safe --no-universe-polymorphism
--no-sized-types --no-guardedness --no-subtyping #-}
module Agda.Builtin.Unit where
record ⊤ : Set where
instance constructor tt
{-# BUILTIN UNIT ⊤ #-}
{-# COMPILE GHC ⊤ = data () (()) #-}
|
algebraic-stack_agda0000_doc_16448 | {-# OPTIONS --sized-types #-}
module Rose where
postulate
Size : Set
_^ : Size -> Size
∞ : Size
{-# BUILTIN SIZE Size #-}
{-# BUILTIN SIZESUC _^ #-}
{-# BUILTIN SIZEINF ∞ #-}
data List (A : Set) : {_ : Size} -> Set where
[] : {size : Size} -> List A {size ^}
_::_ : {size : Size} -> A -> List A {s... |
algebraic-stack_agda0000_doc_16449 | module Terms where
open import Library
-- * Variables
------------------------------------------------------------------------
data Ty : Set where
base : Ty
_→̂_ : (a b : Ty) → Ty
-- Typing contexts.
Cxt = List Ty
-- Variables.
data Var : (Γ : Cxt) (a : Ty) → Set where
zero : ∀{Γ a} → Var (... |
algebraic-stack_agda0000_doc_16450 | {-# BUILTIN CUBEINTERVALUNIV IUniv #-}
|
algebraic-stack_agda0000_doc_16451 | {-# OPTIONS --cubical --safe #-}
-- | Quotient integer
module QuoInt where
open import Cubical.Core.Everything
open import Cubical.HITs.Ints.QuoInt renaming (_+ℤ_ to _+_; ℤ to Z)
open import Cubical.Data.Nat hiding (_+_)
open import Cubical.Foundations.Prelude
+-i-zero : ∀ a i → posneg i + a ≡ a
+-i-zero a i =
co... |
algebraic-stack_agda0000_doc_16452 | module Categories.Monoidal.CartesianClosed where
|
algebraic-stack_agda0000_doc_16453 | {-# OPTIONS --safe #-}
module Cubical.Algebra.Monoid.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
op... |
algebraic-stack_agda0000_doc_16454 | module Numeral.Matrix where
import Lvl
open import Syntax.Number
open import Data
open import Data.Boolean
open import Data.Tuple as Tuple using (_⨯_ ; _,_)
open import Functional using (const)
open import Numeral.Finite
open import Numeral.Finite.Bound
open import Numeral.Finite.Oper
open import Numeral.Finite.O... |
algebraic-stack_agda0000_doc_16455 | module Data.Fin.Properties.Extra where
open import Data.Nat
renaming (suc to S; zero to Z; _+_ to _ℕ+_; _*_ to _ℕ*_)
open ≤-Reasoning renaming (begin_ to start_; _∎ to _□; _≡⟨_⟩_ to _≈⟨_⟩_)
open import Data.Nat.Properties
open import Data.Nat.Properties.Extra renaming (cancel-suc to S-injective)
open import Data.N... |
algebraic-stack_agda0000_doc_16456 | -- Martin-Löf identity type without the K axiom
-- (we do not assume uniqueness of identity proofs).
{-# OPTIONS --without-K --safe #-}
module Tools.PropositionalEquality where
-- We reexport Agda's builtin equality type.
open import Tools.Empty public
import Relation.Binary.PropositionalEquality as Eq
open Eq usin... |
algebraic-stack_agda0000_doc_16457 | {-# OPTIONS --without-K #-}
module sets.fin where
open import sets.fin.core public
open import sets.fin.properties public
open import sets.fin.ordering public
open import sets.fin.universe public
|
algebraic-stack_agda0000_doc_16458 | {-# OPTIONS --without-K #-}
open import Base
open import Homotopy.TruncatedHIT
{-
The idea is that if [n : ℕ] and [A : Set i], then [τ n A] is defined by the
following n-truncated higher inductive type:
module Homotopy.TruncationHIT {i} (n : ℕ) (A : Set i) where
(n)data τ : Set i where
proj : A → τ
M... |
algebraic-stack_agda0000_doc_16459 | -- Andreas, 2016-07-17
record R : Set₁ where
abstract
field T : Set
-- Expected error:
--
-- Using abstract here has no effect. Abstract applies only
-- definitions like data definitions, record type definitions and
-- function clauses.
|
algebraic-stack_agda0000_doc_16460 |
module Prelude.Unit where
open import Agda.Builtin.Unit public
record ⊤′ {a} : Set a where
instance constructor tt
-- To keep changes from compat-2.4.0 to a minimum.
Unit = ⊤
pattern unit = tt
|
algebraic-stack_agda0000_doc_16461 | {-# OPTIONS --without-K --safe #-}
module Categories.Kan where
-- Left and Right Kan extensions (known as Lan and Ran)
open import Level
open import Categories.Category using (Category)
open import Categories.Functor
open import Categories.NaturalTransformation using (NaturalTransformation; _∘ʳ_; _∘ᵥ_)
open import Ca... |
algebraic-stack_agda0000_doc_16463 | {-# OPTIONS --prop --type-in-type #-}
record × (A B : Prop) : Prop where
field
fst : A
snd : B
|
algebraic-stack_agda0000_doc_16462 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Category.Complete.Finitely
module Categories.Category.Complete.Finitely.Properties {o ℓ e} {C : Category o ℓ e} (finite : FinitelyComplete C) where
open import Level using (Level)
open import Data.Nat using (ℕ)
open import Data... |
algebraic-stack_agda0000_doc_16768 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- A type for expressions over a raw ring.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Tactic.RingSolver.Core.Expression where
open import Da... |
algebraic-stack_agda0000_doc_16769 | {-# OPTIONS --cubical #-}
module Exercises where
open import Part2
open import Part3
open import Part4
open import Part5
|
algebraic-stack_agda0000_doc_16770 | -- Some basic structures and operations for dealing
-- with non-deterministic values.
--
-- @author Sergio Antoy, Michael Hanus, Steven Libby
module nondet where
open import bool
open import nat
open import list
infixr 8 _??_
----------------------------------------------------------------------
-- A tree datatype ... |
algebraic-stack_agda0000_doc_16771 | open import Agda.Builtin.Equality
module _ (A : Set) where
data Wrap (X : Set) : Set where
wrap : X → Wrap X
data D (x : A) : ∀ y → Wrap (x ≡ y) → Set where
c : ∀ y (x≡y : x ≡ y) → D x y (wrap x≡y)
test : ∀ x y (x≡y x≡y' : Wrap (x ≡ y)) → D x y x≡y → D x y x≡y' → Set
test y .y (wrap refl) .(wrap refl) (c .y .re... |
algebraic-stack_agda0000_doc_16772 | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Environments
--
-- This module defines the meaning of contexts, that is,
-- the type of environments that fit a context, together
-- with operations and properties of these operations.
--
-- This module is parametri... |
algebraic-stack_agda0000_doc_16773 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Comonads
------------------------------------------------------------------------
-- Note that currently the monad laws are not included here.
{-# OPTIONS --without-K --safe #-}
module Category.Comonad where
... |
algebraic-stack_agda0000_doc_16774 | ------------------------------------------------------------------------
-- Alternative definitions of weak bisimilarity
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
open import Prelude
module Delay-monad.Bisimilarity.Alternative {a} {A : Type a} where
open ... |
algebraic-stack_agda0000_doc_16775 | open import prelude
-- Copied pretty much verbatim
data Term : Set where
true : Term
false : Term
if_then_else_end : Term → Term → Term → Term
data Value : Term → Set where
true : Value true
false : Value false
data _⟶_ : Term → Term → Set where
E─IfTrue : ∀ {t₂ t₃} →
----------------------------... |
algebraic-stack_agda0000_doc_16776 | {-# OPTIONS --safe #-}
module Cubical.Algebra.Polynomials.Multivariate.Base where
open import Cubical.Algebra.CommRing.Instances.Polynomials.MultivariatePoly public
{-
The Multivariate Polynomials of size n over a CommRing A is a CommRing.
This version is define as an instance of the more general constructions of gr... |
algebraic-stack_agda0000_doc_16777 | {-# OPTIONS --without-K #-}
open import HoTT
open import cohomology.Exactness
open import cohomology.Theory
module cohomology.Sn {i} (OT : OrdinaryTheory i) where
open OrdinaryTheory OT
C-Sphere-≠ : (n : ℤ) (m : ℕ) → (n ≠ ℕ-to-ℤ m)
→ C n (⊙Lift (⊙Sphere m)) == Lift-Unit-group
C-Sphere-≠ n O neq = C-dimension n ne... |
algebraic-stack_agda0000_doc_16778 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Vectors
------------------------------------------------------------------------
module Data.Vec where
open import Category.Applicative
open import Data.Nat
open import Data.Fin using (Fin; zero; suc)
open impo... |
algebraic-stack_agda0000_doc_16779 | module Data.Union.Relation.Binary.Subtype where
open import Data.List using (List)
open import Data.List.Relation.Unary.Any using (here; there)
open import Data.List.Relation.Binary.Subset.Propositional using (_⊆_)
open import Data.Union using (Union; here; there; inj)
open import Function using (_∘_; id)
open impo... |
algebraic-stack_agda0000_doc_16780 | {-# OPTIONS --without-K --rewriting #-}
module lib.types.Suspension.Trunc where
open import lib.Basics
open import lib.NType2
open import lib.types.Paths
open import lib.types.Pointed
open import lib.types.Truncation
open import lib.types.Suspension.Core
module _ {i} (A : Type i) (m : ℕ₋₂) where
module SuspTrunc... |
algebraic-stack_agda0000_doc_16781 | {-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Weakening {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.LogicalRelation
open import Defini... |
algebraic-stack_agda0000_doc_16782 | {-# OPTIONS --without-K #-}
open import HoTT
{- Move (parts of) faces of a cube around -}
module lib.cubical.elims.CubeMove where
square-push-rb : ∀ {i} {A : Type i} {a₀₀ a₀₁ a₁₀ a₁₁ b : A}
{p₀₋ : a₀₀ == a₀₁} {p₋₀ : a₀₀ == a₁₀}
{p₋₁ : a₀₁ == a₁₁} (p₁₋ : a₁₀ == b) (q : b == a₁₁)
→ Square p₀₋ p₋₀ p₋₁ (p₁₋ ∙ q)
... |
algebraic-stack_agda0000_doc_16783 | -- test termination using structured orders
module TerminationTupledAckermann where
data Nat : Set where
zero : Nat
succ : Nat -> Nat
data _×_ (A B : Set) : Set where
_,_ : A -> B -> A × B
-- addition in tupled form
add : Nat × Nat -> Nat
add (zero , m) = m
add (succ n , m) = succ (add (n , m))
-- a... |
algebraic-stack_agda0000_doc_5648 | module sn-calculus-confluence.helper where
open import Data.List.All
open import Function
using (_∘_)
open import Data.List.Any using (Any ; here ; there)
open import Data.Nat using (_+_)
open import utility
open import Esterel.Lang
open import Esterel.Lang.Properties
open import Esterel.Environment as Env
open impo... |
algebraic-stack_agda0000_doc_5649 |
module Fail.TupleType where
open import Haskell.Prelude
idT : ∀ {as} → Tuple as → Tuple as
idT x = x
{-# COMPILE AGDA2HS idT #-}
|
algebraic-stack_agda0000_doc_5650 | {-# OPTIONS --without-K --safe #-}
module Categories.Adjoint.Equivalents where
-- Theorems about equivalent formulations to Adjoint
-- (though some have caveats)
open import Level
open import Data.Product using (_,_; _×_)
open import Function using (_$_) renaming (_∘_ to _∙_)
open import Function.Equality using (Π; ... |
algebraic-stack_agda0000_doc_5651 | {-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Groups.DirectSum.Definition
open import Setoids.Setoids
open import Rings.Definition
module Rings.DirectSum {a b c d : _} {A : Set a} {S : Setoid {a} {b} A} {_+1_ : A → A → A} {_*1_ : A → A → A} {C : Set c} {T : Setoid {c} {d}... |
algebraic-stack_agda0000_doc_5652 | {-# OPTIONS --without-K #-}
open import Prelude
import GSeTT.Typed-Syntax
import Globular-TT.Syntax
import Globular-TT.Rules
module Globular-TT.Globular-TT {l} (index : Set l) (rule : index → GSeTT.Typed-Syntax.Ctx × (Globular-TT.Syntax.Pre-Ty index))
(assumption : G... |
algebraic-stack_agda0000_doc_5653 | -- {-# OPTIONS -v interaction:50 #-}
x : Set → Set
x = {!λ x → x!}
-- "refine" (C-c C-r) should behave the same as "give" here
-- Old, bad result:
-- x = λ x₁ → x₁
-- New, expected result:
-- x = λ x → x
-- Expected interaction test case behavior:
--
-- (agda2-give-action 0 'no-paren)
|
algebraic-stack_agda0000_doc_5654 | module Luau.Type where
data Type : Set where
nil : Type
_⇒_ : Type → Type → Type
none : Type
any : Type
_∪_ : Type → Type → Type
_∩_ : Type → Type → Type
|
algebraic-stack_agda0000_doc_5655 | ------------------------------------------------------------------------------
-- FOCT list terms properties
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-... |
algebraic-stack_agda0000_doc_5656 | module 030-semigroup where
-- We need equivalence.
open import 020-equivalence
-- Semigroups are basically a set with equality and some binary
-- operator which is associative and respects equality.
record SemiGroup
{M : Set}
(_==_ : M -> M -> Set)
(_*_ : M -> M -> M)
: Set1 where
field
equiv : Equiv... |
algebraic-stack_agda0000_doc_5657 | {-# OPTIONS --sized-types #-}
open import Relation.Binary.Core
module SOList.Total.Properties {A : Set}
(_≤_ : A → A → Set)
(trans≤ : Transitive _≤_) where
open import Bound.Total A
open import Bound.Total.Order _≤_
open import Bound.Total.Order.Properties _≤_ trans≤
open import List... |
algebraic-stack_agda0000_doc_5658 | module test.AddInteger where
open import Type
open import Declarative
open import Builtin
open import Builtin.Constant.Type
open import Builtin.Constant.Term Ctx⋆ Kind * # _⊢⋆_ con size⋆
open import Agda.Builtin.Sigma
-- zerepoch/zerepoch-core/test/data/addInteger.plc
addI : ∀{Γ} →
Γ ⊢ con integer (size⋆ 8) ⇒ con ... |
algebraic-stack_agda0000_doc_5659 | -- {-# OPTIONS -v tc.proj.like:10 #-} {-# OPTIONS -v tc.conv:10 #-}
import Common.Level
module ProjectionLikeAndModules1 (A : Set) (a : A) where
record ⊤ : Set where
constructor tt
data Wrap (W : Set) : Set where
wrap : W → Wrap W
data Bool : Set where
true false : Bool
-- `or' should be projection like in t... |
algebraic-stack_agda0000_doc_5660 |
open import Everything
module Test.SurjidentityP where
module _
{𝔬₁} {𝔒₁ : Ø 𝔬₁}
{𝔯₁} (_∼₁_ : 𝔒₁ → 𝔒₁ → Ø 𝔯₁)
{𝔬₂} {𝔒₂ : Ø 𝔬₂}
{𝔯₂} (_∼₂_ : 𝔒₂ → 𝔒₂ → Ø 𝔯₂)
(_∼₂2_ : 𝔒₂ → 𝔒₂ → Ø 𝔯₂)
{𝔯₂'} (_∼₂'_ : 𝔒₂ → 𝔒₂ → Ø 𝔯₂')
{ℓ₂} (_∼̇₂_ : ∀ {x y} → x ∼₂ y → x ∼₂ y → Ø ℓ₂)
... |
algebraic-stack_agda0000_doc_5661 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Definitions where
open import Cubical.Core.Everything
open import Cubical.Relation.Binary
open import Cubical.Data.Sigma using (_×_)
open import Cubical.Data.Sum using (_⊎_)
open import Cubical.HITs.PropositionalTruncation using (∥_∥)
open impo... |
algebraic-stack_agda0000_doc_5662 | {-# OPTIONS --rewriting #-}
module Luau.Heap where
open import Agda.Builtin.Equality using (_≡_; refl)
open import FFI.Data.Maybe using (Maybe; just; nothing)
open import FFI.Data.Vector using (Vector; length; snoc; empty; lookup-snoc-not)
open import Luau.Addr using (Addr; _≡ᴬ_)
open import Luau.Var using (Var)
open... |
algebraic-stack_agda0000_doc_5663 | {-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Paths
open import lib.types.Pi
open import lib.types.Unit
open import lib.types.Nat
open import lib.types.TLevel
open import lib.types.Pointed
open import lib.types.Sigma
open import lib.NType2
open import lib.types.PathSeq
open import nicolai.p... |
algebraic-stack_agda0000_doc_5760 | {-# OPTIONS --without-K --rewriting #-}
module Basics where
open import Base public
open import PropT public
open import hSet public
open import lib.Basics public
|
algebraic-stack_agda0000_doc_5762 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Finite sets
------------------------------------------------------------------------
-- Note that elements of Fin n can be seen as natural numbers in the
-- set {m | m < n}. The notation "m" in comments below re... |
algebraic-stack_agda0000_doc_5763 | {-# OPTIONS --allow-unsolved-metas #-}
postulate
A : Set
data Unit : Set where
unit : Unit
F : Unit → Set
F unit = A
postulate
P : {A : Set} → A → Set
Q : ∀ {x} → F x → Set
f : ∀ {x} {y : F x} (z : Q y) → P z
variable
x : Unit
y : F x
g : (z : Q y) → P z
g z with f z
... | p = p
|
algebraic-stack_agda0000_doc_5764 | {-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Categories.Instances.EilenbergMoore where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism renaming (Iso to _≅_)
open import Cubical... |
algebraic-stack_agda0000_doc_5765 |
module _ where
open import Issue1839.A
open import Issue1839.B
X : DontPrintThis -- should display as PrintThis
X = {!!}
|
algebraic-stack_agda0000_doc_5766 | ------------------------------------------------------------------------
-- Some code suggesting that types used in "programs" might not
-- necessarily be sets
------------------------------------------------------------------------
-- If lenses are only used in programs, and types used in programs are
-- always sets,... |
algebraic-stack_agda0000_doc_5767 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Examples showing how the generic n-ary operations the stdlib provides
-- can be used
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module README.Nar... |
algebraic-stack_agda0000_doc_5768 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category using (Category)
-- A "canonical" presentation of cartesian closed categories.
--
-- This presentation is equivalent to the one in
-- Categories.Category.CartesianClosed but it is easier to work with
-- in some circumstances.
--
-- Here, exponentials a... |
algebraic-stack_agda0000_doc_5769 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Data.Empty.Base where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
private
variable
ℓ : Level
data ⊥ : Type₀ where
⊥* : Type ℓ
⊥* = Lift ⊥
rec : {A : Type ℓ} → ⊥ → A
rec ()
elim : {A : ⊥ → Type ℓ} → (x : ⊥) → A ... |
algebraic-stack_agda0000_doc_5770 | ------------------------------------------------------------------------
-- A memoising backend for RecursiveDescent.Hybrid
------------------------------------------------------------------------
-- Following Frost/Szydlowski and Frost/Hafiz/Callaghan (but without
-- the left recursion fix). An improvement has been m... |
algebraic-stack_agda0000_doc_5771 |
module Data.Rational where
import Data.Bool as Bool
import Data.Nat as Nat
import Data.Integer as Int
open Int renaming
( _*_ to _*'_
; _+_ to _+'_
; -_ to -'_
; _-_ to _-'_
; !_! to !_!'
; _==_ to _=='_
; _≤_ to _≤'_
... |
algebraic-stack_agda0000_doc_5772 | {-
This second-order signature was created from the following second-order syntax description:
syntax Empty | E
type
𝟘 : 0-ary
term
abort : 𝟘 -> α
theory
(𝟘η) e : 𝟘 c : α |> abort(e) = c
-}
module Empty.Signature where
open import SOAS.Context
-- Type declaration
data ET : Set where
𝟘 : ET
ope... |
algebraic-stack_agda0000_doc_5773 | module Issue1245 where
postulate
A B : Set
[_] : A -> B
module M (_ : B) where
module N (a : A) = M [ a ]
|
algebraic-stack_agda0000_doc_5774 | -- This file is the source Agda file
-- Edit this file not Type.hs
-- The warning below will be written to Type.hs
module PlutusCore.Generators.NEAT.Type where
-- warning to be written to Haskell file:
{-# FOREIGN AGDA2HS
{-
!!! THIS FILE IS GENERATED FROM Type.agda
!!! DO NOT EDIT THIS FILE. EDIT Type.agda
!!! AND T... |
algebraic-stack_agda0000_doc_5775 |
module Fail.MultiArgumentPatternLambda where
open import Agda.Builtin.Bool
tooManyPats : Bool → Bool → Bool
tooManyPats = λ where false false → false
true true → false
_ _ → true
{-# COMPILE AGDA2HS tooManyPats #-}
|
algebraic-stack_agda0000_doc_5761 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category.Monoidal.Structure
using (SymmetricMonoidalCategory)
module Categories.Functor.Monoidal.Symmetric {o o′ ℓ ℓ′ e e′}
(C : SymmetricMonoidalCategory o ℓ e) (D : SymmetricMonoidalCategory o′ ℓ′ e′)
where
open import Level
open import Data.Product u... |
algebraic-stack_agda0000_doc_8608 | module L.Base.Nat where
-- Reexport definitions
open import L.Base.Nat.Core public
-- Functions on Nats
pred : Nat → Nat
pred = ind (λ _ → Nat) zero (λ x _ → x)
infixl 6 _+_
infixl 7 _*_
_+_ : Nat → Nat → Nat
zero + y = y
succ x + y = succ (x + y)
{-# BUILTIN NATPLUS _+_ #-}
_*_ : Nat → Nat → Nat
zero * y = z... |
algebraic-stack_agda0000_doc_8609 | {-# OPTIONS --without-K #-}
module sets.nat.solver where
open import decidable
open import equality
open import function.core
hiding (const)
open import sets.nat.core
open import sets.nat.properties
open import sets.nat.ordering
open import sets.fin.core
hiding (_≟_)
open import sets.vec.core
open import sets.vec... |
algebraic-stack_agda0000_doc_8610 | {-
This module defines the basic opens of the Zariski lattice and proves that they're a basis of the lattice.
It also contains the construction of the structure presheaf and a proof of the sheaf property on basic opens,
using the theory developed in the module PreSheafFromUniversalProp and its toSheaf.lemma.
... |
algebraic-stack_agda0000_doc_8611 | {-# OPTIONS --erased-cubical #-}
open import Agda.Builtin.Cubical.Path
-- Higher constructors must be erased when --erased-cubical is used.
data ∥_∥ (A : Set) : Set where
∣_∣ : A → ∥ A ∥
trivial : (x y : ∥ A ∥) → x ≡ y
|
algebraic-stack_agda0000_doc_8612 | ------------------------------------------------------------------------
-- Lemmas related to application of substitutions
------------------------------------------------------------------------
-- The record below allows the application operation to be
-- "heterogeneous", applying substitutions containing one kind o... |
algebraic-stack_agda0000_doc_8614 | ------------------------------------------------------------------------
-- Excluded middle
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
module Excluded-middle
{e⁺} (eq : ∀ {a p} → Equality-with-J a p e⁺) where
open Derived-defini... |
algebraic-stack_agda0000_doc_8615 | ------------------------------------------------------------------------------
-- Lists examples
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --... |
algebraic-stack_agda0000_doc_8616 | {-# OPTIONS --cubical --no-import-sorts #-}
open import Cubical.Foundations.Everything renaming (_⁻¹ to _⁻¹ᵖ; assoc to ∙-assoc)
import Cubical.Algebra.Semigroup as Std
open import MorePropAlgebra.Bundles
module MorePropAlgebra.Properties.Semigroup {ℓ} (assumptions : Semigroup {ℓ}) where
open Semigroup assumptions re... |
algebraic-stack_agda0000_doc_8617 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Lexicographic ordering of lists
------------------------------------------------------------------------
-- The definition of lexicographic ordering used here is suitable if
-- the argument order is a (non-stric... |
algebraic-stack_agda0000_doc_8618 | ------------------------------------------------------------------------
-- Some definitions related to and properties of the Maybe type
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
module Maybe
{reflexive} (eq : ∀ {a p} → Equality... |
algebraic-stack_agda0000_doc_8619 | {-# OPTIONS --without-K --safe #-}
open import Level
module Categories.Category.Instance.SimplicialSet.Properties (o ℓ : Level) where
open import Function using (_$_)
open import Data.Empty.Polymorphic using (⊥; ⊥-elim)
open import Data.Nat using (ℕ)
open import Data.Fin using (Fin)
open import Data.Product using (... |
algebraic-stack_agda0000_doc_8620 | module PLRTree.Equality.Correctness {A : Set} where
open import BTree.Equality {A}
open import PLRTree {A}
open import PLRTree.Equality {A} renaming (_≃_ to _≃'_)
lemma-≃'-≃ : {l r : PLRTree} → l ≃' r → forget l ≃ forget r
lemma-≃'-≃ ≃lf = ≃lf
lemma-≃'-≃ (≃nd x x' l≃'r l'≃'r' l≃'l') = ≃nd x x' (lemma-≃'-≃ l≃'r) (lem... |
algebraic-stack_agda0000_doc_8621 | -- Andreas, 2019-07-15, issue #3901, requested by msuperdock
--
-- Allow function spaces {A} → B and {{A}} → B.
postulate
A B : Set
foo : {{A}} → B
bar : {A} → B
-- Original feature request:
open import Agda.Builtin.Unit using (⊤; tt)
data ⊥ : Set where
data Nat : Set where
zero : Nat
suc : Nat → Nat... |
algebraic-stack_agda0000_doc_8622 | -- Jesper, 2018-11-23: Unsolved metas are turned into postulates
-- when --allow-unsolved-metas is enabled, but there was no internal
-- representation of postulated sorts.
module Issue3256 where
open import Issue3256.B
-- WAS:
-- An internal error has occurred. Please report this as a bug.
-- Location of the error:... |
algebraic-stack_agda0000_doc_8623 | {-# OPTIONS --universe-polymorphism #-}
module Categories.Graphs where
open import Categories.Category
hiding (module Heterogeneous)
open import Data.Product
open import Level
open import Relation.Binary
renaming (_⇒_ to _⊆_)
open import Relation.Binary.PropositionalEquality
using ()
renaming (_≡_ to _≣_; refl... |
algebraic-stack_agda0000_doc_8613 |
module Abstract where
data Bool : Set where
true false : Bool
not : Bool → Bool
not true = false
not false = true
abstract
Answer : Set
Answer = Bool
yes : Answer
yes = true
no : Answer
no = false
contradict : Answer → Answer
contradict x = not x
counter-contradict : Answer → Answer
counter-c... |
algebraic-stack_agda0000_doc_16912 | module Common.Context where
open import Common public
-- Contexts.
data Cx (U : Set) : Set where
∅ : Cx U
_,_ : Cx U → U → Cx U
-- Vector contexts.
data VCx (U : Set) : ℕ → Set where
∅ : VCx U zero
_,_ : ∀ {n} → VCx U n → U → VCx U (suc n)
-- Inversion principles for contexts.
module _ {U : Set} w... |
algebraic-stack_agda0000_doc_16913 | {-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Groups.Definition
open import Rings.Definition
open import Rings.IntegralDomains.Definition
open import Setoids.Setoids
open import Sets.EquivalenceRelations
module Fields.FieldOfFractions.Ring {a b : _} {A : Set a} {S : Setoid... |
algebraic-stack_agda0000_doc_16914 |
module Oscar.Category.Semigroup where
open import Oscar.Category.Setoid
open import Oscar.Level
module _ {𝔬 𝔮} (setoid : Setoid 𝔬 𝔮) where
open Setoid setoid
record IsSemigroup (_∙_ : ⋆ → ⋆ → ⋆) : Set (𝔬 ⊔ 𝔮) where
field
extensionality : ∀ {f₁ f₂} → f₁ ≋ f₂ → ∀ {g₁ g₂} → g₁ ≋ g₂ → g₁ ∙ f₁ ≋ g₂ ∙... |
algebraic-stack_agda0000_doc_16915 | {-# OPTIONS --rewriting #-}
open import Luau.Type using (Type; Scalar; nil; number; string; boolean; never; unknown; _⇒_; _∪_; _∩_)
open import Properties.Equality using (_≢_)
module Luau.Subtyping where
-- An implementation of semantic subtyping
-- We think of types as languages of trees
data Tree : Set where
... |
algebraic-stack_agda0000_doc_16916 | {-# OPTIONS --cubical --guarded -W ignore #-}
module combinations-of-lift-and-list where
open import Clocked.Primitives
open import Cubical.Foundations.Prelude
open import Cubical.Data.List as List
open import Cubical.Data.List.Properties
open import Cubical.Data.Sum using (_⊎_; inl; inr)
--**************************... |
algebraic-stack_agda0000_doc_16917 | {-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Categories.Definition
module Categories.Functor.Definition where
record Functor {a b c d : _} (C : Category {a} {b}) (D : Category {c} {d}) : Set (a ⊔ b ⊔ c ⊔ d) where... |
algebraic-stack_agda0000_doc_16918 | module Stuck where
postulate
I : Set
i j : I
data D : I → I → Set where
d : D i i
e : D j j
f : ∀ {x} → D i x → Set₁
f d = Set
|
algebraic-stack_agda0000_doc_16919 |
module SetOmega where
postulate
IsType : ∀ {a} → Set a → Set
Bad : IsType (∀ a → Set a)
|
algebraic-stack_agda0000_doc_16920 |
open import Agda.Builtin.Bool
data Test : Set where
CTest : Bool -> {Bool} -> Test
{-# COMPILE AGDA2HS Test #-}
getTest : Test → Bool
getTest (CTest b) = b
{-# COMPILE AGDA2HS getTest #-}
putTest : Bool → Test → Test
putTest b (CTest _ {b'}) = CTest b {b'}
{-# COMPILE AGDA2HS putTest #-}
|
algebraic-stack_agda0000_doc_16921 | open import Relation.Binary.Core using (Rel)
module GGT.Definitions
{a b ℓ₁ ℓ₂}
{G : Set a} -- The underlying group carrier
{Ω : Set b} -- The underlying space
(_≈_ : Rel G ℓ₁) -- The underlying group equality
(_≋_ : Rel Ω ℓ₂) -- The underlying space equality
where
open import Level
open import ... |
algebraic-stack_agda0000_doc_16922 | module MJ.Examples.Exceptions where
open import Prelude
open import Data.Star
import Data.Vec.All as Vec∀
open import Data.List
open import Data.List.Any
open import Data.List.Membership.Propositional
open import Data.List.All hiding (lookup)
open import Data.Product hiding (Σ)
open import Relation.Binary.Propositiona... |
algebraic-stack_agda0000_doc_16923 | module STLC.Type.Relation where
open import Data.Nat using (ℕ)
open import Data.Fin using (Fin)
open import STLC.Term
open import STLC.Type
open import STLC.Type.Context using (Ctxt)
open import Data.Vec using (_∷_; lookup)
open import Relation.Nullary using (¬_)
open import Relation.Binary.PropositionalEquality ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.