id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_6048 | {-# OPTIONS --type-in-type #-}
record ⊤ : Set where
constructor tt
data ⊥ : Set where
data _==_ {A : Set} (x : A) : A → Set where
refl : x == x
module _ (A : Set) (B : A → Set) where
record Σ : Set where
constructor _,_
field
π₁ : A
π₂ : B π₁
open Σ public
syntax Σ A (λ x → B) = Σ[ x ∶... |
algebraic-stack_agda0000_doc_6049 |
module Agda.Builtin.Nat where
open import Agda.Builtin.Bool
data Nat : Set where
zero : Nat
suc : (n : Nat) → Nat
{-# BUILTIN NATURAL Nat #-}
infix 4 _==_ _<_
infixl 6 _+_ _-_
infixl 7 _*_
_+_ : Nat → Nat → Nat
zero + m = m
suc n + m = suc (n + m)
{-# BUILTIN NATPLUS _+_ #-}
_-_ : Nat → Nat → Nat
n -... |
algebraic-stack_agda0000_doc_6050 | {-# OPTIONS --safe #-}
module Definition.Conversion.Reduction where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Conversion
-- Weak head expansion of algorithmic equality of types.
reductionConv↑ : ∀ {A A′ B B′ r Γ}
→ Γ ⊢ A... |
algebraic-stack_agda0000_doc_6051 | open import Agda.Builtin.IO
open import Agda.Builtin.Size
open import Agda.Builtin.Unit
data D (i : Size) : Set where
{-# FOREIGN GHC
data Empty i
#-}
{-# COMPILE GHC D = data Empty () #-}
f : ∀ {i} → D i → D i
f ()
{-# COMPILE GHC f as f #-}
postulate
return : {A : Set} → A → IO A
{-# COMPILE GHC return =... |
algebraic-stack_agda0000_doc_6053 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category using (Category; module Commutation)
open import Categories.Category.Monoidal.Core using (Monoidal)
open import Categories.Category.Monoidal.Braided using (Braided)
-- Braided monoidal categories satisfy the "four middle interchange"
module Categorie... |
algebraic-stack_agda0000_doc_6054 | module Min where
open import Data.Nat using (ℕ; zero; suc)
open import Algebra.Bundles using (CommutativeRing)
open import Algebra.Module.Bundles using (Module)
open import Data.Product using (Σ-syntax; ∃-syntax; _×_; proj₁; proj₂; _,_)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Relation.Binary.Core usin... |
algebraic-stack_agda0000_doc_6055 | {-
This file contains:
- Properties of groupoid truncations
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.GroupoidTruncation.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Found... |
algebraic-stack_agda0000_doc_6056 | {-# OPTIONS --cubical --no-import-sorts --guardedness --safe #-}
module Cubical.Codata.M.AsLimit.Coalg where
open import Cubical.Codata.M.AsLimit.Coalg.Base public
|
algebraic-stack_agda0000_doc_6057 |
module Oscar.Property.Extensionality where
open import Oscar.Level
record Extensionality
{a} {A : Set a} {b} {B : A → Set b} {ℓ₁}
(_≤₁_ : (x : A) → B x → Set ℓ₁)
{c} {C : A → Set c} {d} {D : ∀ {x} → B x → Set d} {ℓ₂}
(_≤₂_ : ∀ {x} → C x → ∀ {y : B x} → D y → Set ℓ₂)
(μ₁ : (x : A) → C x)
(μ₂ : ∀ {... |
algebraic-stack_agda0000_doc_6058 | {-# OPTIONS --without-K #-}
open import Base
open import Homotopy.Truncation
open import Integers
-- Formalization of 0-truncated groups
module Algebra.Groups where
-- A pregroup is a group whose carrier is not a required to be a set (but
-- without higher coherences)
record pregroup i : Set (suc i) where
-- cons... |
algebraic-stack_agda0000_doc_6059 | {-
Definition of the integers as a HIT ported from the redtt library:
https://github.com/RedPRL/redtt/blob/master/library/cool/biinv-int.red
For the naive, but incorrect, way to define the integers as a HIT, see HITs.IsoInt
This file contains:
- definition of BiInvInt
- proof that Int ≡ BiInvInt
- [discreteBiInvI... |
algebraic-stack_agda0000_doc_6060 | module Numeral.Natural.Oper.Summation.Range.Proofs where
import Lvl
open import Data.List
open import Data.List.Functions
open Data.List.Functions.LongOper
open import Data.List.Proofs
open import Data.List.Equiv.Id
open import Data.List.Proofs.Length
open import Functional as Fn using (_$_ ; _∘_ ; const)
... |
algebraic-stack_agda0000_doc_6061 | module Section9 where
open import Section8 public
-- 9. A decision algorithm for terms
-- =================================
--
-- The reduction defined above can be used for deciding if two well-typed terms are convertible
-- with each other or not: reduce the terms and check if the results are equal. This algorith... |
algebraic-stack_agda0000_doc_6062 | -- Andreas, 2019-12-03, issue #4205, reported by Smaug123,
-- first shrinking by Jesper Cockx
record R : Set₂ where
field
f : Set₁
postulate
r : R
open R r
test : R
R.f test with Set₃
f test | _ = Set
-- WAS: internal error in getOriginalProjection
-- EXPECTED:
-- With clause pattern f is not an instance... |
algebraic-stack_agda0000_doc_6063 | module Ints.Add.Invert where
open import Ints
open import Ints.Properties
open import Ints.Add.Comm
open import Nats.Add.Invert
open import Data.Empty
open import Relation.Nullary
open import Equality
open import Function
------------------------------------------------------------------------
-- internal stuffs
p... |
algebraic-stack_agda0000_doc_6052 |
module Oscar.Class.Reflexive where
open import Oscar.Level
open import Oscar.Property.IsReflexive
record Reflexive {𝔬} (⋆ : Set 𝔬) ℓ : Set (𝔬 ⊔ lsuc ℓ) where
field
_≣_ : ⋆ → ⋆ → Set ℓ
isReflexive : IsReflexive ⋆ _≣_
open IsReflexive isReflexive public
|
algebraic-stack_agda0000_doc_16560 | module Pi.Examples where
open import Data.Empty
open import Data.Unit
open import Data.Sum
open import Data.Product
open import Relation.Binary.PropositionalEquality
open import Data.Nat
open import Data.Vec as V hiding (map)
open import Pi.Syntax
open import Pi.Opsem
open import Pi.Eval
pattern 𝔹 = 𝟙 +ᵤ 𝟙
pattern ... |
algebraic-stack_agda0000_doc_16561 | ------------------------------------------------------------------------
-- A correct implementation of tree sort
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
-- The algorithm and the treatment of ordering information is taken
-- from Conor McBride's talk... |
algebraic-stack_agda0000_doc_16562 | module Issue734a where
module M₁ (Z : Set₁) where
postulate
P : Set
Q : Set → Set
module M₂ (X Y : Set) where
module M₁′ = M₁ Set
open M₁′
p : P
p = {!!}
-- Previous and current agda2-goal-and-context:
-- Y : Set
-- X : Set
-- ---------
-- Goal: P
q : Q X
q = {!!}
-- Previous ... |
algebraic-stack_agda0000_doc_16563 | {-# OPTIONS --prop --rewriting #-}
module Examples.Gcd where
open import Examples.Gcd.Euclid public
open import Examples.Gcd.Clocked public
open import Examples.Gcd.Spec public
open import Examples.Gcd.Refine public
|
algebraic-stack_agda0000_doc_16564 | {-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.GradedRing.Instances.Polynomials where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Data.Unit
open import Cubical.Data.Nat using (ℕ)
open impo... |
algebraic-stack_agda0000_doc_16565 | module std-lib where
open import IO using (IO; run; putStrLn; _>>_)
open import Data.Unit using (⊤)
open import Codata.Musical.Notation using (♯_)
import Agda.Builtin.IO using (IO)
open import Function using (_$_)
main1 : Agda.Builtin.IO.IO ⊤
main1 = run (♯ putStrLn "hallo" >> ♯ putStrLn "welt")
main2 : Agda.Builtin... |
algebraic-stack_agda0000_doc_16566 | module Sessions.Syntax.Values where
open import Prelude hiding (both)
open import Relation.Unary
open import Data.Maybe
open import Data.List.Properties using (++-isMonoid)
import Data.List as List
open import Sessions.Syntax.Types
open import Sessions.Syntax.Expr
open import Relation.Ternary.Separation.Morphisms
d... |
algebraic-stack_agda0000_doc_16567 | -- Jesper, 2018-10-16: When solving constraints produces a term which
-- contains the same unsolved metavariable twice, only the first
-- occurrence should be turned into an interaction hole.
open import Agda.Builtin.Equality
postulate Id : (A : Set) → A → A → Set
allq : (∀ m n → Id _ m n) ≡ {!!}
allq = refl
|
algebraic-stack_agda0000_doc_16568 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Products
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Product where
open import Function
open import Level
open import Relation.Nullar... |
algebraic-stack_agda0000_doc_16569 | module New where
module _ where
open import Agda.Primitive
record IsBottom {ℓ-⊥} (⊥ : Set ℓ-⊥) ℓ-elim : Set (lsuc ℓ-elim ⊔ ℓ-⊥) where
field
⊥-elim : ⊥ → {A : Set ℓ-elim} → A
open IsBottom ⦃ … ⦄ public
record Bottom ℓ-⊥ ℓ-elim : Set (lsuc (ℓ-elim ⊔ ℓ-⊥)) where
field
⊥ : Set ℓ-⊥
ins... |
algebraic-stack_agda0000_doc_16570 | -- Andreas, 2022-06-10
-- A failed attempt to break Prop ≤ Set.
-- See https://github.com/agda/agda/issues/5761#issuecomment-1151336715
{-# OPTIONS --prop --cumulativity #-}
data ⊥ : Set where
record ⊤ : Set where
constructor tt
data Fool : Prop where
true false : Fool
Bool : Set
Bool = Fool
True : Bool → Se... |
algebraic-stack_agda0000_doc_16571 | {-# OPTIONS --without-K --safe #-}
-- | Exclusive option. Exactly one of the options holds at the same time.
module Dodo.Nullary.XOpt where
-- Stdlib imports
open import Level using (Level; _⊔_)
open import Data.Empty using (⊥; ⊥-elim)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Data.Product using (_×_;... |
algebraic-stack_agda0000_doc_16573 | ------------------------------------------------------------------------------
-- Property <→◁
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --wi... |
algebraic-stack_agda0000_doc_16574 | {-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.Group.EilenbergMacLane.GroupStructure where
open import Cubical.Algebra.Group.EilenbergMacLane.Base
open import Cubical.Algebra.Group.EilenbergMacLane.WedgeConnectivity
open import Cubical.Algebra.Group.Base
open import Cubical.Algebra.Gro... |
algebraic-stack_agda0000_doc_16575 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of functions, such as associativity and commutativity
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Level
open import Relatio... |
algebraic-stack_agda0000_doc_16572 | module Issue2486.Haskell where
{-# FOREIGN GHC
data MyList a = Nil | Cons a (MyList a)
#-}
|
algebraic-stack_agda0000_doc_8752 | module VecAppend where
open import Prelude
add : Nat -> Nat -> Nat
add zero y = y
add (suc x) y = suc (add x y)
append : forall {A m n} -> Vec A m -> Vec A n -> Vec A (add m n)
append xs ys = {!!}
|
algebraic-stack_agda0000_doc_8753 | {-# OPTIONS --without-K --overlapping-instances #-}
open import lib.Basics
open import lib.types.Coproduct
open import lib.types.Truncation
open import lib.types.Sigma
open import lib.types.Empty
open import lib.types.Bool
open import lib.NConnected
open import lib.NType2
module Util.Misc where
transp-↓' : ∀ {k j} {... |
algebraic-stack_agda0000_doc_8754 | ------------------------------------------------------------------------
-- An alternative but equivalent definition of the partiality monad
-- (but only for sets), based on the lifting construction in Lifting
------------------------------------------------------------------------
-- The code in this module is based ... |
algebraic-stack_agda0000_doc_8755 | module container.w where
open import container.w.core public
open import container.w.algebra public
open import container.w.fibration public
|
algebraic-stack_agda0000_doc_8756 | module Preduploid where
open import Relation.Unary using (Pred)
open import Relation.Binary using (REL)
open import Relation.Binary.PropositionalEquality using (_≡_; refl; sym)
open import Level
data Polarity : Set where
+ : Polarity
⊝ : Polarity
private
variable p q r s : Polarity
record Preduploid o ℓ : Se... |
algebraic-stack_agda0000_doc_8757 | {-# OPTIONS --safe #-}
module Cubical.Algebra.Field.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.SIP
open import Cub... |
algebraic-stack_agda0000_doc_8758 | module Data.Vec.Any {a} {A : Set a} where
open import Level using (_⊔_)
open import Relation.Nullary
open import Data.Fin
open import Data.Nat as ℕ hiding (_⊔_)
open import Data.Vec as Vec using (Vec; _∷_; [])
open import Relation.Unary renaming (_⊆_ to _⋐_) using (Decidable)
open import Function.Inverse ... |
algebraic-stack_agda0000_doc_8759 | ------------------------------------------------------------------------
-- Well-typed substitutions
------------------------------------------------------------------------
module Data.Fin.Substitution.Typed where
open import Data.Fin using (Fin; zero; suc)
open import Data.Fin.Substitution
open import Data.Fin.Subs... |
algebraic-stack_agda0000_doc_8760 | {-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.Idlemmas {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Type... |
algebraic-stack_agda0000_doc_8761 | module Numeral.Natural where
import Lvl
open import Type
-- The set of natural numbers (0,..).
-- Positive integers including zero.
data ℕ : Type{Lvl.𝟎} where
𝟎 : ℕ -- Zero
𝐒 : ℕ → ℕ -- Successor function (Intuitively: 𝐒(n) = n+1)
{-# BUILTIN NATURAL ℕ #-}
pattern 𝟏 = ℕ.𝐒(𝟎)
{-# DISPLAY ℕ.𝐒(𝟎)... |
algebraic-stack_agda0000_doc_8762 | ------------------------------------------------------------------------
-- Abstract typing contexts
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module Data.Context where
open import Data.Fin using (Fin)
open import Data.Fin.Substitution
open import Dat... |
algebraic-stack_agda0000_doc_8763 | {-# OPTIONS --prop --without-K --rewriting #-}
module Data.Nat.PredExp2 where
open import Data.Nat
open import Data.Nat.Properties
open import Relation.Nullary
open import Relation.Nullary.Negation
open import Relation.Binary
open import Relation.Binary.PropositionalEquality as Eq using (_≡_; refl; _≢_; module ≡-Rea... |
algebraic-stack_agda0000_doc_8764 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Some properties of reflexive closures which rely on the K rule
------------------------------------------------------------------------
{-# OPTIONS --safe --with-K #-}
module Relation.Binary.Construct.Closure.R... |
algebraic-stack_agda0000_doc_8765 | module Setoids where
open import Eq
open import Prelude
record Setoid : Set1 where
field
carrier : Set
_≈_ : carrier -> carrier -> Set
equiv : Equiv _≈_
record Datoid : Set1 where
field
setoid : Setoid
_≟_ : forall x y -> Dec (Setoid._≈_ setoid x y)
Setoid-≡ : Set -> Setoid
Setoid-≡... |
algebraic-stack_agda0000_doc_8766 | head : #$\forall$# {A n} → Vec A (1 + n) → A
zip : #$\forall$# {A B n} → Vec A n → Vec B n → Vec (A × B) n
take : #$\forall$# {A} m {n} → Vec A (m + n) → Vec A m
|
algebraic-stack_agda0000_doc_8767 | -- Andreas, 2013-02-18 problem with 'with'-display, see also issue 295
-- {-# OPTIONS -v tc.with:50 #-}
module Issue800 where
data ⊤ : Set where
tt : ⊤
data I⊤ : ⊤ → Set where
itt : ∀ r → I⊤ r
bug : ∀ l → ∀ k → I⊤ l → ⊤
bug .l k (itt l) with itt k
... | foo = {! foo!}
{-
Current rewriting:
bug .... |
algebraic-stack_agda0000_doc_17072 | {-# OPTIONS --safe --without-K #-}
module CF.Types where
open import Data.Unit using (⊤; tt)
open import Data.Empty using (⊥)
open import Data.Product
open import Data.List as L
open import Data.String
open import Relation.Binary
open import Relation.Binary.PropositionalEquality
open import Relation.Nullary.Decidable
... |
algebraic-stack_agda0000_doc_17073 | {-# OPTIONS --cumulativity #-}
open import Agda.Primitive
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
module _ where
variable
ℓ ℓ′ ℓ₁ ℓ₂ : Level
A B C : Set ℓ
k l m n : Nat
lone ltwo lthree : Level
lone = lsuc lzero
ltwo = lsuc lone
lthree = lsuc ltwo
set0 : Set₂
set0 = Set₀
set1 : Set₂
s... |
algebraic-stack_agda0000_doc_17074 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Container Morphisms
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Container.Morphism where
open import Data.Container.Core
import Funct... |
algebraic-stack_agda0000_doc_17075 | module AbstractInterfaceExample where
open import Function
open import Data.Bool
open import Data.String
-- * One-parameter interface for the type `a' with only one method.
record VoiceInterface (a : Set) : Set where
constructor voice-interface
field say-method-of : a → String
open VoiceInterface
-- * An overl... |
algebraic-stack_agda0000_doc_17076 | module Dave.Isomorphism where
open import Dave.Equality
open import Dave.Functions
infix 0 _≃_
record _≃_ (A B : Set) : Set where
field
to : A → B
from : B → A
from∘to : ∀ (x : A) → from (to x) ≡ x
to∘from : ∀ (x : B) → to (from x) ≡ x
open _≃... |
algebraic-stack_agda0000_doc_17077 | open import Relation.Binary.Core
module Mergesort.Impl2.Correctness.Permutation {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_) where
open import Bound.Lower A
open import Bound.Lower.Order _≤_
open import Data.List
open import Data.Sum
open import List.Permutation.Base A
open im... |
algebraic-stack_agda0000_doc_17078 | {-# OPTIONS --cubical --safe #-}
module Data.Integer where
open import Level
open import Data.Nat using (ℕ; suc; zero)
import Data.Nat as ℕ
import Data.Nat.Properties as ℕ
open import Data.Bool
data ℤ : Type where
⁺ : ℕ → ℤ
⁻suc : ℕ → ℤ
⁻ : ℕ → ℤ
⁻ zero = ⁺ zero
⁻ (suc n) = ⁻suc n
{-# DISPLAY ⁻suc n = ⁻ ... |
algebraic-stack_agda0000_doc_17079 | ------------------------------------------------------------------------
-- Some definitions related to and properties of natural numbers
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
module Nat
{reflexive} (eq : ∀ {a p} → Equality-... |
algebraic-stack_agda0000_doc_17080 | {-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.GradedRing.Instances.TrivialGradedRing where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Data.Unit
open import Cubical.Data.Nat using (ℕ ; ze... |
algebraic-stack_agda0000_doc_17081 | {-# OPTIONS --allow-unsolved-metas #-}
open import Oscar.Class
open import Oscar.Class.Reflexivity
open import Oscar.Class.Symmetry
open import Oscar.Class.Transitivity
open import Oscar.Class.Transleftidentity
open import Oscar.Prelude
module Test.ProblemWithDerivation-5 where
module Map
{𝔵₁} {𝔛₁ : Ø 𝔵₁}
{𝔵... |
algebraic-stack_agda0000_doc_17082 | module CS410-Vec where
open import CS410-Prelude
open import CS410-Nat
data Vec (X : Set) : Nat -> Set where
[] : Vec X 0
_::_ : forall {n} ->
X -> Vec X n -> Vec X (suc n)
infixr 3 _::_
_+V_ : forall {X m n} -> Vec X m -> Vec X n -> Vec X (m +N n)
[] +V ys = ys
(x :: xs) +V ys = x :: xs +V ys
infixr ... |
algebraic-stack_agda0000_doc_17083 | -- Andreas, issue 2349
-- Andreas, 2016-12-20, issue #2350
-- {-# OPTIONS -v tc.term.con:50 #-}
postulate A : Set
data D {{a : A}} : Set where
c : D
test : {{a b : A}} → D
test {{a}} = c {{a}}
-- WAS: complaint about unsolvable instance
-- Should succeed
|
algebraic-stack_agda0000_doc_17084 | ------------------------------------------------------------------------------
-- Discussion about the inductive approach
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymo... |
algebraic-stack_agda0000_doc_17085 |
open import Agda.Builtin.Equality
postulate
Ty Cxt : Set
Var Tm : Ty → Cxt → Set
_≤_ : (Γ Δ : Cxt) → Set
variable
Γ Δ Φ : Cxt
A B C : Ty
x : Var A Γ
Mon : (P : Cxt → Set) → Set
Mon P = ∀{Δ Γ} (ρ : Δ ≤ Γ) → P Γ → P Δ
postulate
_•_ : Mon (_≤ Φ)
monVar : Mon (Var A)
monTm : Mon (Tm A)
postulate
r... |
algebraic-stack_agda0000_doc_17086 | module Prelude.List.Properties where
open import Prelude.Function
open import Prelude.Bool
open import Prelude.Bool.Properties
open import Prelude.Nat
open import Prelude.Nat.Properties
open import Prelude.Semiring
open import Prelude.List.Base
open import Prelude.Decidable
open import Prelude.Monoid
open import... |
algebraic-stack_agda0000_doc_17087 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- M-types (the dual of W-types)
------------------------------------------------------------------------
module Data.M where
open import Level
open import Coinduction
-- The family of M-types.
data M {a b} (A :... |
algebraic-stack_agda0000_doc_17024 | {-# OPTIONS --without-K #-}
module Agda.Builtin.Bool where
data Bool : Set where
false true : Bool
{-# BUILTIN BOOL Bool #-}
{-# BUILTIN FALSE false #-}
{-# BUILTIN TRUE true #-}
{-# COMPILE UHC Bool = data __BOOL__ (__FALSE__ | __TRUE__) #-}
{-# COMPILE JS Bool = function (x,v) { return ((x)? v["true"]() :... |
algebraic-stack_agda0000_doc_17025 | module _ where
q : ?
q = Set
|
algebraic-stack_agda0000_doc_17027 |
module _ where
module M where
infixr 3 _!_
data D : Set₁ where
_!_ : D → D → D
infixl 3 _!_
data E : Set₁ where
_!_ : E → E → E
open M
postulate
[_]E : E → Set
[_]D : D → Set
fail : ∀ {d e} → [ (d ! d) ! d ]D → [ e ! (e ! e) ]E
fail x = x -- should use the right fixity for the overloaded constructo... |
algebraic-stack_agda0000_doc_17028 | {-# OPTIONS --cubical --no-import-sorts --prop #-}
module Instances where
open import Cubical.Foundations.Everything renaming (_⁻¹ to _⁻¹ᵖ)
open import Agda.Primitive renaming (_⊔_ to ℓ-max; lsuc to ℓ-suc; lzero to ℓ-zero)
open import Cubical.Relation.Nullary.Base -- ¬_
open import Cubical.Relation.Binary.Base
open i... |
algebraic-stack_agda0000_doc_17029 |
module Container.List where
open import Prelude
infixr 5 _∷_
data All {a b} {A : Set a} (P : A → Set b) : List A → Set (a ⊔ b) where
[] : All P []
_∷_ : ∀ {x xs} (p : P x) (ps : All P xs) → All P (x ∷ xs)
data Any {a b} {A : Set a} (P : A → Set b) : List A → Set (a ⊔ b) where
instance
zero : ∀ {x xs} (p ... |
algebraic-stack_agda0000_doc_17030 | -- 2013-02-21 Andreas
-- ensure that constructor-headedness works also for abstract things
module Issue796 where
data U : Set where
a b : U
data A : Set where
data B : Set where
abstract
A' B' : Set
A' = A
B' = B -- fails if changed to A.
[_] : U → Set
[_] a = A'
[_] b = B'
f : ∀ u → [ u ] → U
... |
algebraic-stack_agda0000_doc_17031 | module Helper.CodeGeneration where
open import Agda.Primitive
open import Data.Nat
open import Data.Fin
open import Data.List
open import Function using (_∘_ ; _$_ ; _∋_)
open import Reflection
a : {A : Set} -> (x : A) -> Arg A
a x = arg (arg-info visible relevant) x
a1 : {A : Set} -> (x : A) -> Arg A
a1 x = arg (ar... |
algebraic-stack_agda0000_doc_17032 | import Lvl
open import Structure.Operator.Vector
open import Structure.Setoid
open import Type
module Structure.Operator.Vector.Subspace.Proofs
{ℓᵥ ℓₛ ℓᵥₑ ℓₛₑ}
{V : Type{ℓᵥ}} ⦃ equiv-V : Equiv{ℓᵥₑ}(V) ⦄
{S : Type{ℓₛ}} ⦃ equiv-S : Equiv{ℓₛₑ}(S) ⦄
{_+ᵥ_ : V → V → V}
{_⋅ₛᵥ_ : S → V → V}
{_+ₛ_ _⋅ₛ_ : S → ... |
algebraic-stack_agda0000_doc_17033 |
module _ where
module Inner where
private
variable A : Set
open Inner
fail : A → A
fail x = x
|
algebraic-stack_agda0000_doc_17034 | {-# OPTIONS --cubical --safe #-}
open import Prelude
open import Categories
module Categories.Coequalizer {ℓ₁ ℓ₂} (C : Category ℓ₁ ℓ₂) where
open Category C
private
variable
h i : X ⟶ Y
record Coequalizer (f g : X ⟶ Y) : Type (ℓ₁ ℓ⊔ ℓ₂) where
field
{obj} : Ob
arr : Y ⟶ obj
equality : arr ... |
algebraic-stack_agda0000_doc_17035 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- The universe polymorphic unit type and ordering relation
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Unit.Polymorphic.Base where
open... |
algebraic-stack_agda0000_doc_17036 | {-# OPTIONS --safe --warning=error --without-K --guardedness #-}
open import Functions.Definition
open import Functions.Lemmas
open import LogicalFormulae
open import Numbers.Naturals.Definition
open import Numbers.Naturals.Order
open import Sets.FinSet.Definition
open import Sets.FinSet.Lemmas
open import Sets.Cardin... |
algebraic-stack_agda0000_doc_17037 | module DeBruijn where
open import Prelude -- using (_∘_) -- composition, identity
open import Data.Maybe
open import Logic.Identity renaming (subst to subst≡)
import Logic.ChainReasoning
module Chain = Logic.ChainReasoning.Poly.Homogenous _≡_ (\x -> refl) (\x y z -> trans)
open Chain
-- untyped de Bruijn terms ... |
algebraic-stack_agda0000_doc_17038 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Some examples showing where the natural numbers and some related
-- operations and properties are defined, and how they can be used
------------------------------------------------------------------------
module... |
algebraic-stack_agda0000_doc_17039 | {-# OPTIONS --cubical --safe #-}
module Data.Nat.Base where
open import Agda.Builtin.Nat public
using (_+_; _*_; zero; suc)
renaming (Nat to ℕ; _-_ to _∸_)
import Agda.Builtin.Nat as Nat
open import Level
open import Data.Bool
data Ordering : ℕ → ℕ → Type₀ where
less : ∀ m k → Ordering m (suc (m + k))
eq... |
algebraic-stack_agda0000_doc_17026 | module Relator.Equals.Category where
import Data.Tuple as Tuple
open import Functional as Fn using (_$_)
open import Functional.Dependent using () renaming (_∘_ to _∘ᶠ_)
open import Logic.Predicate
import Lvl
open import Relator.Equals
open import Relator.Equals.Proofs
open import Structure.Categorical.Prope... |
algebraic-stack_agda0000_doc_5680 | ------------------------------------------------------------------------
-- An alternative definition of equality
------------------------------------------------------------------------
module TotalParserCombinators.CoinductiveEquality where
open import Codata.Musical.Notation
open import Data.List
open import Data.... |
algebraic-stack_agda0000_doc_5681 | {-# OPTIONS --type-in-type --guardedness #-}
module IO.Instance where
open import Class.Monad using (Monad)
open import Class.Monad.IO
open import Class.Monoid
open import Data.Product
open import Data.Sum
open import IO
open import Monads.ExceptT
open import Monads.StateT
open import Monads.WriterT
open import Level... |
algebraic-stack_agda0000_doc_5682 | ------------------------------------------------------------------------------
-- The FOTC lists type
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIO... |
algebraic-stack_agda0000_doc_5683 | -- Andreas, 2012-10-18
module Issue481 where
as = Set
open import Common.Issue481ParametrizedModule as as -- as clause
open import Common.Issue481ParametrizedModule as as as -- as clause, duplicate def.
|
algebraic-stack_agda0000_doc_5684 | open import MLib.Algebra.PropertyCode
open import MLib.Algebra.PropertyCode.Structures
module MLib.Matrix.SemiTensor.Associativity {c ℓ} (struct : Struct bimonoidCode c ℓ) where
open import MLib.Prelude
open import MLib.Matrix.Core
open import MLib.Matrix.Equality struct
open import MLib.Matrix.Mul struct
open import... |
algebraic-stack_agda0000_doc_5685 | {-# OPTIONS -v interaction.case:65 #-}
data Bool : Set where
true false : Bool
test : Bool → Bool
test x = {!x!}
|
algebraic-stack_agda0000_doc_5686 | module CTL.Modalities where
open import CTL.Modalities.AF public
open import CTL.Modalities.AG public
open import CTL.Modalities.AN public
-- open import CTL.Modalities.AU public -- TODO Unfinished
open import CTL.Modalities.EF public
open import CTL.Modalities.EG public
open import CTL.Modalities.EN public
-- open im... |
algebraic-stack_agda0000_doc_5687 | {-# OPTIONS --safe --warning=error --without-K #-}
open import Agda.Primitive
module Basic where
data False : Set where
record True : Set where
data _||_ {a b : _} (A : Set a) (B : Set b) : Set (a ⊔ b) where
inl : A → A || B
inr : B → A || B
infix 1 _||_
|
algebraic-stack_agda0000_doc_5688 | ------------------------------------------------------------------------
-- A formalisation of some definitions and laws from Section 3 of Ralf
-- Hinze's paper "Streams and Unique Fixed Points"
------------------------------------------------------------------------
module Hinze.Section3 where
open import Stream.Pro... |
algebraic-stack_agda0000_doc_5689 | ------------------------------------------------------------------------
-- The one-sided Step function, used to define similarity and the
-- two-sided Step function
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
open import Prelude
open import Labelled-transit... |
algebraic-stack_agda0000_doc_5690 | module Holes.Util where
open import Holes.Prelude
private
Rel : ∀ {a} → Set a → ∀ ℓ → Set (a ⊔ lsuc ℓ)
Rel A ℓ = A → A → Set ℓ
module CongSplit {ℓ x} {X : Set x} (_≈_ : Rel X ℓ) (reflexive : ∀ {x} → x ≈ x) where
two→one₁ : {_+_ : X → X → X}
→ (∀ {x x′ y y′} → x ≈ x′ → y ≈ y′ → (x + y) ≈ (x′ + y′))... |
algebraic-stack_agda0000_doc_5691 | {-# OPTIONS --without-K #-}
open import HoTT
open import homotopy.CircleHSpace
open import homotopy.LoopSpaceCircle
open import homotopy.Pi2HSusp
open import homotopy.IterSuspensionStable
-- This summerizes all [πₙ Sⁿ]
module homotopy.PinSn where
private
-- another way is to use path induction to prove the oth... |
algebraic-stack_agda0000_doc_5692 | open import MLib.Algebra.PropertyCode
open import MLib.Algebra.PropertyCode.Structures
module MLib.Matrix.Bimonoid {c ℓ} (struct : Struct bimonoidCode c ℓ) where
open import MLib.Prelude
open import MLib.Matrix.Core
open import MLib.Matrix.Equality struct
open import MLib.Matrix.Mul struct
open import MLib.Matrix.Plu... |
algebraic-stack_agda0000_doc_5693 |
open import Common.Prelude
record IsNumber (A : Set) : Set where
field fromNat : Nat → A
open IsNumber {{...}} public
{-# BUILTIN FROMNAT fromNat #-}
instance
IsNumberNat : IsNumber Nat
IsNumberNat = record { fromNat = λ n → n }
record IsNegative (A : Set) : Set where
field fromNeg : Nat → A
open IsNegat... |
algebraic-stack_agda0000_doc_5694 | {-# OPTIONS --cubical #-}
module Cubical.Categories.Category where
open import Cubical.Foundations.Prelude
record Precategory ℓ ℓ' : Type (ℓ-suc (ℓ-max ℓ ℓ')) where
no-eta-equality
field
ob : Type ℓ
hom : ob → ob → Type ℓ'
idn : ∀ x → hom x x
seq : ∀ {x y z} (f : hom x y) (g : hom y z) → hom x z
... |
algebraic-stack_agda0000_doc_5695 | ------------------------------------------------------------------------
-- Acyclic precedence graphs
------------------------------------------------------------------------
module Mixfix.Acyclic.PrecedenceGraph where
open import Data.List
open import Data.Product
open import Mixfix.Fixity
open import Mixfix.Operat... |
algebraic-stack_agda0000_doc_240 | -- Reported by Nils Anders Danielsson in Issue #3960.
open import Agda.Builtin.Unit
open import Agda.Primitive
id : ∀ {a} (A : Set a) → A → A
id _ a = a
apply : ∀ {a b} {A : Set a} {B : Set b} → A → (A → B) → B
apply = λ x f → f x
postulate
P : ∀ {a} {A : Set a} → A → A → Set a
Q : ∀ {ℓ} → Set ℓ → Set ℓ
Q A = {x... |
algebraic-stack_agda0000_doc_241 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Relation.Binary.Raw.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function using (_∘_; _$_; flip; id)
open import Cubical.Relation.Binary.Base
open import Cubical.Relation.... |
algebraic-stack_agda0000_doc_242 | module examplesPaperJFP.VariableList where
open import Data.Product hiding (map)
open import Data.List
open import NativeIO
open import StateSizedIO.GUI.WxBindingsFFI
open import Relation.Binary.PropositionalEquality
data VarList : Set₁ where
[] : VarList
addVar : (A : Set) → Var A → VarList → VarList
... |
algebraic-stack_agda0000_doc_243 | {-# OPTIONS --cubical #-}
module _ where
open import Agda.Builtin.Cubical.Path
open import Agda.Builtin.Bool
data S¹ : Set where
base : S¹
loop : base ≡ base
-- We cannot allow this definition as
-- decideEq (loop i) base ↦ false
-- but
-- decideEq (loop i0) base ↦ true
decideEq : ∀ (x y : S¹) → Bool
decide... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.