id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_12512 | ------------------------------------------------------------------------
-- A large class of algebraic structures satisfies the property that
-- isomorphic instances of a structure are equal (assuming univalence)
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-... |
algebraic-stack_agda0000_doc_12513 | {-# OPTIONS --without-K --safe #-}
module Categories.Category.Construction.Properties.Kleisli where
open import Level
import Relation.Binary.PropositionalEquality as ≡
open import Categories.Adjoint
open import Categories.Adjoint.Properties
open import Categories.Category
open import Categories.Functor using (Functor... |
algebraic-stack_agda0000_doc_12514 | module Issue599 where
data Bool : Set where
true false : Bool
-- standard lambda here
foo : Bool → Bool
foo = ?
-- pattern matching lambda here
bar : Bool → Bool
bar = ?
|
algebraic-stack_agda0000_doc_12515 | ------------------------------------------------------------------------
-- The halting problem
------------------------------------------------------------------------
module Halting-problem where
open import Equality.Propositional.Cubical
open import Logical-equivalence using (_⇔_)
open import Prelude hiding (const... |
algebraic-stack_agda0000_doc_12516 | module IrrelevantLambda where
postulate
A : Set
P : .A -> Set
f : ._ -> Set
f = λ .x -> P x
f' = λ .(x : _) -> P x
f'' = λ .{x y z : _} -> P x
g : ((.A -> Set) -> Set) -> Set
g k = k f
|
algebraic-stack_agda0000_doc_12517 | module Golden.InsertionSort where
open import Agda.Builtin.Nat
open import Agda.Builtin.List
open import Agda.Builtin.Bool
insert : Nat -> List Nat -> List Nat
insert a [] = a ∷ []
insert x (a ∷ b) with x < a
... | true = x ∷ a ∷ b
... | false = a ∷ (insert x b)
foldr : ∀ {a b : Set} → (a → b → b) → b → List a -> b
... |
algebraic-stack_agda0000_doc_12518 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Universe levels
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Level where
-- Levels.
open import Agda.Primitive as Prim public
using (... |
algebraic-stack_agda0000_doc_12519 | {-# OPTIONS --safe #-}
module Cubical.Algebra.MonoidSolver.Solver where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Structure
open import Cubical.Data.FinData using (Fin)
open import Cubical.Data.Nat using (ℕ)
open import Cubical.Data.List
open import Cubical.Data.Vec using (Vec; lookup)
... |
algebraic-stack_agda0000_doc_12520 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Homotopy.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv.Properties
private
variable
ℓ ℓ' : Level
_∼_ : {X : Type ℓ} {Y : X → Type ℓ'} → (f g : (x : X) → Y x) → Type (ℓ-max ℓ ℓ')
_∼_ {X = X} f g = (x : X... |
algebraic-stack_agda0000_doc_12521 | {-# OPTIONS --cubical --safe --postfix-projections #-}
module Categories.Exercises where
open import Prelude
open import Categories
open Category ⦃ ... ⦄
open import Categories.Product
open Product public
open HasProducts ⦃ ... ⦄ public
-- module _ {ℓ₁} {ℓ₂} ⦃ c : Category ℓ₁ ℓ₂ ⦄ ⦃ hp : HasProducts c ⦄ where
-- ... |
algebraic-stack_agda0000_doc_12522 | {-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Multiplication
open import Semirings.Definition
open import Rings.Definition
open import Setoids.Setoids
module Numbers.Integers.RingStructure.Ring where
open import Numbe... |
algebraic-stack_agda0000_doc_12523 |
module Oscar.Data.Term.Injectivity {𝔣} (FunctionName : Set 𝔣) where
open import Oscar.Data.Term FunctionName
open import Data.Fin
open import Data.Nat
open import Data.Vec
open import Relation.Binary.PropositionalEquality
Term-i-inj : ∀ {m} {𝑥₁ 𝑥₂ : Fin m} → i 𝑥₁ ≡ i 𝑥₂ → 𝑥₁ ≡ 𝑥₂
Term-i-inj refl = refl
Ter... |
algebraic-stack_agda0000_doc_12524 | {-# OPTIONS --without-K --exact-split --rewriting --overlapping-instances #-}
open import lib.Basics
open import lib.NConnected
open import lib.NType2
open import lib.types.Truncation
open import lib.types.Sigma
open import lib.Equivalence
open import lib.types.Fin
open import lib.types.Coproduct
open import Graphs.D... |
algebraic-stack_agda0000_doc_12525 | {-# OPTIONS --without-K #-}
module TypeEquivalences where
open import Data.Empty
open import Data.Unit
open import Data.Unit.Core
open import Data.Nat renaming (_⊔_ to _⊔ℕ_)
open import Data.Sum renaming (map to _⊎→_)
open import Data.Product renaming (map to _×→_)
open import Function renaming (_∘_ to _○_)
-- explic... |
algebraic-stack_agda0000_doc_12526 | {-# OPTIONS --cubical #-}
module HyperPositive where
open import Prelude
infixr 4 _↬_
{-# NO_POSITIVITY_CHECK #-}
record _↬_ (A : Type a) (B : Type b) : Type (a ℓ⊔ b) where
inductive; constructor hyp
field invoke : ((A ↬ B) → A) → B
open _↬_
open import Data.List using (List; _∷_; []; foldr)
module _ {a b} {A ... |
algebraic-stack_agda0000_doc_12527 | open import Relation.Binary.Indexed
module Relation.Binary.Indexed.EqReasoning {𝒾} {I : Set 𝒾} {𝒸 ℓ} (S : Setoid I 𝒸 ℓ) where
open Setoid S
import Relation.Binary.Indexed.PreorderReasoning as PreR
open import Relation.Binary.Indexed.Extra using (Setoid⇒Preorder)
open PreR (Setoid⇒Preorder S) public
renamin... |
algebraic-stack_agda0000_doc_4656 | module Categories.Ran where
open import Level
open import Categories.Category
open import Categories.Functor hiding (_≡_)
open import Categories.NaturalTransformation
record Ran {o₀ ℓ₀ e₀} {o₁ ℓ₁ e₁} {o₂ ℓ₂ e₂}
{A : Category o₀ ℓ₀ e₀} {B : Category o₁ ℓ₁ e₁} {C : Category o₂ ℓ₂ e₂}
(F : Functor... |
algebraic-stack_agda0000_doc_4657 | {- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020 Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.Prelude
open import LibraBFT.Lemmas
open import LibraBFT.H... |
algebraic-stack_agda0000_doc_4658 | module Thesis.Syntax where
open import Thesis.Types public
open import Thesis.Contexts public
data Const : (τ : Type) → Set where
unit : Const unit
lit : ℤ → Const int
plus : Const (int ⇒ int ⇒ int)
minus : Const (int ⇒ int ⇒ int)
cons : ∀ {t1 t2} → Const (t1 ⇒ t2 ⇒ pair t1 t2)
fst : ∀ {t1 t2} → Con... |
algebraic-stack_agda0000_doc_4659 |
open import Common.Reflection
macro
round-trip : Term → Tactic
round-trip v hole = unify v hole
module M (A : Set) where
data D : Set where
test : Set
test = round-trip D
|
algebraic-stack_agda0000_doc_4660 | module MissingWithClauses where
data D : Set where
c : D
f : D -> D
f c with c
|
algebraic-stack_agda0000_doc_4661 |
module PiInSet where
Rel : Set -> Set1
Rel A = A -> A -> Set
Reflexive : {A : Set} -> Rel A -> Set
Reflexive {A} _R_ = forall x -> x R x
Symmetric : {A : Set} -> Rel A -> Set
Symmetric {A} _R_ = forall x y -> x R y -> y R x
data True : Set where
tt : True
data False : Set where
data Nat : Set where
zero : Na... |
algebraic-stack_agda0000_doc_4662 | {-# OPTIONS --without-K --allow-unsolved-metas --exact-split #-}
module 21-pushouts where
import 20-pullbacks
open 20-pullbacks public
-- Section 14.1
{- We define the type of cocones with vertex X on a span. Since we will use it
later on, we will also characterize the identity type of the type of cocones
wit... |
algebraic-stack_agda0000_doc_4663 | {-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Category.Monoidal
-- the definition used here is not very similar to what one usually sees in nLab or
-- any textbook. the difference is that usually closed monoidal category is defined
-- through a right adjoint of -⊗X, which ... |
algebraic-stack_agda0000_doc_4664 | {-# OPTIONS --universe-polymorphism #-}
module Categories.Bifunctor where
open import Level
open import Data.Product using (_,_; swap)
open import Categories.Category
open import Categories.Functor public
open import Categories.Product
Bifunctor : ∀ {o ℓ e} {o′ ℓ′ e′} {o′′ ℓ′′ e′′} → Category o ℓ e → Category o′ ℓ′... |
algebraic-stack_agda0000_doc_4665 | module Cats.Functor.Op where
open import Cats.Category.Base
open import Cats.Category.Op using (_ᵒᵖ)
open import Cats.Functor using (Functor)
open Functor
Op : ∀ {lo la l≈ lo′ la′ l≈′}
→ {C : Category lo la l≈} {D : Category lo′ la′ l≈′}
→ Functor C D
→ Functor (C ᵒᵖ) (D ᵒᵖ)
Op F = record
{ fobj = fobj F
... |
algebraic-stack_agda0000_doc_4666 |
module Tactic.Deriving.Quotable where
open import Prelude
open import Container.Traversable
open import Tactic.Reflection
open import Tactic.Reflection.Quote.Class
open import Tactic.Deriving
private
-- Bootstrapping
qVis : Visibility → Term
qVis visible = con (quote visible) []
qVis hidden = con (quote hidd... |
algebraic-stack_agda0000_doc_4667 | open import Data.Product using ( _×_ )
open import FRP.LTL.ISet.Core using ( ISet ; ⌈_⌉ ; M⟦_⟧ )
open import FRP.LTL.Time using ( Time )
open import FRP.LTL.Time.Bound using ( fin ; _≺_ )
open import FRP.LTL.Time.Interval using ( [_⟩ ; sing )
module FRP.LTL.ISet.Until where
data _Until_ (A B : ISet) (t : Time) : Set ... |
algebraic-stack_agda0000_doc_4668 | module Sets.ExtensionalPredicateSet where
import Lvl
open import Data
open import Data.Boolean
open import Data.Either as Either using (_‖_)
open import Data.Tuple as Tuple using (_⨯_ ; _,_)
open import Functional
open import Function.Equals
open import Function.Equals.Proofs
open import Function.Inverse
open imp... |
algebraic-stack_agda0000_doc_4669 | open import MLib.Prelude
open import MLib.Algebra.PropertyCode
open import MLib.Algebra.PropertyCode.Structures
module MLib.Matrix.Plus {c ℓ} (struct : Struct bimonoidCode c ℓ) {m n : ℕ} where
open import MLib.Matrix.Core
open import MLib.Matrix.Equality struct
open FunctionProperties
-- Pointwise addition --
infi... |
algebraic-stack_agda0000_doc_4670 | {-
Practical Relational Algebra
Toon Nolten
based on
The Power Of Pi
-}
module relational-algebra where
open import Data.Empty
open import Data.Unit hiding (_≤_)
open import Data.Bool
open import Data.Nat
open import Data.Integer hiding (show)
open import Data.List
open import... |
algebraic-stack_agda0000_doc_4671 | {-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped as U
open import Definition.Typed
open import Definition.Typed.Weakening
open import Agda.Primitive
open import Tools.Pro... |
algebraic-stack_agda0000_doc_13024 | {-# OPTIONS --safe --postfix-projections #-}
module Cubical.Algebra.OrderedCommMonoid.PropCompletion where
{-
The completion of an ordered monoid, viewed as monoidal prop-enriched category.
This is used in the construction of the upper naturals, which is an idea of David
Jaz Myers presented here
https://felix-... |
algebraic-stack_agda0000_doc_13025 | -- Andreas, 2018-10-18, re issue #2757
--
-- Extracted this snippet from the standard library
-- as it caused problems during work in #2757
-- (runtime erasue using 0-quantity).
-- {-# OPTIONS -v tc.lhs.unify:65 -v tc.irr:50 #-}
open import Agda.Builtin.Size
data ⊥ : Set where
mutual
data Conat (i : Size) : Set w... |
algebraic-stack_agda0000_doc_13026 | open import MJ.Types
open import MJ.Classtable
import MJ.Syntax as Syntax
import MJ.Semantics.Values as Values
--
-- Substitution-free interpretation of welltyped MJ
--
module MJ.Semantics.Functional {c} (Σ : CT c) (ℂ : Syntax.Impl Σ) where
open import Prelude
open import Data.Vec hiding (init)
open import Data.Ve... |
algebraic-stack_agda0000_doc_13027 | {-# OPTIONS --allow-unsolved-metas #-}
module LiteralFormula where
open import OscarPrelude
open import IsLiteralFormula
open import HasNegation
open import Formula
record LiteralFormula : Set
where
constructor ⟨_⟩
field
{formula} : Formula
isLiteralFormula : IsLiteralFormula formula
open LiteralFormul... |
algebraic-stack_agda0000_doc_13028 | {-# OPTIONS --cubical --safe #-}
module Cubical.Foundations.Bundle where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.Fibration
open import Cubical.Foundations.Structure
open import Cubical.Structures.TypeEqvTo... |
algebraic-stack_agda0000_doc_13029 | module Generic.Property.Reify where
open import Generic.Core
data ExplView : Visibility -> Set where
yes-expl : ExplView expl
no-expl : ∀ {v} -> ExplView v
explView : ∀ v -> ExplView v
explView expl = yes-expl
explView v = no-expl
ExplMaybe : ∀ {α} -> Visibility -> Set α -> Set α
ExplMaybe v A with explView... |
algebraic-stack_agda0000_doc_13030 | module Issue1760g where
data ⊥ : Set where
{-# NO_POSITIVITY_CHECK #-}
{-# NON_TERMINATING #-}
mutual
record U : Set where
constructor roll
field ap : U → U
lemma : U → ⊥
lemma (roll u) = lemma (u (roll u))
bottom : ⊥
bottom = lemma (roll λ x → x)
|
algebraic-stack_agda0000_doc_13031 | {-# OPTIONS --without-K --safe #-}
open import Algebra.Structures.Bundles.Field
module Algebra.Linear.Morphism.VectorSpace
{k ℓᵏ} (K : Field k ℓᵏ)
where
open import Level
open import Algebra.FunctionProperties as FP
import Algebra.Linear.Morphism.Definitions as LinearMorphismDefinitions
import Algebra.Morphism a... |
algebraic-stack_agda0000_doc_13032 | module helloworld where
open import IO
main = run (putStrLn "Hello World")
|
algebraic-stack_agda0000_doc_13033 | {-# OPTIONS --without-K #-}
module hott.types where
open import hott.types.nat public
open import hott.types.coproduct public
|
algebraic-stack_agda0000_doc_13034 | module README where
----------------------------------------------------------------------
-- The Agda smallib library, version 0.1
----------------------------------------------------------------------
--
-- This library implements a type theory which is described in the
-- Appendix of the HoTT book. It also contains... |
algebraic-stack_agda0000_doc_13035 | {-# OPTIONS --without-K #-}
open import HoTT
open import cohomology.SuspAdjointLoopIso
open import cohomology.WithCoefficients
open import cohomology.Theory
open import cohomology.Exactness
open import cohomology.Choice
{- A spectrum (family (Eₙ | n : ℤ) such that ΩEₙ₊₁ = Eₙ)
- gives rise to a cohomology theory C wi... |
algebraic-stack_agda0000_doc_13036 | {-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Functions.Definition
open import Setoids.Setoids
open import Setoids.Subset
module Graphs.Definition where
record Graph {a b : _} (c : _) {V' : Set a} (V : Setoid {a} ... |
algebraic-stack_agda0000_doc_13037 | {-
A defintion of the real projective spaces following:
[BR17] U. Buchholtz, E. Rijke, The real projective spaces in homotopy type theory.
(2017) https://arxiv.org/abs/1704.05770
-}
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.RPn.Base where
open import Cubical.Foundations.Prelude
open impo... |
algebraic-stack_agda0000_doc_13038 | {-# OPTIONS --allow-unsolved-metas #-}
open import Agda.Builtin.Bool
postulate
A : Set
F : Bool → Set
F true = A
F false = A
data D {b : Bool} (x : F b) : Set where
variable
b : Bool
x : F b
postulate
f : D x → (P : F b → Set) → P x
|
algebraic-stack_agda0000_doc_13039 | -- {-# OPTIONS -v scope.clash:20 #-}
-- Andreas, 2012-10-19 test case for Issue 719
module ShadowModule2 where
open import Common.Size as YesDuplicate
import Common.Size as NotDuplicate
private open module YesDuplicate = NotDuplicate
-- should report:
-- Duplicate definition of module YesDuplicate.
-- NOT: Duplicate ... |
algebraic-stack_agda0000_doc_4832 | module CS410-Monoid where
open import CS410-Prelude
record Monoid (M : Set) : Set where
field
-- OPERATIONS ----------------------------------------
e : M
op : M -> M -> M
-- LAWS ----------------------------------------------
lunit : forall m -> op e m == m
runit : forall m -> op m e... |
algebraic-stack_agda0000_doc_4833 | ------------------------------------------------------------------------
-- A combinator for running two computations in parallel
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
module Delay-monad.Parallel where
import Equality.Propositional as Eq
open import Pr... |
algebraic-stack_agda0000_doc_4834 | {-# OPTIONS --allow-exec #-}
open import Agda.Builtin.FromNat
open import Data.Bool.Base using (T; Bool; if_then_else_)
open import Data.String using (String; _++_; lines)
open import Data.Nat.Base using (ℕ)
open import Data.Fin using (Fin)
import Data.Fin.Literals as Fin
import Data.Nat.Literals as Nat
open import D... |
algebraic-stack_agda0000_doc_4835 | module Theory where
open import Data.List using (List; []; _∷_; _++_)
open import Data.Fin using () renaming (zero to fzero; suc to fsuc)
open import Relation.Binary using (Rel)
open import Level using (suc; _⊔_)
open import Syntax
record Theory ℓ₁ ℓ₂ ℓ₃ : Set (suc (ℓ₁ ⊔ ℓ₂ ⊔ ℓ₃)) where
field
Sg : Signature ... |
algebraic-stack_agda0000_doc_4836 | module Prelude.Unit where
data Unit : Set where
unit : Unit
|
algebraic-stack_agda0000_doc_4837 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Bounded vectors (inefficient implementation)
------------------------------------------------------------------------
-- Vectors of a specified maximum length.
module Data.Star.BoundedVec where
open import Dat... |
algebraic-stack_agda0000_doc_4838 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
module homotopy.SmashFmapConn where
module _ {i} {j} {A : Type i} (B : A → Type j) where
custom-assoc : {a₀ a₁ a₂ a₃ : A}
{b₀ : B a₀} {b₁ b₁' b₁'' : B a₁} {b₂ : B a₂} {b₃ : B a₃}
{p : a₀ == a₁} (p' : b₀ == b₁ [ B ↓ p ])
(q' : b₁ == b₁')
(r' ... |
algebraic-stack_agda0000_doc_4839 | {-# OPTIONS --allow-unsolved-metas #-}
------------------------------------------------------------------------------
------------------------------------------------------------------------------
-- CS410 2017/18 Exercise 1 VECTORS AND FRIENDS (worth 25%)
--------------------------------------------------------------... |
algebraic-stack_agda0000_doc_4840 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- A categorical view of Vec
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Vec.Categorical {a n} where
open import Category.Applicative us... |
algebraic-stack_agda0000_doc_4841 | -- A placeholder module so that we can write a main. Agda compilation
-- does not work without a main so batch compilation is bound to give
-- errors. For travis builds, we want batch compilation and this is
-- module can be imported to serve that purpose. There is nothing
-- useful that can be achieved from this modul... |
algebraic-stack_agda0000_doc_4842 | open import Mockingbird.Forest using (Forest)
import Mockingbird.Forest.Birds as Birds
-- The Master Forest
module Mockingbird.Problems.Chapter18 {b ℓ} (forest : Forest {b} {ℓ})
⦃ _ : Birds.HasStarling forest ⦄
⦃ _ : Birds.HasKestrel forest ⦄ ... |
algebraic-stack_agda0000_doc_4843 | -- Andreas, 2017-01-12, re #2386
-- Correct error message for wrong BUILTIN UNIT
data Bool : Set where
true false : Bool
{-# BUILTIN UNIT Bool #-}
-- Error WAS:
-- The builtin UNIT must be a datatype with 1 constructors
-- when checking the pragma BUILTIN UNIT Bool
-- Expected error:
-- Builtin UNIT must be a sin... |
algebraic-stack_agda0000_doc_4844 | open import FRP.JS.Bool using ( not )
open import FRP.JS.Nat using ( ) renaming ( _≟_ to _≟n_ )
open import FRP.JS.String using ( _≟_ ; _≤_ ; _<_ ; length )
open import FRP.JS.QUnit using ( TestSuite ; ok ; test ; _,_ )
module FRP.JS.Test.String where
tests : TestSuite
tests =
( test "≟"
( ok "abc ≟ abc" ("ab... |
algebraic-stack_agda0000_doc_4845 | -- Andreas, 2017-11-06, issue #2840 reported by wenkokke
Id : (F : Set → Set) → Set → Set
Id F = F
data D (A : Set) : Set where
c : Id _ A
-- WAS: internal error in positivity checker
-- EXPECTED: success, or
-- The target of a constructor must be the datatype applied to its
-- parameters, _F_2 A isn't
-- when ch... |
algebraic-stack_agda0000_doc_4846 | ------------------------------------------------------------------------
-- This module proves that the context-sensitive language aⁿbⁿcⁿ can
-- be recognised
------------------------------------------------------------------------
-- This is obvious given the proof in
-- TotalRecognisers.LeftRecursion.ExpressiveStren... |
algebraic-stack_agda0000_doc_4847 |
postulate
Nat : Set
Fin : Nat → Set
Finnat : Nat → Set
fortytwo : Nat
finnatic : Finnat fortytwo
_==_ : Finnat fortytwo → Finnat fortytwo → Set
record Fixer : Set where
field fix : ∀ {x} → Finnat x → Finnat fortytwo
open Fixer {{...}}
postulate
Fixidentity : {{_ : Fixer}} → Set
instance
fixiden... |
algebraic-stack_agda0000_doc_13248 | module Categories.Setoids where
open import Library
open import Categories
record Setoid {a b} : Set (lsuc (a ⊔ b)) where
field set : Set a
eq : set → set → Set b
ref : {s : set} → eq s s
sym' : {s s' : set} → eq s s' → eq s' s
trn : {s s' s'' : set} →
eq s s' → eq s... |
algebraic-stack_agda0000_doc_13249 | ------------------------------------------------------------------------
-- Divisibility and coprimality
------------------------------------------------------------------------
module Data.Integer.Divisibility where
open import Data.Function
open import Data.Integer
open import Data.Integer.Properties
import Data.Na... |
algebraic-stack_agda0000_doc_13250 | module Issue18 where
postulate
D : Set
data ∃ (A : D → Set) : Set where
_,_ : (witness : D) → A witness → ∃ A
|
algebraic-stack_agda0000_doc_13251 | {-# OPTIONS --cubical #-}
module Cubical.README where
------------------------------------------------------------------------
-- An experimental library for Cubical Agda
-----------------------------------------------------------------------
-- The library comes with a .agda-lib file, for use with the library
-- man... |
algebraic-stack_agda0000_doc_13252 | module Lang.Function where
import Lvl
open import Data.Boolean
open import Data.List as List using (List)
open import Data.List.Functions.Positional as List
open import Data.Option
open import Data
open import Lang.Reflection
open import Syntax.Do
open import Type
-- A default value tactic for implicit arguments... |
algebraic-stack_agda0000_doc_13253 |
postulate
T C D : Set
instance I : {{_ : C}} → D
d : {{_ : D}} → T
t : T
t = d
|
algebraic-stack_agda0000_doc_13254 | {-# OPTIONS --without-K --safe #-}
module Categories.Diagram.Cone.Properties where
open import Level
open import Categories.Category
open import Categories.Functor
open import Categories.Functor.Properties
open import Categories.NaturalTransformation
import Categories.Diagram.Cone as Con
import Categories.Morphism.R... |
algebraic-stack_agda0000_doc_13255 | {-# OPTIONS --safe #-}
module Definition.Conversion.HelperDecidable where
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Conversion
open import Definition.Conversion.Whnf
open import Definition.Conver... |
algebraic-stack_agda0000_doc_13256 | record R (X : Set) : Set₁ where
field
P : X → Set
f : ∀ {x : X} → P x → P x
open R {{…}}
test : ∀ {X} {{r : R X}} {x : X} → P x → P x
test p = f p
-- WAS: instance search fails with several candidates left
-- SHOULD: succeed
|
algebraic-stack_agda0000_doc_13257 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Heterogeneous equality
------------------------------------------------------------------------
{-# OPTIONS --with-K --safe #-}
module Relation.Binary.HeterogeneousEquality where
import Axiom.Extensionality.He... |
algebraic-stack_agda0000_doc_13258 | {-# OPTIONS --without-K #-}
module Data.Word8.Primitive where
open import Agda.Builtin.Bool using (Bool)
open import Agda.Builtin.Nat using (Nat)
{-# FOREIGN GHC import qualified Data.Word #-}
{-# FOREIGN GHC import qualified Data.Bits #-}
postulate
Word8 : Set
_==_ : Word8 → Word8 → Bool
_/=_ : Word8 → Word8... |
algebraic-stack_agda0000_doc_13259 | ------------------------------------------------------------------------------
-- Testing the --schematic-propositional-symbols option
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-un... |
algebraic-stack_agda0000_doc_13260 | module Formalization.ClassicalPropositionalLogic.NaturalDeduction.Consistency where
import Lvl
open import Formalization.ClassicalPropositionalLogic.NaturalDeduction
open import Formalization.ClassicalPropositionalLogic.NaturalDeduction.Proofs
open import Formalization.ClassicalPropositionalLogic.Syntax
open impo... |
algebraic-stack_agda0000_doc_13261 | open import Structure.Operator.Field
open import Structure.Setoid
open import Type
-- Operators for matrices over a field.
module Numeral.Matrix.OverField {ℓ ℓₑ}{T : Type{ℓ}} ⦃ equiv : Equiv{ℓₑ}(T) ⦄ {_+ₛ_ _⋅ₛ_ : T → T → T} ⦃ field-structure : Field(_+ₛ_)(_⋅ₛ_) ⦄ where
open Field(field-structure) renaming (_−_ to _−ₛ_... |
algebraic-stack_agda0000_doc_13262 | module Five where
open import Relation.Binary.PropositionalEquality
open ≡-Reasoning
import Data.Nat as ℕ
import Data.Nat.Properties as ℕₚ
import Data.List as List
import Data.List.Properties as Listₚ
import Data.Product as Product
open List using (List; []; _∷_; _++_)
open ℕ using (ℕ; zero; suc; _+_)
open Product u... |
algebraic-stack_agda0000_doc_13263 | open import Prelude renaming (lift to finlift) hiding (id; subst)
module Implicits.Substitutions.Lemmas.LNMetaType where
open import Implicits.Syntax.LNMetaType
open import Implicits.Substitutions.LNMetaType
open import Data.Fin.Substitution
open import Data.Fin.Substitution.Lemmas
open import Data.Vec.Properties
o... |
algebraic-stack_agda0000_doc_14048 | {-# OPTIONS --universe-polymorphism #-}
module Categories.Enriched where
open import Categories.Category
open import Categories.Monoidal
-- moar |
algebraic-stack_agda0000_doc_14049 | {-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.cubical.Square
open import lib.types.Bool
open import lib.types.Coproduct
open import lib.types.FunctionSeq
open import lib.types.Paths
open import lib.types.Pointed
open import lib.types.Span
open import lib.types.Pushout
open import lib.t... |
algebraic-stack_agda0000_doc_14050 | -- Testing parameterised records in parameterised modules
module Exist (X : Set) where
data [_] (a : Set) : Set where
[] : [ a ]
_∷_ : a -> [ a ] -> [ a ]
map : forall {a b} -> (a -> b) -> [ a ] -> [ b ]
map f [] = []
map f (x ∷ xs) = f x ∷ map f xs
record ∃ (a : Set) (P : a -> Set) : Set where
field
... |
algebraic-stack_agda0000_doc_14051 | {-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (Rel; Setoid; IsEquivalence)
module Structures
{a ℓ} {A : Set a} -- The underlying set
(_≈_ : Rel A ℓ) -- The underlying equality relation
where
open import Algebra.Core
open import Level using (_⊔_)
open import Data.Product using (_,_; pr... |
algebraic-stack_agda0000_doc_14052 | -- Andreas, 2016-10-04, issue #2236
-- Result splitting should not insert hidden arguments visibly
-- {-# OPTIONS -v interaction.case:100 #-}
-- {-# OPTIONS -v tc.cover:100 #-}
-- {-# OPTIONS -v reify.clause:100 #-}
-- {-# OPTIONS -v reify.implicit:100 #-}
splitMe : (A : Set) {B : Set} → Set
splitMe = {!!} -- C-c C-... |
algebraic-stack_agda0000_doc_14053 | {-# OPTIONS --without-K --exact-split --safe #-}
open import Fragment.Algebra.Signature
module Fragment.Algebra.Free.Base (Σ : Signature) where
open import Fragment.Algebra.Algebra Σ
open import Fragment.Algebra.Free.Atoms public
open import Level using (Level; _⊔_)
open import Function using (_∘_)
open import Dat... |
algebraic-stack_agda0000_doc_14054 | -- 2011-09-14 posted by Nisse
-- Andreas: this failed since SubstHH for Telescopes was wrong.
-- {-# OPTIONS --show-implicit -v tc.lhs.unify:15 #-}
module Issue292-14 where
data D : Set where
d : D
postulate T : D → D → Set
data T′ (x y : D) : Set where
c : T x y → T′ x y
F : D → D → Set
F x d = T′ x d -- bloc... |
algebraic-stack_agda0000_doc_14055 | {-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
{-# OPTIONS --type-in-type #-}
-- Note: Using this module is discouraged unless absolutely necessary.
-- Use `Data.Product` or `Data.Both` instead.
module Light.Indexed where
open import Light.Level using (Level)
postulate ℓ : Level
rec... |
algebraic-stack_agda0000_doc_14056 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Group.Action where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Structure
open import Cubical.A... |
algebraic-stack_agda0000_doc_14057 | {-
This file contains:
- Properties of set truncations
-}
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.SetTruncation.Properties where
open import Cubical.HITs.SetTruncation.Base
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open im... |
algebraic-stack_agda0000_doc_14058 | {-# OPTIONS --without-K #-}
open import Base
open import Homotopy.TruncatedHIT
open import Spaces.Spheres
open import Integers
module Sets.Quotient {i j} (A : Set i) ⦃ p : is-set A ⦄
(R : A → A → Set j) ⦃ q : (x y : A) → is-prop (R x y) ⦄ where
private
data _#/_ : Set (max i j) where
#proj : A → _#/_
#t... |
algebraic-stack_agda0000_doc_14059 | {-# OPTIONS --allow-unsolved-metas #-}
-- When instantiating metas, we can't ignore variables occurring in
-- irrelevant terms. If we do the irrelevant terms will become illformed
-- (and we get __IMPOSSIBLE__s)
-- For instance
-- _42 := DontCare (Just (Var 0 []))
-- is a bad thing to do. In the example below we hit ... |
algebraic-stack_agda0000_doc_14060 | module Categories.Support.Experimental where
open import Relation.Binary.PropositionalEquality.TrustMe
open import Categories.Support.PropositionalEquality
≣-relevant : ∀ {l} {A : Set l} {X Y : A} -> .(X ≣ Y) -> X ≣ Y
≣-relevant _ = trustMe
private
≣-coe : ∀ {a} {A B : Set a} → (A ≣ B) -> A -> B
≣-coe ≣-refl a ... |
algebraic-stack_agda0000_doc_14061 | {-# OPTIONS --without-K --safe #-}
open import Polynomial.Parameters
module Polynomial.NormalForm.Construction
{a ℓ}
(coeffs : RawCoeff a ℓ)
where
open import Relation.Nullary using (Dec; yes; no)
open import Level using (lift; lower; _⊔_)
open import Data.Unit using (... |
algebraic-stack_agda0000_doc_14062 | -- Andreas, 2011-04-14
module UnificationUndecidedForNonStronglyRigidOccurrence where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
data _≡_ {A : Set}(a : A) : A -> Set where
refl : a ≡ a
i : (f : Nat -> Nat)(n : Nat) -> n ≡ f n -> Nat
i f n ()
-- this should fail, since n ≡ f n is not always empty, only i... |
algebraic-stack_agda0000_doc_14063 | {-# OPTIONS --safe #-}
module JVM.Compiler where
open import JVM.Types
open import JVM.Syntax.Instructions
module _ 𝑭 where
open import JVM.Compiler.Monad StackTy ⟨ 𝑭 ∣_↝_⟩ noop using (Compiler) public
module _ {𝑭} where
open import JVM.Compiler.Monad StackTy ⟨ 𝑭 ∣_↝_⟩ noop hiding (Compiler) public
|
algebraic-stack_agda0000_doc_13648 | -- The purpose of this universe construction is to get some definitional
-- equalities in the model. Specifically, if we define ⟦σ⟧ : ⟦Δ⟧ → ⟦Ω⟧
-- (a functor) for the "canonical" notion of subsitution, then we have
-- ⟦Wk⟧ (δ , m) ≡ δ propositionally, but *not* definitionally. This then
-- complicates proofs involving ... |
algebraic-stack_agda0000_doc_13649 | {-# OPTIONS --safe #-}
module Cubical.Algebra.DirectSum.DirectSumHIT.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Empty as ⊥
open import Cubical.Data.Sigma
open import Cubical.Relation.Nullary
open import Cubical.Algebra.Group
open import Cubical.Algebra.AbGroup
open import Cubi... |
algebraic-stack_agda0000_doc_13650 | -- Check that unquoted functions are termination checked.
module _ where
open import Common.Prelude hiding (_>>=_)
open import Common.Reflection
`⊥ : Type
`⊥ = def (quote ⊥) []
{-
Generate
aux : ⊥
aux = aux
loop : ⊥
loop = aux
-}
makeLoop : QName → TC ⊤
makeLoop loop =
freshName "aux" >>= λ aux →
declar... |
algebraic-stack_agda0000_doc_13651 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Definitions for types of functions that only require an equality
-- relation over the domain.
------------------------------------------------------------------------
-- The contents of this file should usually ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.