id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_5256 | module bee2 where
open import Bee2.Crypto.Belt
open import Data.ByteString.Utf8
open import Data.ByteString.IO
open import Data.String using (toList)
open import Data.Product using (proj₁)
open import IO
-- beltPBKDF : Password → ℕ → Salt → Kek
main = run (writeBinaryFile "pbkdf2" (proj₁ (beltPBKDF (packStrict "zed... |
algebraic-stack_agda0000_doc_5257 | {-# OPTIONS --without-K --safe #-}
module Dodo.Binary.Union where
-- Stdlib imports
open import Level using (Level; _⊔_)
open import Data.Sum using (_⊎_; inj₁; inj₂; swap)
open import Relation.Binary using (REL)
-- Local imports
open import Dodo.Binary.Equality
-- # Definitions
infixl 19 _∪₂_
_∪₂_ : {a b ℓ₁ ℓ₂ : ... |
algebraic-stack_agda0000_doc_5258 | postulate
F : @0 Set → Set
G : @0 Set → Set
G A = F (λ { → A })
|
algebraic-stack_agda0000_doc_5259 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import cohomology.Theory
open import homotopy.PushoutSplit
open import cw.CW
module cw.cohomology.WedgeOfCells {i} (OT : OrdinaryTheory i)
{n} (⊙skel : ⊙Skeleton {i} (S n)) where
open OrdinaryTheory OT
open import cohomology.Bouquet OT
open import cw.We... |
algebraic-stack_agda0000_doc_5260 | {-# OPTIONS --safe --without-K #-}
module Literals.Number where
open import Agda.Builtin.FromNat public
open Number ⦃ ... ⦄ public
|
algebraic-stack_agda0000_doc_5261 | module StateSizedIO.Base where
open import Size
open import SizedIO.Base
open import Data.Product
record IOInterfaceˢ : Set₁ where
field
IOStateˢ : Set
Commandˢ : IOStateˢ → Set
Responseˢ : (s : IOStateˢ) → (m : Commandˢ s) → Set
IOnextˢ : (s : IOStateˢ) → (m : Commandˢ s) → (Responseˢ... |
algebraic-stack_agda0000_doc_5262 | module Untyped.Abstract where
open import Function
open import Data.String
open import Data.Nat
open import Data.Unit
open import Data.Product
open import Data.List
open import Data.Sum as Sum
open import Data.Maybe
open import Strict
open import Debug.Trace
open import Category.Monad
open import Untyped.Monads
po... |
algebraic-stack_agda0000_doc_5263 | -- Andreas, 2011-05-09
-- {-# OPTIONS -v tc.inj:40 -v tc.meta:30 #-}
module Issue383b where
postulate
Σ : (A : Set) → (A → Set) → Set
U : Set
El : U → Set
mutual
data Ctxt : Set where
_▻_ : (Γ : Ctxt) → (Env Γ → U) → Ctxt
Env : Ctxt → Set
Env (Γ ▻ σ) = Σ (Env Γ) λ γ → El (σ γ)
postulate
Δ : Ctx... |
algebraic-stack_agda0000_doc_6944 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Examples showing how the reflective ring solver may be used.
------------------------------------------------------------------------
module README.Tactic.RingSolver where
-- You can ignore this bit! We're just... |
algebraic-stack_agda0000_doc_6945 | {-# OPTIONS --sized-types #-}
-- {-# OPTIONS -v tc.size.solve:100 -v tc.meta.new:50 #-}
module CheckSizeMetaBounds where
open import Common.Size
postulate
Size< : (_ : Size) → Set
{-# BUILTIN SIZELT Size< #-}
data Nat {i : Size} : Set where
zero : Nat
suc : {j : Size< i} → Nat {j} → Nat
one : Nat
one = suc {... |
algebraic-stack_agda0000_doc_6946 | -- The bug documented below was exposed by the fix to issue 274.
module Issue274 where
open import Common.Level
record Q a : Set (a ⊔ a) where
record R a : Set a where
field q : Q a
A : Set₁
A = Set
postulate
ℓ : Level
r : R (ℓ ⊔ ℓ)
foo : R ℓ
foo = r
-- Issue274.agda:32,7-8
-- ℓ ⊔ ℓ !=< ℓ of type Leve... |
algebraic-stack_agda0000_doc_6947 | {-# OPTIONS --copatterns #-}
module SplitResult where
open import Common.Product
test : {A B : Set} (a : A) (b : B) → A × B
test a b = {!!}
-- expected:
-- proj₁ (test a b) = {!!}
-- proj₂ (test a b) = {!!}
testFun : {A B : Set} (a : A) (b : B) → A × B
testFun = {!!}
-- expected:
-- testFun a b = {!!}
record FunRe... |
algebraic-stack_agda0000_doc_6948 | {-# OPTIONS --without-K --rewriting #-}
module lib.types.Suspension where
open import lib.types.Suspension.Core public
open import lib.types.Suspension.Flip public
open import lib.types.Suspension.Iterated public
open import lib.types.Suspension.IteratedFlip public
open import lib.types.Suspension.IteratedTrunc publi... |
algebraic-stack_agda0000_doc_6949 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Rational numbers
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Rational where
open import Data.Integer as ℤ using (ℤ; +_)
open import D... |
algebraic-stack_agda0000_doc_6950 | module Data.Num.Redundant.Properties where
open import Data.Num.Bij
open import Data.Num.Redundant renaming (_+_ to _+R_)
open import Data.Nat renaming (_<_ to _<ℕ_)
open import Data.Nat.Etc
open import Data.Nat.Properties.Simple
open import Data.Sum
open import Data.List hiding ([_])
open import Relation.Nullary
op... |
algebraic-stack_agda0000_doc_6951 | -- Andreas, 2018-03-03, issue #2989
-- Internal error, fixable with additional 'reduce'.
-- {-# OPTIONS --show-implicit --show-irrelevant #-}
-- {-# OPTIONS -v tc.rec:70 -v tc:10 #-}
postulate
N : Set
P : N → Set
record Σ (A : Set) (B : A → Set) : Set where
constructor pair
field
fst : A
snd : B fst
... |
algebraic-stack_agda0000_doc_6952 |
module Derivative where
open import Sets
open import Functor
import Isomorphism
∂ : U -> U
∂ (K A) = K [0]
∂ Id = K [1]
∂ (F + G) = ∂ F + ∂ G
∂ (F × G) = ∂ F × G + F × ∂ G
open Semantics
-- Plugging a hole
plug-∂ : {X : Set}(F : U) -> ⟦ ∂ F ⟧ X -> X -> ⟦ F ⟧ X
plug-∂ (K _) () x
pl... |
algebraic-stack_agda0000_doc_6953 | {-# OPTIONS --safe #-}
module Cubical.Algebra.CommAlgebra where
open import Cubical.Algebra.CommAlgebra.Base public
open import Cubical.Algebra.CommAlgebra.Properties public
|
algebraic-stack_agda0000_doc_6954 | -- Andreas, 2012-01-12
module Common.Irrelevance where
open import Common.Level
postulate
.irrAxiom : ∀ {a}{A : Set a} → .A → A
{-# BUILTIN IRRAXIOM irrAxiom #-}
record Squash {a}(A : Set a) : Set a where
constructor squash
field
.unsquash : A
open Squash public
|
algebraic-stack_agda0000_doc_6955 | -- define ∑ and ∏ as the bigOps of a Ring when interpreted
-- as an additive/multiplicative monoid
{-# OPTIONS --safe #-}
module Cubical.Algebra.Ring.BigOps where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Data.Bool
open import Cubical.Data.Nat using (ℕ ; zer... |
algebraic-stack_agda0000_doc_6956 | module UpTo where
open import Level
open import Relation.Binary using (Rel; IsEquivalence)
open import Data.Product
open import Categories.Support.Equivalence
open import Categories.Category
open import Categories.2-Category
open import Categories.Functor
open import Categories.NaturalTransformation
renaming (id to ... |
algebraic-stack_agda0000_doc_6957 |
open import Oscar.Prelude
open import Oscar.Class.IsDecidable
open import Oscar.Data.Fin
open import Oscar.Data.Decidable
open import Oscar.Data.Proposequality
module Oscar.Class.IsDecidable.Fin where
instance
IsDecidableFin : ∀ {n} → IsDecidable (Fin n)
IsDecidableFin .IsDecidable._≟_ ∅ ∅ = ↑ ∅
IsDecidableFi... |
algebraic-stack_agda0000_doc_6958 | ------------------------------------------------------------------------------
-- Even predicate
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --... |
algebraic-stack_agda0000_doc_6959 | {-# OPTIONS --without-K --safe #-}
module Categories.Category.Instance.LawvereTheories where
-- Category of Lawvere Theories
open import Level
open import Categories.Category.Core using (Category)
open import Categories.Functor.Cartesian using (CartesianF)
open import Categories.NaturalTransformation.NaturalIsomorph... |
algebraic-stack_agda0000_doc_6768 | ------------------------------------------------------------------------------
-- Testing the η-expansion
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# O... |
algebraic-stack_agda0000_doc_6769 | module Text.Greek.SBLGNT.Mark where
open import Data.List
open import Text.Greek.Bible
open import Text.Greek.Script
open import Text.Greek.Script.Unicode
ΚΑΤΑ-ΜΑΡΚΟΝ : List (Word)
ΚΑΤΑ-ΜΑΡΚΟΝ =
word (Ἀ ∷ ρ ∷ χ ∷ ὴ ∷ []) "Mark.1.1"
∷ word (τ ∷ ο ∷ ῦ ∷ []) "Mark.1.1"
∷ word (ε ∷ ὐ ∷ α ∷ γ ∷ γ ∷ ε ∷ ∙λ ∷ ί ∷ ο ... |
algebraic-stack_agda0000_doc_6770 | {-# OPTIONS --without-K #-}
module FinNatLemmas where
open import Data.Empty using (⊥-elim)
open import Data.Product using (_×_; _,_)
open import Data.Nat
using (ℕ; zero; suc; _+_; _*_; _<_; _≤_; _∸_; z≤n; s≤s; module ≤-Reasoning)
open import Data.Nat.Properties
using (m+n∸n≡m; m≤m+n; +-∸-assoc; cancel-+-left)
o... |
algebraic-stack_agda0000_doc_6771 | open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
test : (A : Set) (let X = _) (x : X) (p : A ≡ Bool) → Bool
test .Bool true refl = false
test .Bool false refl = true
|
algebraic-stack_agda0000_doc_6772 | -- Andreas, 2014-09-23
-- Syntax declaration for overloaded constructor.
module _ where
module A where
syntax c x = ⟦ x ⟧
data D2 (A : Set) : Set where
c : A → D2 A
data D1 : Set where
c : D1
open A
test : D2 D1
test = ⟦ c ⟧
-- Should work.
|
algebraic-stack_agda0000_doc_6773 | module Issue1419 where
module A where
module M where
module B where
module M where
open A
open B
module N (let open M) where
module LotsOfStuff where
|
algebraic-stack_agda0000_doc_6774 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- A simple example of a program using the foreign function interface
------------------------------------------------------------------------
module README.Foreign.Haskell where
-- In order to be considered safe ... |
algebraic-stack_agda0000_doc_6775 | {-# OPTIONS --sized-types #-}
module Sized.Data.List where
import Lvl
open import Lang.Size
open import Type
private variable ℓ ℓ₁ ℓ₂ : Lvl.Level
private variable T A A₁ A₂ B B₁ B₂ Result : Type{ℓ}
private variable s s₁ s₂ : Size
data List(s : Size){ℓ} (T : Type{ℓ}) : Type{ℓ} where
∅ : List(s)(T) -- An emp... |
algebraic-stack_agda0000_doc_6776 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
{- The cofiber space of [winl : X → X ∨ Y] is equivalent to [Y],
- and the cofiber space of [winr : Y → X ∨ Y] is equivalent to [X]. -}
module homotopy.WedgeCofiber {i} (X Y : Ptd i) where
module CofWinl where
module Into = CofiberRec {f = winl} (pt Y... |
algebraic-stack_agda0000_doc_6777 |
module Issue1278.A (X : Set1) where
data D : Set where
d : D
|
algebraic-stack_agda0000_doc_6778 | -- Combinators for logical reasoning
{-# OPTIONS --without-K --safe --exact-split #-}
module Constructive.Combinators where
-- agda-stdlib
open import Data.Empty
open import Data.Sum as Sum
open import Data.Product as Prod
open import Function.Base
open import Relation.Nullary using (¬_; Dec; yes; no)
open import Rel... |
algebraic-stack_agda0000_doc_6779 | module Sessions.Semantics.Commands where
open import Prelude
open import Data.Fin
open import Sessions.Syntax.Types
open import Sessions.Syntax.Values
mutual
data Cmd : Pred RCtx 0ℓ where
fork : ∀[ Comp unit ⇒ Cmd ]
mkchan : ∀ α → ε[ Cmd ]
send : ∀ {a α} → ∀[ (Endptr (a ! α) ... |
algebraic-stack_agda0000_doc_6780 | {-# OPTIONS --cubical --safe #-}
module Relation.Nullary.Decidable.Properties where
open import Relation.Nullary.Decidable
open import Level
open import Relation.Nullary.Stable
open import Data.Empty
open import HLevels
open import Data.Empty.Properties using (isProp¬)
open import Data.Unit
open import Data.Empty
De... |
algebraic-stack_agda0000_doc_6781 |
-- Semantics of syntactic traversal and substitution
module Semantics.Substitution.Traversal where
open import Syntax.Types
open import Syntax.Context renaming (_,_ to _,,_)
open import Syntax.Terms
open import Syntax.Substitution.Kits
open import Syntax.Substitution.Instances
open import Semantics.Types
open import... |
algebraic-stack_agda0000_doc_6782 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Endomorphisms on a Set
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Function.Endomorphism.Propositional {a} (A : Set a) where
open import A... |
algebraic-stack_agda0000_doc_6783 | -- MIT License
-- Copyright (c) 2021 Luca Ciccone and Luca Padovani
-- Permission is hereby granted, free of charge, to any person
-- obtaining a copy of this software and associated documentation
-- files (the "Software"), to deal in the Software without
-- restriction, including without limitation the rights to use... |
algebraic-stack_agda0000_doc_14672 | {-# OPTIONS --without-K #-}
module Util.HoTT.Univalence.Axiom where
open import Util.HoTT.Equiv
open import Util.HoTT.Univalence.Statement
open import Util.Prelude
open import Util.Relation.Binary.PropositionalEquality using (Σ-≡⁻)
private
variable
α β γ : Level
A B C : Set α
postulate
univalence : ∀ {... |
algebraic-stack_agda0000_doc_14673 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- IO
------------------------------------------------------------------------
module IO where
open import Coinduction
open import Data.Unit
open import Data.String
open import Data.Colist
open import Function
imp... |
algebraic-stack_agda0000_doc_14674 | -- {-# OPTIONS -v tc.cover.cover:10 -v tc.cover.splittree:100 -v tc.cover.strategy:100 -v tc.cc:100 #-}
module Issue365 where
{- Basic data types -}
data Nat : Set where
zero : Nat
succ : Nat -> Nat
data Fin : Nat -> Set where
fzero : {n : Nat} -> Fin (succ n)
fsucc : {n : Nat} -> Fin n -> Fin (succ n)
data Vec... |
algebraic-stack_agda0000_doc_14675 | module Operator.Equals {ℓ} where
import Lvl
open import Data.Boolean
open import Functional
open import Relator.Equals{ℓ}
open import Type{ℓ}
-- Type class for run-time checking of equality
record Equals(T : Type) : Type where
infixl 100 _==_
field
_==_ : T → T → Bool
field
⦃ completeness ⦄ : ∀{a b... |
algebraic-stack_agda0000_doc_14676 | open import Data.Product using ( ∃ ; _×_ ; _,_ ; proj₁ ; proj₂ )
open import Relation.Unary using ( _∈_ )
open import Web.Semantic.DL.TBox.Interp using ( Δ ; _⊨_≈_ ) renaming
( Interp to Interp′ ; emp to emp′ )
open import Web.Semantic.DL.Signature using ( Signature )
open import Web.Semantic.Util using ( False ; id... |
algebraic-stack_agda0000_doc_14677 | {-# OPTIONS --cubical #-}
module Cubical.Categories.Everything where
import Cubical.Categories.Category
import Cubical.Categories.Functor
import Cubical.Categories.NaturalTransformation
import Cubical.Categories.Presheaves
import Cubical.Categories.Sets
import Cubical.Categories.Type
|
algebraic-stack_agda0000_doc_14678 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Vectors defined by recursion
------------------------------------------------------------------------
-- What is the point of this module? The n-ary products below are intended
-- to be used with a fixed n, in w... |
algebraic-stack_agda0000_doc_14679 | open import Prelude
open import RW.Utils.Monads
-- Some Error monad utilities, a là Haskell.
module RW.Utils.Error where
open import Data.String
open Monad {{...}}
-- Error Typeclass
record IsError {a}(A : Set a) : Set a where
field
showError : A → String
open IsError {{...}}
instance
... |
algebraic-stack_agda0000_doc_14680 | -- Andreas, 2018-04-10, issue #3581, reported by 3abc, test case by Andrea
-- Regression in the termination checker introduced together
-- with collecting function calls also in the type signatures
-- (fix of #1556).
open import Agda.Builtin.Bool
open import Agda.Builtin.Nat
I = Bool
i0 = true
i1 = false
record Pat... |
algebraic-stack_agda0000_doc_14681 | ------------------------------------------------------------------------------
-- Testing Agda internal terms: @Var Nat Args@ when @Args = []@
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS... |
algebraic-stack_agda0000_doc_14682 | {-# OPTIONS --universe-polymorphism #-}
module Categories.Groupoid where
open import Level
open import Categories.Category
import Categories.Morphisms
record Groupoid {o ℓ e} (C : Category o ℓ e) : Set (o ⊔ ℓ ⊔ e) where
private module C = Category C
open C using (_⇒_)
open Categories.Morphisms C
field
... |
algebraic-stack_agda0000_doc_14683 | ------------------------------------------------------------------------
-- Lemmas
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --exact-split #-}
module Math.Combinatorics.ListFunction.Properties.Lemma where
open import Data.List hiding (_∷ʳ_)
import Data.Li... |
algebraic-stack_agda0000_doc_14684 |
module _ where
open import Agda.Builtin.Equality using (_≡_; refl)
-- First example --
module M (A : Set) where
record R : Set where
data D : Set where
open R (record {})
postulate
x : A
F : D → Set₁
F _ rewrite refl {x = x} = Set
-- Second example --
record ⊤ : Set where
no-eta-equality
... |
algebraic-stack_agda0000_doc_14685 | {-# OPTIONS --sized-types #-}
open import FRP.JS.Bool using ( Bool ; true ; false ) renaming ( _≟_ to _≟b_ )
open import FRP.JS.Nat using ( ℕ )
open import FRP.JS.Float using ( ℝ ) renaming ( _≟_ to _≟n_ )
open import FRP.JS.String using ( String ) renaming ( _≟_ to _≟s_ )
open import FRP.JS.Array using ( Array ) rena... |
algebraic-stack_agda0000_doc_14686 | -- Testing the version option on a file with errors.
--
-- N.B. It is necessary to change the Issue1244a.out file when using
-- different versions of Agda.
foo : Set → Set
foo a = b
|
algebraic-stack_agda0000_doc_14687 | module Luau.Addr where
open import Agda.Builtin.Bool using (true; false)
open import Agda.Builtin.Equality using (_≡_)
open import Agda.Builtin.Nat using (Nat; _==_)
open import Agda.Builtin.String using (String)
open import Agda.Builtin.TrustMe using (primTrustMe)
open import Properties.Dec using (Dec; yes; no)
open ... |
algebraic-stack_agda0000_doc_14320 | {-# OPTIONS --rewriting #-}
open import Common.Prelude
open import Common.Equality
{-# BUILTIN REWRITE _≡_ #-}
postulate
f g : Nat → Nat
f-zero : f zero ≡ g zero
f-suc : ∀ n → f n ≡ g n → f (suc n) ≡ g (suc n)
r : (n : Nat) → f n ≡ g n
r zero = f-zero
r (suc n) = f-suc n refl
where
rn : f n ≡ g n
... |
algebraic-stack_agda0000_doc_14321 | {-# OPTIONS --cubical-compatible #-}
module Common.Equality where
open import Agda.Builtin.Equality public
open import Common.Level
subst : ∀ {a p}{A : Set a}(P : A → Set p){x y : A} → x ≡ y → P x → P y
subst P refl t = t
cong : ∀ {a b}{A : Set a}{B : Set b}(f : A → B){x y : A} → x ≡ y → f x ≡ f y
cong f refl = refl... |
algebraic-stack_agda0000_doc_14322 |
module _ {T : Type{ℓₒ}} ⦃ equiv : Equiv{ℓₑ}(T) ⦄ where
instance
PredSet-setLike : SetLike{C = PredSet{ℓ}(T) ⦃ equiv ⦄} (_∈_)
SetLike._⊆_ PredSet-setLike = _⊆_
SetLike._≡_ PredSet-setLike = _≡_
SetLike.[⊆]-membership PredSet-setLike = [↔]-intro intro _⊆_.proof
SetLike.[≡]-membership PredSet-setLik... |
algebraic-stack_agda0000_doc_14323 | {-# OPTIONS --cubical --safe #-}
module Cubical.Structures.CommRing where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Data.Sigma
open import Cubical.Foundations.SIP renaming (SNS-PathP to SNS)
open import Cubical.Structures... |
algebraic-stack_agda0000_doc_14324 | {-# OPTIONS --cubical #-}
open import Cubical.Core.Glue
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Nat
open import Cubical.Data.Empty
open import Cubical.Data.Unit
open imp... |
algebraic-stack_agda0000_doc_14325 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use `Data.Vec.Functional` instead.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
-- Disabled to prevent warnings f... |
algebraic-stack_agda0000_doc_14326 |
open import Oscar.Prelude
open import Oscar.Class
open import Oscar.Class.Unit
open import Oscar.Class.Leftunit
module Oscar.Class.Leftunit.ToUnit where
module _
{𝔞} {𝔄 : Ø 𝔞} {𝔢} {𝔈 : Ø 𝔢} {ℓ}
{_↦_ : 𝔄 → 𝔄 → Ø ℓ} (let _↦_ = _↦_; infix 4 _↦_)
{ε : 𝔈}
{_◃_ : 𝔈 → 𝔄 → 𝔄} (let _◃_ = _◃_; infix 16 _◃_... |
algebraic-stack_agda0000_doc_14327 | module Lectures.One where
-- Check background color
-- Check fontsize
-- Ask questions at *any* time
data ⊤ : Set where
tt : ⊤
data ⊥ : Set where
absurd : ⊥ → {P : Set} → P
absurd ()
-- Introduce most common key bindings
-- C-c C-l load
-- C-c C-, show context
-- C-c C-. show context + type
-- C-c C-... |
algebraic-stack_agda0000_doc_14328 | {-# OPTIONS --without-K --exact-split --allow-unsolved-metas #-}
module 13-propositional-truncation where
import 12-univalence
open 12-univalence public
-- Section 13 Propositional truncations, the image of a map, and the replacement axiom
-- Section 13.1 Propositional truncations
-- Definition 13.1.1
type-hom-Pr... |
algebraic-stack_agda0000_doc_14329 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Convenient syntax for reasoning with a partial setoid
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
module Relation.Bin... |
algebraic-stack_agda0000_doc_14330 |
module Issue1232.Fin where
data Fin : Set where
zero : Fin
|
algebraic-stack_agda0000_doc_14331 | {- 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
-}
import LibraBFT.Impl.Consensus.ConsensusTypes.Vote as Vote
... |
algebraic-stack_agda0000_doc_14332 | {-# OPTIONS --without-K --safe #-}
module Polynomial.Simple.AlmostCommutativeRing where
import Algebra.Solver.Ring.AlmostCommutativeRing as Complex
open import Level
open import Relation.Binary
open import Algebra
open import Algebra.Structures
open import Algebra.FunctionProperties
import Algebra.Morphism as Morphis... |
algebraic-stack_agda0000_doc_14333 | {-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NType2
open import lib.types.Bool
open import lib.types.Empty
open import lib.types.Paths
open import lib.types.Pi
open import lib.types.Sigma
{-
This file contains various lemmas that rely on lib.types.Paths or
functional extensionality f... |
algebraic-stack_agda0000_doc_14334 | open import Signature
-- | One signature for terms and one for predicates.
module Logic (Σ Δ : Sig) (V : Set) where
open import Data.Empty renaming (⊥ to Ø)
open import Data.Unit
open import Data.Sum
open import Data.Product renaming (Σ to ∐)
open import Data.Nat
open import Data.Fin
FinSet : Set → Set
FinSet X = ∃ ... |
algebraic-stack_agda0000_doc_14335 | -- Andreas, 2017-01-24, issue #2429
-- Respect subtyping also for irrelevant lambdas!
-- Subtyping: (.A → B) ≤ (A → B)
-- Where a function is expected, we can put one which does not use its argument.
id : ∀{A B : Set} → (.A → B) → A → B
id f = f
test : ∀{A B : Set} → (.A → B) → A → B
test f = λ .a → f a
-- Should w... |
algebraic-stack_agda0000_doc_6512 | {-# OPTIONS --cubical --safe #-}
module Function.Surjective.Base where
open import Path
open import Function.Fiber
open import Level
open import HITs.PropositionalTruncation
open import Data.Sigma
Surjective : (A → B) → Type _
Surjective f = ∀ y → ∥ fiber f y ∥
SplitSurjective : (A → B) → Type _
SplitSurjective f =... |
algebraic-stack_agda0000_doc_6513 | module T where
postulate x : Set
postulate y : Set
postulate p : Set -> Set
e : Set
e = p y
|
algebraic-stack_agda0000_doc_6514 | open import Agda.Builtin.Reflection
open import Agda.Builtin.Unit
@0 A : Set₁
A = Set
macro
@0 m : Term → TC ⊤
m B =
bindTC (quoteTC A) λ A →
unify A B
B : Set₁
B = m
|
algebraic-stack_agda0000_doc_6515 |
module Prelude.Bool where
open import Prelude.Unit
open import Prelude.Empty
open import Prelude.Equality
open import Prelude.Decidable
open import Prelude.Function
open import Agda.Builtin.Bool public
infix 0 if_then_else_
if_then_else_ : ∀ {a} {A : Set a} → Bool → A → A → A
if true then x else y = x
if false the... |
algebraic-stack_agda0000_doc_6516 | module Prelude.Char where
open import Prelude.Bool
postulate
Char : Set
{-# BUILTIN CHAR Char #-}
private
primitive
primCharEquality : (c c' : Char) -> Bool
postulate
eof : Char
{-# COMPILED_EPIC eof () -> Int = foreign Int "eof" () #-}
charEq : Char -> Char -> Bool
charEq = primCharEquality
|
algebraic-stack_agda0000_doc_6517 | -- Andreas, 2018-06-15, issue #1086
-- Reported by Andrea
-- Fixed by Jesper in https://github.com/agda/agda/commit/242684bca62fabe43e125aefae7526be4b26a135
open import Common.Bool
open import Common.Equality
and : (a b : Bool) → Bool
and true b = b
and false b = false
test : ∀ a b → and a b ≡ true → a ≡ true
test ... |
algebraic-stack_agda0000_doc_6518 | ------------------------------------------------------------------------
-- Encoder and decoder instances for Atom.χ-ℕ-atoms
------------------------------------------------------------------------
module Coding.Instances.Nat where
open import Atom
-- The code-Var and code-Const instances are hidden: they are replac... |
algebraic-stack_agda0000_doc_6519 | {-# OPTIONS --warning=error --without-K --guardedness --safe #-}
open import LogicalFormulae
open import Numbers.Naturals.Definition
open import Setoids.Setoids
open import Numbers.Naturals.Order
open import Vectors
module Sequences where
record Sequence {a : _} (A : Set a) : Set a where
coinductive
field
he... |
algebraic-stack_agda0000_doc_6520 | {-
Properties and Formulae about Cardinality
This file contains:
- Relation between abstract properties and cardinality in special cases;
- Combinatorial formulae, namely, cardinality of A+B, A×B, ΣAB, ΠAB, etc;
- A general form of Pigeonhole Principle;
- Maximal value of numerical function on finite sets;
- Set trun... |
algebraic-stack_agda0000_doc_6521 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Decidable setoid membership over vectors.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (DecSetoid)
module Data.V... |
algebraic-stack_agda0000_doc_6522 | module _ where
open import Agda.Primitive.Cubical
postulate
PathP : ∀ {ℓ} (A : I → Set ℓ) → A i0 → A i1 → Set ℓ
{-# BUILTIN PATHP PathP #-}
|
algebraic-stack_agda0000_doc_6523 | module #8 where
{-
Define multiplication and exponentiation using recN. Verify that (N, +, 0, ×, 1) is
a semiring using only indN. You will probably also need to use symmetry and transitivity of
equality, Lemmas 2.1.1 and 2.1.2.
-}
open import Data.Nat
recₙ : ∀{c}{C : Set c} → C → (ℕ → C → C) → ℕ → C
recₙ c₀ c... |
algebraic-stack_agda0000_doc_6524 | ---------------------------------------
-- Pairs of sets
---------------------------------------
{-# OPTIONS --allow-unsolved-meta #-}
module sv20.assign2.SetTheory.Pairs where
-- Everything involving pairs, be them unordered
-- or ordered pairs. Also the definition of power set
-- and cartesian product between sets... |
algebraic-stack_agda0000_doc_6525 |
postulate
A : Set
I : ..(_ : A) → Set
R : A → Set
f : ∀ ..(x : A) (r : R x) → I x
-- can now be used here ^
|
algebraic-stack_agda0000_doc_6526 | module examplesPaperJFP.VariableListForDispatchOnly 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 → VarLi... |
algebraic-stack_agda0000_doc_6527 | {-# OPTIONS --without-K #-}
open import lib.Basics
{-
The generic nonrecursive higher inductive type with one point constructor and
one paths constructor.
-}
module lib.types.Generic1HIT {i j} (A : Type i) (B : Type j)
(g h : B → A) where
{-
data T : Type where
cc : A → T
pp : (b : B) → cc (f' b) ≡ cc (g b)
... |
algebraic-stack_agda0000_doc_15104 | -- Problem 2: Multiplication for matrices (from the matrix algebra DSL).
module P2 where
-- 2a: Type the variables in the text.
-- (This answer uses Agda syntax, but that is not required.)
postulate Nat : Set
postulate V : Nat -> Set -> Set
postulate Fin : Nat -> Set
Op : Set -> Set
Op a = a -> a -> a
postulate su... |
algebraic-stack_agda0000_doc_15105 | {-# OPTIONS --without-K --safe #-}
module C where
open import Data.Empty
open import Data.Unit
open import Data.Sum
open import Data.Product
open import Relation.Binary.PropositionalEquality
open import Singleton
infixr 70 _×ᵤ_
infixr 60 _+ᵤₗ_
infixr 60 _+ᵤᵣ_
infixr 50 _⊚_
-----------------------------------------... |
algebraic-stack_agda0000_doc_15106 | {-# OPTIONS --universe-polymorphism #-}
module Categories.Product where
open import Level
open import Function using () renaming (_∘_ to _∙_)
open import Data.Product using (_×_; Σ; _,_; proj₁; proj₂; zip; map; <_,_>; swap)
open import Categories.Category
private
map⁎ : ∀ {a b p q} {A : Set a} {B : A → Set b} {P :... |
algebraic-stack_agda0000_doc_15107 | open import Nat
open import Prelude
open import List
open import core
open import judgemental-erase
open import sensibility
open import moveerase
module checks where
-- these three judmgements lift the action semantics judgements to relate
-- an expression and a list of pair-wise composable actions to the
-- exp... |
algebraic-stack_agda0000_doc_15108 | {-# OPTIONS --no-import-sorts #-}
open import Agda.Primitive renaming (Set to _X_X_)
test : _X_X₁_
test = _X_X_
|
algebraic-stack_agda0000_doc_15109 | {-# OPTIONS --without-K #-}
open import Agda.Primitive using (Level; lsuc)
open import Relation.Binary.PropositionalEquality.Core using (_≡_; cong)
open import Data.Empty using (⊥; ⊥-elim)
open import Data.Product using (proj₁; proj₂; Σ-syntax; _,_)
open import Function.Base using (_∘_)
variable
ℓ ℓ′ : Level
A C ... |
algebraic-stack_agda0000_doc_15110 | {-# OPTIONS --cubical --safe #-}
module Cubical.Homotopy.Loopspace where
open import Cubical.Core.Everything
open import Cubical.Data.Nat
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed
open import Cubical.Foundations.GroupoidLaws
{- loop space of a pointed type -}
Ω : {ℓ : Level} →... |
algebraic-stack_agda0000_doc_15111 | module Sets.ImageSet.Oper where
open import Data
open import Functional
open import Logic
open import Logic.Propositional
open import Logic.Predicate
import Lvl
open import Sets.ImageSet
open import Structure.Function
open import Structure.Setoid renaming (_≡_ to _≡ₛ_)
open import Type
open import Type.Dependent
... |
algebraic-stack_agda0000_doc_15112 | open import Agda.Builtin.IO using (IO)
open import Agda.Builtin.String using (String)
open import Agda.Builtin.Unit using (⊤)
data D : Set where
c₁ c₂ : D
f : D → Set → String
f c₁ = λ _ → "OK"
f c₂ = λ _ → "OK"
-- The following pragma should refer to the generated Haskell name
-- for f.
{-# FOREIGN GHC {-# NOINL... |
algebraic-stack_agda0000_doc_15113 | {-# OPTIONS --no-unreachable-check #-}
module Issue424 where
data _≡_ {A : Set₁} (x : A) : A → Set where
refl : x ≡ x
f : Set → Set
f A = A
f A = A
fails : (A : Set) → f A ≡ A
fails A = refl
-- The case tree compiler used to treat f as a definition with an
-- absurd pattern.
|
algebraic-stack_agda0000_doc_15114 | {-# OPTIONS --cubical --no-import-sorts #-}
open import Cubical.Foundations.Everything renaming (_⁻¹ to _⁻¹ᵖ; assoc to ∙-assoc)
open import Function.Base using (_∋_; _$_)
open import MorePropAlgebra.Bundles
import Cubical.Structures.CommRing as Std
module MorePropAlgebra.Properties.CommRing {ℓ} (assumptions : CommR... |
algebraic-stack_agda0000_doc_15115 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Trie, basic type and operations
------------------------------------------------------------------------
-- See README.Data.Trie.NonDependent for an example of using a trie to
-- build a lexer.
{-# OPTIONS --wi... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.