id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_13652 | ------------------------------------------------------------------------
-- Parsers containing non-terminals, and grammars using such parsers
------------------------------------------------------------------------
module StructurallyRecursiveDescentParsing.Grammar where
open import Data.Bool
open import Data.Empty
o... |
algebraic-stack_agda0000_doc_13653 | {-# OPTIONS --universe-polymorphism #-}
module Categories.Square where
open import Level
open import Function renaming (id to idᶠ; _∘_ to _©_)
open import Categories.Support.PropositionalEquality
open import Categories.Category
import Categories.Morphisms as Mor
open import Relation.Binary hiding (_⇒_)
module Glue... |
algebraic-stack_agda0000_doc_13654 | -- Andreas, 2016-06-09 issue during refactoring for #1963
-- Shrunk this issue with projection-like functions from std-lib
-- {-# OPTIONS --show-implicit #-}
-- {-# OPTIONS -v tc.proj.like:10 #-}
open import Common.Level
open import Common.Nat renaming ( Nat to ℕ )
data ⊥ : Set where
record ⊤ : Set where
construc... |
algebraic-stack_agda0000_doc_13655 | open import Level using (_⊔_; suc; Lift; lift)
open import Function using (_$_; _∘_; _⤖_)
open import Relation.Nullary using (¬_)
open import Relation.Nullary.Decidable using (False)
open import Relation.Binary using (Rel; Decidable; Setoid; DecSetoid; IsEquivalence; IsDecEquivalence)
open import Data.Empty using (⊥)
... |
algebraic-stack_agda0000_doc_13656 |
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
record Eq (A : Set) : Set₁ where
field
_≈_ : A → A → Set
open Eq {{...}} public
record Setoid : Set₁ where
field
∣_∣ : Set
{{eq}} : Eq ∣_∣
open Setoid public
-- instance
-- EqNat : Eq Nat
-- _≈_ {{EqNat}} = _≡_
NatSetoid : Seto... |
algebraic-stack_agda0000_doc_13657 | open import Data.Bool
module GUIgeneric.GUIExample where
open import GUIgeneric.Prelude renaming (inj₁ to secondBtn; inj₂ to firstBtn; WxColor to Color) hiding (addButton; _>>_)
open import GUIgeneric.GUIDefinitions renaming (add to add'; add' to add)
open import GUIgeneric.GUI
open import GUIgeneric.GUIExampleLi... |
algebraic-stack_agda0000_doc_13658 | -- {-# OPTIONS -v tc.conv.level:60 #-}
-- {-# OPTIONS -v tc.conv:30 #-}
{- Agda development version: Wed Oct 30 16:30:06 GMT 2013
The last line of code triggers the following error,
but replacing '_' with 'a' typechecks just fine.
Bug.agda:32,8-11
tt != a of type ⊤
when checking that the expression s ... |
algebraic-stack_agda0000_doc_13659 | module x01-842Naturals where
-- This is a comment.
{-
This is a multi-line comment
-}
-- Definition of datatype representing natural numbers. ♭
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
-- A couple of definitions using this datatype.
one : ℕ
one = suc zero
two : ℕ
two = suc (suc zero)
-- I could have also... |
algebraic-stack_agda0000_doc_13660 | -- Andreas, 2018-05-28, issue #3095, fail on attempt to make hidden parent variable visible
data Nat : Set where
suc : {n : Nat} → Nat
data IsSuc : Nat → Set where
isSuc : ∀{n} → IsSuc (suc {n})
test : ∀{m} → IsSuc m → Set
test p = aux p
where
aux : ∀{n} → IsSuc n → Set
aux isSuc = {!.m!} -- Split on .m h... |
algebraic-stack_agda0000_doc_13661 | {-# OPTIONS --without-K --safe #-}
module Categories.Minus2-Category.Properties where
-- All -2-Categories are equivalent to One
open import Level
open import Data.Product using (Σ; _,_; proj₁; proj₂)
open import Data.Unit using (⊤; tt)
open import Categories.Minus2-Category
open import Categories.Category
import C... |
algebraic-stack_agda0000_doc_13662 | module gc where
open import lib
-- we will model addresses in memory as just natural numbers
Address : Set
Address = ℕ
-- a value of type (Bounded n) is an address a together with a proof that a is less than n
Bounded : Address → Set
Bounded n = Σ Address (λ a → a < n ≡ tt)
-- a (Cell a) models an addre... |
algebraic-stack_agda0000_doc_13663 | {-
In this file we apply the cubical machinery to Martin Hötzel-Escardó's
structure identity principle:
https://www.cs.bham.ac.uk/~mhe/HoTT-UF-in-Agda-Lecture-Notes/HoTT-UF-Agda.html#sns
-}
{-# OPTIONS --cubical --safe #-}
module Cubical.Foundations.SIP where
open import Cubical.Foundations.Prelude
open import Cubi... |
algebraic-stack_agda0000_doc_3936 | module Record where
module M where
record A
: Set
where
constructor
a
open M
record B
: Set
where
record C
: Set
where
constructor
c
x
: A
x
= a
y
: C
y
= record {}
record D
(E : Set)
: Set
where
record F
: Set₁
where
field
G
: Set
... |
algebraic-stack_agda0000_doc_3937 | {-# OPTIONS --cubical --safe #-}
module JustBeInjective where
open import Cubical.Core.Everything
open import Cubical.Data.Unit
data maybe (A : Set) : Set where
just : A -> maybe A
nothing : maybe A
variable A : Set
unwrap : A → (a : maybe A) → A
unwrap _ (just x) = x
unwrap a nothing = a
just-injective : ∀ {A ... |
algebraic-stack_agda0000_doc_3938 | {-# OPTIONS --cubical #-}
module LaterPrims where
open import Agda.Primitive
open import Agda.Primitive.Cubical renaming (itIsOne to 1=1)
open import Agda.Builtin.Cubical.Path
open import Agda.Builtin.Cubical.Sub renaming (Sub to _[_↦_]; primSubOut to outS)
module Prims where
primitive
primLockUniv : Set₁
open... |
algebraic-stack_agda0000_doc_3939 | module 120-natural-induction-necessary where
open import 010-false-true
open import 020-equivalence
open import 100-natural
-- We prove that the induction axiom is necessary.
-- Peano axioms without induction.
record NaturalWithoutInduction
{M : Set}
(zero : M)
(suc : M -> M)
(_==_ : M -> M -> Set)
: Set1... |
algebraic-stack_agda0000_doc_3940 |
module Issue468 where
data Unit : Set where
nothing : Unit
data Maybe (A : Set) : Set where
nothing : Maybe A
just : A → Maybe A
data P : (R : Set) → Maybe R → Set₁ where
p : (R : Set) (x : R) → P R (just x)
works : P Unit (just _)
works = p _ nothing
fails : Unit → P Unit (just _)
fails x = p _ nothing
|
algebraic-stack_agda0000_doc_3941 | {-# OPTIONS --safe --warning=error --without-K #-}
open import Setoids.Setoids
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Groups.Definition
open import Groups.Homomorphisms.Definition
module Groups.Isomorphisms.Definition where
record GroupIso {m n o p : _} {A : Set m} {S : Setoid {m} {o}... |
algebraic-stack_agda0000_doc_3942 |
module Lib.Vec where
open import Lib.Prelude
open import Lib.Nat
open import Lib.Fin
infixr 40 _::_ _++_
data Vec (A : Set) : Nat -> Set where
[] : Vec A 0
_::_ : forall {n} -> A -> Vec A n -> Vec A (suc n)
_++_ : {A : Set}{n m : Nat} -> Vec A n -> Vec A m -> Vec A (n + m)
[] ++ ys = ys
(x :: xs) ++ y... |
algebraic-stack_agda0000_doc_3943 | {-# OPTIONS --safe #-}
module Cubical.Algebra.CommRing.Instances.Unit where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Unit
open import Cubical.Algebra.Ring
open import Cubical.Algebra.CommRing
private
variable
ℓ : Level
open CommRingStr
UnitCommRing : ∀ {ℓ} → CommRing ℓ
fst UnitCommRi... |
algebraic-stack_agda0000_doc_3944 | module Prelude.String where
open import Prelude.Bool
open import Prelude.Char
open import Prelude.List
open import Prelude.Nat
postulate
String : Set
nil : String
primStringToNat : String → Nat
charToString : Char -> String
{-# BUILTIN STRING String #-}
primitive
primStringAppend : String → String → Str... |
algebraic-stack_agda0000_doc_3945 | module Everything where
import Library
import Syntax
import RenamingAndSubstitution
import EquationalTheory
|
algebraic-stack_agda0000_doc_3946 | -- TODO: Unfinished
open import Logic
open import Type
open import Structure.Relator
open import Structure.Setoid
module Geometry.HilbertAxioms
{ℓₚ ℓₗ ℓₚₑ ℓₗₑ ℓₚₗ ℓₚₚₚ}
(Point : Type{ℓₚ}) ⦃ equiv-point : Equiv{ℓₚₑ}(Point) ⦄ -- The type of points on a plane.
(Line : Type{ℓₗ}) ⦃ equiv-line : Equiv{ℓₗₑ}(Line) ⦄ ... |
algebraic-stack_agda0000_doc_3947 | {-# OPTIONS --sized-types #-}
module GiveSize where
postulate Size : Set
{-# BUILTIN SIZE Size #-}
id : Size → Size
id i = {!i!}
|
algebraic-stack_agda0000_doc_3948 | open import Formalization.PredicateLogic.Signature
module Formalization.PredicateLogic.Syntax.NegativeTranslations (𝔏 : Signature) where
open Signature(𝔏)
open import Data.ListSized
import Lvl
open import Formalization.PredicateLogic.Syntax (𝔏)
open import Functional using (_∘_ ; _∘₂_ ; swap)
open import Nume... |
algebraic-stack_agda0000_doc_3949 | module Lawvere where
open import Library
open import Data.Sum
open import Categories
open import Categories.Sets
open import Categories.Initial
open import Categories.PushOuts
open import Categories.Products hiding (_×_)
open import Categories.CoProducts
open import Categories.Terminal
open import Functors
open impor... |
algebraic-stack_agda0000_doc_3950 |
module UniDB.Subst.Core where
open import UniDB.Spec public
open import UniDB.Morph.Unit
record Ap (T X : STX) : Set₁ where
field
ap : {Ξ : MOR} {{lkTΞ : Lk T Ξ}} {{upΞ : Up Ξ}}
{γ₁ γ₂ : Dom} (ξ : Ξ γ₁ γ₂) (x : X γ₁) → X γ₂
open Ap {{...}} public
record ApVr (T : STX) {{vrT : Vr T}} {{apTT : Ap T T}} : ... |
algebraic-stack_agda0000_doc_3951 | {-# OPTIONS --allow-unsolved-metas #-}
infixr 6 _∷_
data List (A : Set) : Set where
[] : List A
_∷_ : A -> List A -> List A
postulate
Bool : Set
t : Bool
long : List Bool
long =
t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷
t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ t ∷ ... |
algebraic-stack_agda0000_doc_5280 | ------------------------------------------------------------------------
-- A definitional interpreter
------------------------------------------------------------------------
{-# OPTIONS --cubical --safe #-}
module Lambda.Simplified.Partiality-monad.Inductive.Interpreter where
open import Equality.Propositional.Cub... |
algebraic-stack_agda0000_doc_5281 |
module Elements where
open import OscarPrelude
open import Arity
open import Vector
open import Element
record Elements : Set
where
constructor ⟨_⟩
field
{arity} : Arity
elements : Vector Element arity
open Elements public
instance EqElements : Eq Elements
Eq._==_ EqElements (⟨_⟩ {𝑎₁} εs₁) (⟨_⟩ {𝑎₂}... |
algebraic-stack_agda0000_doc_5282 | {-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Categories.DistLatticeSheaf.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Structure
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Powerset
open import Cubical.Data.Sigma
open import Cub... |
algebraic-stack_agda0000_doc_5283 | {- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020, 2021, Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
-- This is a selection of useful functions and definitions
-- from the s... |
algebraic-stack_agda0000_doc_5284 | {-# OPTIONS --without-K --safe #-}
module Math.NumberTheory.Product.Generic where
-- agda-stdlib
open import Algebra
-- agda-misc
open import Math.NumberTheory.Summation.Generic
-- TODO add syntax
module MonoidProduct {c e} (M : Monoid c e) =
MonoidSummation M
renaming
( Σ< to Π<
; Σ≤ to Π≤
; Σ<range to Π... |
algebraic-stack_agda0000_doc_5285 |
postulate
C : Set
anything : C
record I : Set where
constructor c
field
f : C
data Wrap : (j : I) → Set where
wrap : ∀ {j} → Wrap j
-- The following should not pass.
-- It did before the fix of #142.
issue142 : ∀ {j} → Wrap j → C
issue142 {c _} (wrap {c _}) with anything
issue142 {c _} (wrap .{c anyth... |
algebraic-stack_agda0000_doc_5286 | open import Relation.Unary using ( ∅ ; _∪_ )
open import Web.Semantic.DL.Signature using ( Signature ; CN ; RN )
open import Web.Semantic.Util using ( Subset ; ⁅_⁆ )
module Web.Semantic.DL.Role where
data Role (Σ : Signature) : Set where
⟨_⟩ : (r : RN Σ) → Role Σ
⟨_⟩⁻¹ : (r : RN Σ) → Role Σ
inv : ∀ {Σ} → Role Σ ... |
algebraic-stack_agda0000_doc_5287 | {- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020, 2021 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 Libr... |
algebraic-stack_agda0000_doc_5288 | module Issue252 where
data I : Set where
zero : I
data D : I → Set where
c : ∀ i → D i → D i
id : I → I
id i = i
index : ∀ i → D i → I
index i _ = i
foo : ∀ i → D i → D zero
foo .i (c i d) with id i
foo ._ (c i d) | zero = d
bar : ∀ i → D i → D zero
bar .i (c i d) with index i d
bar ._ (c i d) | zero = d
-- ... |
algebraic-stack_agda0000_doc_5289 | module Thesis.SIRelBigStep.Normalization where
open import Thesis.SIRelBigStep.Lang
open import Data.Unit.Base hiding (_≤_)
open import Data.Product
open import Relation.Binary.PropositionalEquality
-- Define logical relation for normalization. Adapted from TAPL Ch. 12.
mutual
normT : ∀ {Γ} τ (t : Term Γ τ) (ρ : ⟦... |
algebraic-stack_agda0000_doc_5290 | module Esterel.Environment where
open import utility
open import Data.Empty
open import Esterel.Variable.Signal as Signal
using (Signal ; _ₛ)
open import Esterel.Variable.Shared as SharedVar
using (SharedVar ; _ₛₕ)
open import Esterel.Variable.Sequential as SeqVar
using (SeqVar ; _ᵥ)
open import Data.Product
i... |
algebraic-stack_agda0000_doc_5291 | {-# OPTIONS --safe #-}
module Cubical.Algebra.DistLattice.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Unival... |
algebraic-stack_agda0000_doc_5292 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Relation.Binary.Raw.Construct.Intersection where
open import Cubical.Core.Everything
open import Cubical.Foundations.Function using (_∘_)
open import Cubical.Data.Prod
open import Cubical.Data.Sum.Base using (_⊎_; inl; inr; rec)
open import Cubical.Re... |
algebraic-stack_agda0000_doc_5293 | -- Andreas & Jesper, 2018-05-11, issue #3052 reported by identicalsnowflake
--
-- The problem here was that free variable collection had the standard
-- monoid instance of IntMap, which is just "randomly" picking one variant.
-- Thus, if we have both irrelevant and relevant occurrences of a variable,
-- we get whatever... |
algebraic-stack_agda0000_doc_5294 | module Ex3Lec where
----------------------------------------------------------------------------
-- EXERCISE 3 -- MONADS FOR HUTTON'S RAZOR
--
-- VALUE: 15%
-- DEADLINE: 5pm, Friday 20 November (week 9)
--
-- DON'T SUBMIT, COMMIT!
--
-- The purpose of this exercise is to introduce you to some useful
-- mathematic... |
algebraic-stack_agda0000_doc_5295 | {-# OPTIONS --type-in-type #-}
open import Data.Product
data ⊥ : Set where
-- f doesn't type check unless we put the equality type in Set
data _≡_ {ℓ} {A : Set ℓ} (a : A) : A → Set where
refl : a ≡ a
subst : ∀ {ℓ ℓ′} {A : Set ℓ} {a b : A} → (P : A → Set ℓ′) → (p : a ≡ b) → P a → P b
subst _ refl pa = pa
¬_ : ∀ {... |
algebraic-stack_agda0000_doc_4288 | {-# OPTIONS --cubical --safe #-}
-- Counterpoint Exercises
module Exercises where
open import MidiEvent
open import Note
open import Pitch
open import Data.Fin
open import Data.List
open import Data.Nat
-- Exercise 5.4
cantusFirmus : List Pitch
cantusFirmus = a 4 ∷ c 5 ∷ b 4 ∷ c 5 ∷ d 5 ∷ e 5 ∷ c 5 ∷ b 4 ∷ a 4 ∷ ... |
algebraic-stack_agda0000_doc_4289 | module examplesPaperJFP.SpaceShipSimpleVar where
open import SizedIO.Base
open import StateSizedIO.GUI.BaseStateDependent
open import Data.Bool.Base
open import Data.List.Base
open import Data.Integer
open import Data.Product hiding (map)
open import SizedIO.Object
open import SizedIO.IOObject
open import NativeIO
... |
algebraic-stack_agda0000_doc_4290 | -- {-# OPTIONS --no-coverage #-}
-- {-# OPTIONS -v tc.cover:20 #-}
open import Common.Bool
open import Common.Equality
_∨_ : Bool → Bool → Bool
a ∨ b = if a then true else b
module Works where
data Term : Bool → Set where
I : Term false
App : ∀ a b c → a ∨ b ≡ c → Term a → Term b → Term c
-- The follo... |
algebraic-stack_agda0000_doc_4291 | {-# OPTIONS --without-K --safe #-}
open import Algebra
module Data.FingerTree.View
{r m}
(ℳ : Monoid r m)
where
open import Level using (_⊔_)
open import Data.Product
open import Function
open import Data.List as List using (List; _∷_; [])
open import Data.FingerTree.Structures ℳ
open import Data.FingerTree.... |
algebraic-stack_agda0000_doc_4292 | module Logic.Predicate.Multi where
open import Data.Tuple.RaiseTypeᵣ
open import Function.Multi
open import Function.Multi.Functions
open import Numeral.Natural
open import Logic.Predicate
open import Logic
-- Universal quantification of multiple variables.
-- Example:
-- ∀₊(3) P = ∀{x}{y}{z} → P(x)(y)(z)
∀₊ : (n :... |
algebraic-stack_agda0000_doc_4293 | {-# OPTIONS --cubical --safe --no-sized-types --no-guardedness
--no-subtyping #-}
module Agda.Builtin.Cubical.Glue where
open import Agda.Primitive
open import Agda.Builtin.Sigma
open import Agda.Primitive.Cubical renaming (primINeg to ~_; primIMax to _∨_; primIMin to _∧_;
... |
algebraic-stack_agda0000_doc_4294 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.RingSolver.NatAsAlmostRing where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat
open import Cubical.Algebra.RingSolver.AlmostRing
open import Cubical.Algebra.Semigroup
open import Cubical.Algebra.Monoid
open import Cubical.... |
algebraic-stack_agda0000_doc_4295 | open import Nat
open import Prelude
open import core
open import contexts
open import lemmas-consistency
open import type-assignment-unicity
open import binders-disjoint-checks
open import lemmas-subst-ta
module preservation where
-- if d and d' both result from filling the hole in ε with terms of the
-- same ty... |
algebraic-stack_agda0000_doc_4296 | {-# OPTIONS --without-K --safe #-}
module Categories.NaturalTransformation.NaturalIsomorphism.Properties where
open import Level
open import Categories.Category
open import Categories.Category.Instance.Setoids
open import Categories.Functor renaming (id to idF)
open import Categories.Functor.Construction.LiftSetoids... |
algebraic-stack_agda0000_doc_4297 | {-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Implementation.Standard where
module Data where
module Empty where open import Light.Implementation.Standard.Data.Empty public
module Unit where open import Light.Implementation.Standard.Data.Unit public
mod... |
algebraic-stack_agda0000_doc_4298 |
module Oscar.Data where
open import Agda.Builtin.Unit
open import Oscar.Function
open import Oscar.Level
infixr 20 ∷_
infixr 20 _∷_
data NAT : Set where
∅ : NAT
∷_ : NAT → NAT
testNAT : NAT
testNAT = ∷ ∷ ∷ ∅
-- List
data ⟦_⟧ {a} (A : Set a) : Set a where
∅ : ⟦ A ⟧
_∷_ : A → ⟦ A ⟧ → ⟦ A ⟧
-- Nat
⟦⟧ = ⟦ ⊤ ... |
algebraic-stack_agda0000_doc_4299 | open import Agda.Builtin.Nat
record R : Set where
field
x : Nat
open R {{...}}
f₁ f₂ : R
-- This is fine.
x ⦃ f₁ ⦄ = 0
-- THIS WORKS BUT MAKES NO SENSE!!!
f₂ ⦃ .x ⦄ = 0
|
algebraic-stack_agda0000_doc_4300 | {-# POLARITY F #-}
|
algebraic-stack_agda0000_doc_4301 | module Imports.Issue1913-M where
data D : Set where
d : D
|
algebraic-stack_agda0000_doc_4302 | {- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2021 Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.Prelude
open import LibraBFT.Base.PKCS
open import LibraBF... |
algebraic-stack_agda0000_doc_4303 |
module Vehicle.Data.Tensor where
open import Level using (Level)
open import Data.Empty.Polymorphic using (⊥)
open import Data.Nat.Base using (ℕ; zero; suc)
open import Data.List.Base using (List; []; _∷_)
open import Data.Vec.Functional using (Vector)
private
variable
a : Level
A : Set a
n : ℕ
Tensor... |
algebraic-stack_agda0000_doc_5360 | module GUIgeneric.GUIExampleBankAccount where
open import GUIgeneric.Prelude renaming (inj₁ to firstBtn; inj₂ to secondBtn; WxColor to Color;_∸_ to _-_) hiding (addButton; _>>_ ; show)
open import GUIgeneric.GUIDefinitions renaming (add to add'; add' to add)
open import GUIgeneric.GUI
open import GUIgeneric.GUIExa... |
algebraic-stack_agda0000_doc_5361 | -- {-# OPTIONS -v 100 -v tc.meta.name:100 -v interactive.meta:10 #-}
module Issue526 where
-- Don't just write _49,
-- include the corresponding implicit variable name as well (if any)
postulate
f : {A : Set} → {a : A} → Set1 → {B : Set} → Set
test : Set
test = f Set
test₁ : Set
test₁ = f {A = _} Set
postulate
... |
algebraic-stack_agda0000_doc_5362 | module MLib.Prelude.RelProps where
open import MLib.Prelude.FromStdlib
import Relation.Binary.Indexed as I
open FE using (cong)
import Data.Product.Relation.SigmaPropositional as OverΣ
Σ-bij : ∀ {a b c} {A : Set a} {B : A → Set b} {C : A → Set c} → (∀ x → B x ↔ C x) → Σ A B ↔ Σ A C
Σ-bij pw = record
{ to = ≡.→-to-... |
algebraic-stack_agda0000_doc_5363 |
module Imports.A where
postulate A : Set
|
algebraic-stack_agda0000_doc_5364 | module _ where
import Issue1168 ; module I = Issue1168
import PrettyInterface ; module P = PrettyInterface
id : {A : Set} → A → A
id {A = A} a = a
|
algebraic-stack_agda0000_doc_5365 | module Dot where
postulate h : Set
f : Set -> Set -> Set
f .n n = h
|
algebraic-stack_agda0000_doc_5366 | {-# OPTIONS --cubical --no-exact-split --safe #-}
module Cubical.Data.Nat.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat.Base
open import Cubical.Data.Empty
open import Cubical.Data.Prod.Base
open import Cubical.Relation.Nullary
open import ... |
algebraic-stack_agda0000_doc_5367 | {- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2021, Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import Haskell.Modules.RWS.RustAnyHow
import LibraBFT.Impl.Consensu... |
algebraic-stack_agda0000_doc_5368 | module Data.BitVector.ContainmentOrder where
open import Data.Empty
open import Data.Sum
open import Data.Vec
open import Relation.Nullary
open import Relation.Binary
open import Relation.Binary.PropositionalEquality
open import Data.Nat hiding (_≟_; _≤_; _≤?_) renaming (zero to Nzero; suc to Nsuc)
open import Data... |
algebraic-stack_agda0000_doc_5369 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of sums (disjoint unions)
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Sum.Properties where
open import Level
open import D... |
algebraic-stack_agda0000_doc_5370 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Displayed.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Univalence using (pathToEquiv)
... |
algebraic-stack_agda0000_doc_5371 | {-
This file contains:
- the abelianization of groups as a coequalizer of sets as performed
in https://1lab.dev/Algebra.Group.Ab.Free.html
- the proof that this way of defining the abelianization of groups is equivalent to defining
it as a HIT, more precisely that there is a unique isomorphism betw... |
algebraic-stack_agda0000_doc_5372 | module list-to-string where
open import list
open import string
𝕃-to-string : ∀ {ℓ} {A : Set ℓ} → (f : A → string) → (separator : string) → 𝕃 A → string
𝕃-to-string f sep [] = ""
𝕃-to-string f sep (x1 :: (x2 :: xs)) = (f x1) ^ sep ^ (𝕃-to-string f sep (x2 :: xs))
𝕃-to-string f sep (x1 :: []) = (f x1)
|
algebraic-stack_agda0000_doc_5373 |
module AbstractRationals where
open import Algebra
open import Data.Integer.Base using (+0)
open import Data.Maybe.Base using (just; nothing; decToMaybe)
open import Data.Rational.Base as ℚ public hiding (_+_; _*_; _-_)
open import Data.Rational.Properties as ℚ public
using (module ≤-Reasoning; <⇒≤)
open import Re... |
algebraic-stack_agda0000_doc_5374 |
module Issue461 where
data D : Set where
data D : Set where
|
algebraic-stack_agda0000_doc_5375 | {-# OPTIONS --no-auto-inline #-}
module Where where
open import Haskell.Prelude hiding (_+_; _*_; _-_)
open import Agda.Builtin.Nat
postulate
bool2nat : Bool → Nat
-- no outer arguments
ex1 : Nat
ex1 = mult num + bool2nat true
where
num : Nat
num = 42
mult : Nat → Nat
mult = _* 100
-- nested wh... |
algebraic-stack_agda0000_doc_5296 | open import System.IO using ( _>>_ ; putStr ; commit )
open import Data.Natural using ( show )
open import System.IO.Examples.Four using ( four )
module System.IO.Examples.HelloFour where
main = putStr "Hello, " >> putStr (show four) >> putStr ".\n" >> commit
|
algebraic-stack_agda0000_doc_5297 | {-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Monoids.Definition
module Semirings.Definition where
record Semiring {a : _} {A : Set a} (Zero One : A) (_+_ : A → A → A) (_*_ : A → A → A) : Set a where
field
monoid : Monoid Zero _+_
commutative : (a b : A) → a + b... |
algebraic-stack_agda0000_doc_5298 | {-# OPTIONS --type-in-type --rewriting #-}
open import Agda.Builtin.Sigma
open import Agda.Builtin.Equality
coe : {A B : Set} → A ≡ B → A → B
coe refl x = x
{-# BUILTIN REWRITE _≡_ #-}
Tel = Set
U = Set
variable
Δ : Tel
A B : Δ → U
δ₀ δ₁ : Δ
postulate
IdTel : (Δ : Tel)(δ₀ δ₁ : Δ) → Tel
Id : (A : Δ → U){... |
algebraic-stack_agda0000_doc_5299 | {-# OPTIONS --cubical-compatible --rewriting --confluence-check #-}
module Issue1719.Spans where
open import Issue1719.Common
record Span : Set₁ where
constructor span
field
A B C : Set
f : C → A
g : C → B
open Span public
|
algebraic-stack_agda0000_doc_5300 | ------------------------------------------------------------------------
-- Products
------------------------------------------------------------------------
module Data.Product where
open import Data.Function
open import Relation.Nullary.Core
infixr 4 _,_
infix 4 ,_
infixr 2 _×_ _-×-_ _-,-_
----------------------... |
algebraic-stack_agda0000_doc_5301 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Foundations.Equiv.Base where
open import Cubical.Foundations.Function
open import Cubical.Foundations.Prelude
open import Cubical.Core.Glue public
using ( isEquiv ; equiv-proof ; _≃_ ; equivFun ; equivProof )
fiber : ∀ {ℓ ℓ'} {A : Type ℓ} {B : Type ... |
algebraic-stack_agda0000_doc_5302 | module Prelude.List.Base where
open import Prelude.Nat
open import Prelude.Bool
open import Prelude.Maybe
open import Prelude.Product
open import Prelude.Empty
open import Prelude.Function
open import Prelude.Functor
open import Prelude.Applicative
open import Prelude.Monad
open import Prelude.Decidable
open import Pr... |
algebraic-stack_agda0000_doc_5303 | import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; sym; trans; cong; cong-app)
open Eq.≡-Reasoning
open import Data.Nat using (ℕ; zero; suc; _+_; _*_)
open import Data.Product using (∃; _,_)
+-assoc : ∀ (m n p : ℕ) → m + (n + p) ≡ (m + n) + p
+-assoc zero n p =
begin
zero + (n + p)
≡⟨... |
algebraic-stack_agda0000_doc_5304 | module ExportTestAgda where
open import Common.Prelude
itWorksText : String
itWorksText = "It works!"
{-# COMPILED_EXPORT itWorksText itWorksText #-}
|
algebraic-stack_agda0000_doc_5305 | -- There was a bug when unifying things of function type during pattern matching
-- (the T argument to P is unified with D below)
module Issue199 where
data D (A : Set) : Set where
data P {A : Set} : {T : Set → Set} → T A → Set where
p : ∀ d → P {_} {D} d
foo : ∀ {A} {l : D A} → P l → Set₁
foo (p _) = Set
|
algebraic-stack_agda0000_doc_5306 | open import Type
module Relator.Converse {ℓ₁ ℓ₂} {T : Type{ℓ₁}} (_▫_ : T → T → Type{ℓ₂}) where
import Lvl
open import Functional
Converse : T → T → Type{ℓ₂}
Converse = swap(_▫_)
|
algebraic-stack_agda0000_doc_5307 | module Issue4954 where
open import Issue4954.M Set
|
algebraic-stack_agda0000_doc_5308 | module Relator.Ordering.Proofs where
open import Data
import Lvl
open import Functional
open import Lang.Instance
open import Logic
open import Logic.Classical
open import Logic.Propositional
open import Logic.Propositional.Theorems
open import Type
import Relator.Ordering
open import Structure.Relator.Order... |
algebraic-stack_agda0000_doc_5309 |
module HasSatisfaction where
open import OscarPrelude
open import Interpretation
record HasSatisfaction (A : Set) : Set₁
where
field
_⊨_ : Interpretation → A → Set
_⊭_ : Interpretation → A → Set
_⊭_ I = ¬_ ∘ I ⊨_
open HasSatisfaction ⦃ … ⦄ public
{-# DISPLAY HasSatisfaction._⊨_ _ = _⊨_ #-}
{-# DISPLAY ... |
algebraic-stack_agda0000_doc_5310 | {-# OPTIONS --without-K --safe #-}
open import Algebra
open import Relation.Unary
open import Relation.Binary hiding (Decidable)
module Data.FingerTree.Split.Intermediate
{r m}
(ℳ : Monoid r m)
{s}
{ℙ : Pred (Monoid.Carrier ℳ) s}
(ℙ-resp : ℙ Respects (Monoid._≈_ ℳ))
(ℙ? : Decidable ℙ)
where
open import... |
algebraic-stack_agda0000_doc_5311 | {-# OPTIONS --safe #-}
module Cubical.Algebra.AbGroup.Instances.Unit where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Data.Unit renaming (Unit* to UnitType)
open import Cubical.Algebra.AbGroup
open import Cubical.Algebra.Group.Instances.Unit using (UnitGroup)
... |
algebraic-stack_agda0000_doc_5248 | {-# OPTIONS --universe-polymorphism #-}
module Categories.Profunctor where
open import Level hiding (lift)
open import Categories.Category
open import Categories.Agda
open import Categories.Bifunctor using (Functor; Bifunctor; _∘_)
open import Categories.Functor.Hom
open import Categories.Lan
open import Categories.Y... |
algebraic-stack_agda0000_doc_5249 | {-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Properties.Reduction {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.RedSteps
open i... |
algebraic-stack_agda0000_doc_5250 | open import Data.String using ( String )
open import Data.List.Primitive using ( #List )
open import Data.Maybe.Primitive using ( #Maybe )
open import Web.URI.Port.Primitive using ( Port? )
open import Web.URI.Scheme.Primitive using ( Scheme? )
module Web.URI.Primitive where
{-# IMPORT Data.Maybe #-}
{-# IMPORT Web.UR... |
algebraic-stack_agda0000_doc_5251 |
open import Oscar.Prelude
open import Oscar.Class.IsPrefunctor
open import Oscar.Class.Smap
open import Oscar.Class.Surjection
open import Oscar.Class.Transitivity
module Oscar.Class.Prefunctor where
record Prefunctor 𝔬₁ 𝔯₁ ℓ₁ 𝔬₂ 𝔯₂ ℓ₂ : Ø ↑̂ (𝔬₁ ∙̂ 𝔯₁ ∙̂ ℓ₁ ∙̂ 𝔬₂ ∙̂ 𝔯₂ ∙̂ ℓ₂) where
constructor ∁
field
... |
algebraic-stack_agda0000_doc_5252 | module Negative5 where
data Funny (A : Set) : Set where
funny : A -> Funny (Funny A -> A) -> Funny A
|
algebraic-stack_agda0000_doc_5253 |
module _ where
-- Check that previous clauses reduce in later ones
open import Agda.Builtin.Nat hiding (_==_)
record Σ (A : Set) (B : A → Set) : Set where
field
fst : A
snd : B fst
open Σ
postulate
T : Nat → Set
mkT : ∀ n → T n
t5 : Σ Nat T
fst t5 = 5
snd t5 = mkT 5
-- Also with instance projectio... |
algebraic-stack_agda0000_doc_5254 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Natural numbers represented in binary.
------------------------------------------------------------------------
-- This module aims to create an alternative formulation of ℕ that is
-- still reasonably computati... |
algebraic-stack_agda0000_doc_5255 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Convenient syntax for reasoning with a setoid
------------------------------------------------------------------------
-- Example use:
-- n*0≡0 : ∀ n → n * 0 ≡ 0
-- n*0≡0 zero = refl
-- n*0≡0 (suc n) = begin... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.