id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_2284 | {-# OPTIONS --cubical --allow-unsolved-metas #-}
open import Agda.Primitive.Cubical
module _ where
postulate
PathP : ∀ {ℓ} (A : I → Set ℓ) → A i0 → A i1 → Set ℓ
{-# BUILTIN PATHP PathP #-}
data D {ℓ} (A : Set ℓ) : Set ℓ where
c : PathP _ _ _
|
algebraic-stack_agda0000_doc_2285 | -- "Ordinal notations via simultaneous definitions"
module Experiment.Ord where
open import Level renaming (zero to lzero; suc to lsuc)
open import Relation.Binary
open import Relation.Binary.PropositionalEquality
open import Data.Sum
data Ord : Set
data _<_ : Rel Ord lzero
_≥_ : Rel Ord lzero
fst : Ord → Ord
data O... |
algebraic-stack_agda0000_doc_2286 | module list where
open import level
open import bool
open import eq
open import maybe
open import nat
open import unit
open import product
open import empty
open import sum
----------------------------------------------------------------------
-- datatypes
-------------------------------------------------------------... |
algebraic-stack_agda0000_doc_2287 | {-
Joseph Eremondi
Utrecht University Capita Selecta
UU# 4229924
July 22, 2015
-}
module SemiLinRE where
open import Data.Vec
open import Data.Nat
import Data.Fin as Fin
open import Data.List
import Data.List.All
open import Data.Bool
open import Data.Char
open import Data.Maybe
open import Data.Product
open impor... |
algebraic-stack_agda0000_doc_1216 |
module HasNeitherNor where
record HasNeitherNor (A : Set) : Set
where
field
_⊗_ : A → A → A
open HasNeitherNor ⦃ … ⦄ public
|
algebraic-stack_agda0000_doc_1217 | {-# OPTIONS --guardedness #-}
module ky where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; _≢_; refl; cong; cong₂; sym)
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_; _≡⟨_⟩_; _∎)
open import Data.Rational using (ℚ; _+_; _*_; _-_)
open import Data.Bool
open import Data.Bool.Properties
open import... |
algebraic-stack_agda0000_doc_1218 | {-# OPTIONS --without-K --safe #-}
module Tools.Bool where
open import Data.Bool using (Bool; true; false; _∧_; if_then_else_) public
|
algebraic-stack_agda0000_doc_1219 | module Text.Greek.Script where
open import Data.Maybe
open import Data.Vec
open import Relation.Nullary using (¬_)
open import Relation.Binary.PropositionalEquality using (_≢_)
data Case : Set where
lower upper : Case
data Letter : Set where
α′ β′ γ′ δ′ ε′ ζ′ η′ θ′ ι′ κ′ λ′ μ′ ν′ ξ′ ο′ π′ ρ′ σ′ τ′ υ′ φ′ χ′ ψ′ ω′... |
algebraic-stack_agda0000_doc_1220 | module Partiality where
{- port from http://www.soimort.org/posts/programs-and-proofs/ -}
open import Data.Bool using (Bool; false; true)
open import Data.Maybe using (Maybe; just; nothing)
open import Data.Char using (_==_) renaming (Char to Symbol)
open import Coinduction using (∞; ♯_; ♭)
-- open import Category.Mo... |
algebraic-stack_agda0000_doc_1221 | module Selective.Examples.Main-generated where
import Selective.Examples.PingPong as PingPong
import Selective.Examples.TestCall as Call
import Selective.Examples.TestCall2 as Call2
import Selective.Examples.Fibonacci as Fib
import Selective.Examples.Chat as Chat
import Selective.Examples.Bookstore as Bookstore
import ... |
algebraic-stack_agda0000_doc_1222 |
open import Agda.Primitive
record Functor {a b} (F : Set a → Set b) : Set (lsuc a ⊔ b) where
field
fmap : ∀ {A B} → (A → B) → F A → F B
open Functor {{...}} public
module _ {a b} (F : Set a → Set b) where
record FunctorZero : Set (lsuc a ⊔ b) where
field
empty : ∀ {A} → F A
overlap {{super}}... |
algebraic-stack_agda0000_doc_1223 | module Issue251 where
record Foo : Set₁ where
field
A : Set
B : Set
foo : Set → Set → Foo
foo = λ A B → record {A = A; B = B}
|
algebraic-stack_agda0000_doc_1224 | {-# OPTIONS --without-K #-}
module PathLemmas where
open import Relation.Binary.PropositionalEquality using
(_≡_; sym; refl)
------------------------------------------------------------------------------
-- These also follow from irrelevance, but this is nicer
sym-sym : {A : Set} {x y : A} {p : x ≡ y} → sym (sy... |
algebraic-stack_agda0000_doc_1225 | {-# OPTIONS --erased-cubical --safe #-}
module Interval where
open import Cubical.Core.Everything using (_≡_; Level; Type; Σ; _,_; fst; snd; _≃_; ~_)
open import Cubical.Foundations.Prelude using (refl; sym; _∙_; cong; transport; subst; funExt; transp; I; i0; i1)
--open import Cubical.Foundations.Function usi... |
algebraic-stack_agda0000_doc_1226 | {-# OPTIONS --without-K #-}
open import HoTT.Base
open import HoTT.Equivalence
open import HoTT.Identity.Pi
open import HoTT.Identity.Product
module HoTT.Product.Universal where
×-univ : ∀ {i j k} {X : 𝒰 i} (A : X → 𝒰 j) (B : X → 𝒰 k) →
((c : X) → A c × B c) ≃ Π X A × Π X B
×-univ {X = X} A B = let open I... |
algebraic-stack_agda0000_doc_1227 | {-# OPTIONS --without-K #-}
module Spaces.Spheres where
open import Base
open import Spaces.Suspension public
-- [Sⁿ n] is the sphere of dimension n
Sⁿ : ℕ → Set
Sⁿ 0 = bool
Sⁿ (S n) = suspension (Sⁿ n)
⋆Sⁿ : (n : ℕ) → Sⁿ n
⋆Sⁿ 0 = true
⋆Sⁿ (S n) = north (Sⁿ n) |
algebraic-stack_agda0000_doc_1228 | -- Properties of natural number
{-# OPTIONS --without-K --safe #-}
-- agad-stdlib
open import Relation.Binary.PropositionalEquality
module TypeTheory.Nat.Properties
{a}
(N : Set a)
(zero : N)
(suc : N → N)
(ind : ∀ {p} (P : N → Set p) → P zero → (∀ k → P k → P (suc k)) → ∀ n → P n)
(ind-base : ∀ {p} (P :... |
algebraic-stack_agda0000_doc_1229 | -- Andreas, 2012-07-31 no eager introduction of hidden abstractions
{-# OPTIONS --show-implicit #-}
-- {-# OPTIONS -v tc.conv.coerce:100 #-}
-- {-# OPTIONS -v tc.with:100 #-}
module Issue679 where
data Unit : Set where
unit : Unit
-- works also now:
test : {u : Unit} → Unit
test = λ {u} → u
T : Unit → Set
T unit =... |
algebraic-stack_agda0000_doc_1230 | ------------------------------------------------------------------------
-- The two definitions of substitutions are isomorphic (assuming
-- extensionality)
------------------------------------------------------------------------
open import Data.Universe.Indexed
module deBruijn.Substitution.Isomorphic
{i u e} {Uni... |
algebraic-stack_agda0000_doc_1231 | ------------------------------------------------------------------------
-- Overloaded "equational" reasoning combinators
------------------------------------------------------------------------
{-# OPTIONS --safe #-}
module Equational-reasoning where
open import Equality.Propositional
open import Prelude
infix -1... |
algebraic-stack_agda0000_doc_3552 | {-# OPTIONS --cubical --safe #-}
module Cubical.Structures.TypeEqvTo where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.HITs.PropositionalTruncation
open import Cubical.Data.Prod hiding (_×_) renaming (_×Σ_ to _×_)
open import Cubical.Foundations.SIP renaming (SNS... |
algebraic-stack_agda0000_doc_3553 | module trie-core where
open import bool
open import char
open import list
open import maybe
open import product
open import string
open import unit
open import eq
open import nat
cal : Set → Set
cal A = 𝕃 (char × A)
empty-cal : ∀{A : Set} → cal A
empty-cal = []
cal-lookup : ∀ {A : Set} → cal A → char → maybe A
cal... |
algebraic-stack_agda0000_doc_3554 | postulate
F : Set → Set → Set
syntax F X Y = X ! Y
test : Set → Set → Set
test X = _! X
|
algebraic-stack_agda0000_doc_3555 |
open import Everything
module Test.Test4
{𝔵} {𝔛 : Ø 𝔵}
{𝔞} {𝔒₁ : 𝔛 → Ø 𝔞}
{𝔟} {𝔒₂ : 𝔛 → Ø 𝔟}
{ℓ : Ł}
⦃ _ : Transitivity.class (Arrow 𝔒₁ 𝔒₂) ⦄
-- ⦃ _ : [𝓢urjectivity] (Arrow 𝔒₁ 𝔒₂) (Extension $ ArrowṖroperty ℓ 𝔒₁ 𝔒₂) ⦄
where
test[∙] : ∀ {x y} → ArrowṖroperty ℓ 𝔒₁ 𝔒₂ x → Arrow 𝔒₁ ... |
algebraic-stack_agda0000_doc_3556 | module parser where
open import lib
open import cedille-types
{-# FOREIGN GHC import qualified CedilleParser #-}
data Either (A : Set)(B : Set) : Set where
Left : A → Either A B
Right : B → Either A B
{-# COMPILE GHC Either = data Either (Left | Right) #-}
postulate
parseStart : string → Either (Either string... |
algebraic-stack_agda0000_doc_3557 | {-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.types.Pi
open import lib.types.Pointed
open import lib.types.Sigma
open import lib.types.Span
open import lib.types.Paths
import lib.types.Generic1HIT as Generic1HIT
module lib.types.Pushout where
module _ {i j k} where
postulate -- H... |
algebraic-stack_agda0000_doc_3558 | -- New NO_POSITIVITY_CHECK pragma for data definitions and mutual
-- blocks
-- Skipping an old-style mutual block: Somewhere within a `mutual`
-- block before a data definition.
mutual
data Cheat : Set where
cheat : Oops → Cheat
{-# NO_POSITIVITY_CHECK #-}
data Oops : Set where
oops : (Cheat → Cheat) → ... |
algebraic-stack_agda0000_doc_3559 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.RingSolver.CommRingEvalHom where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat using (ℕ)
open import Cubical.Data.FinData
open import Cubical.Data.Vec
open import Cubical.Data.Bool.Base
open import Cubical.Algebra.RingSo... |
algebraic-stack_agda0000_doc_3560 | module Structure.Operator.Algebra where
open import Lang.Instance
open import Logic.Predicate
import Lvl
open import Structure.Function.Domain
open import Structure.Operator.Field
open import Structure.Operator.Monoid
open import Structure.Operator.Properties
open import Structure.Operator.Ring
open import Struct... |
algebraic-stack_agda0000_doc_3561 | module STLC.Kovacs.Normalisation where
open import STLC.Kovacs.NormalForm public
--------------------------------------------------------------------------------
-- (Tyᴺ)
infix 3 _⊩_
_⊩_ : 𝒞 → 𝒯 → Set
Γ ⊩ ⎵ = Γ ⊢ⁿᶠ ⎵
Γ ⊩ A ⇒ B = ∀ {Γ′} → (η : Γ′ ⊇ Γ) (a : Γ′ ⊩ A)
→ Γ′ ⊩ B
-- (Conᴺ ;... |
algebraic-stack_agda0000_doc_3562 |
open import Oscar.Prelude
open import Oscar.Data.Decidable
open import Oscar.Data.Proposequality
module Oscar.Class.IsDecidable where
record IsDecidable {𝔬} (𝔒 : Ø 𝔬) : Ø 𝔬 where
infix 4 _≟_
field
_≟_ : (x y : 𝔒) → Decidable (x ≡ y)
open IsDecidable ⦃ … ⦄ public
|
algebraic-stack_agda0000_doc_3563 | module Syntax where
{-
open import Data.Nat hiding (_>_)
open import Data.Fin
open import Data.Product
open import Data.Bool
open import Relation.Binary.PropositionalEquality
-}
open import StdLibStuff
erase-subst :
(X : Set) → (Y : X → Set) →
(F : {x : X} → Y x) →
(x₁ x₂ : X) →
(eq : x₁ ≡ x₂) →
(P : Y x₂ → Set... |
algebraic-stack_agda0000_doc_3564 | -- Andreas, 2018-06-03, issue #3102
-- Regression: slow reduce with lots of module parameters and an import.
-- {-# OPTIONS -v tc.cc:30 -v tc.cover.top:30 --profile=internal #-}
open import Agda.Builtin.Bool
module _ (A B C D E F G H I J K L M O P Q R S T U V W X Y Z
A₁ B₁ C₁ D₁ E₁ F₁ G₁ H₁ I₁ J₁ K₁ L₁ M₁ ... |
algebraic-stack_agda0000_doc_3565 | module AmbiguousTopLevelModuleName where
import Imports.Ambiguous
|
algebraic-stack_agda0000_doc_3566 | {- 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.Base.Types
import LibraBFT.Impl.Consensus.Consensus... |
algebraic-stack_agda0000_doc_3567 | -- Andreas, 2012-07-26, reported by Nisse
module Issue678 where
module Unit where
data Unit : Set where
unit : Unit
El : Unit → Set
El unit = Unit
data IsUnit : Unit → Set where
isUnit : IsUnit unit
test : (u : Unit)(x : El u)(p : IsUnit u) → Set
test .unit unit isUnit = Unit
-- this requires... |
algebraic-stack_agda0000_doc_11184 | {-# OPTIONS --sized-types #-}
open import Relation.Binary.Core
module SelectSort {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_) where
open import Data.List
open import Data.Product
open import Data.Sum
open import Size
open import SList
open import SList.Order _≤_
select : {ι :... |
algebraic-stack_agda0000_doc_11185 | {-# OPTIONS --without-K --safe #-}
module Categories.Category.Instance.Monoidals where
open import Level
open import Categories.Category
open import Categories.Category.Helper
open import Categories.Category.Monoidal
open import Categories.Functor.Monoidal
open import Categories.Functor.Monoidal.Properties
open impo... |
algebraic-stack_agda0000_doc_11186 | {-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module LogicalFramework.Disjunction where
module LF where
postulate
_∨_ : Set → Set → Set
inj₁ : {A B : Set} → A → A ∨ B
inj₂ : {A ... |
algebraic-stack_agda0000_doc_11187 | ------------------------------------------------------------------------
-- A type soundness result
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
module Lambda.Delay-monad.Type-soundness where
open import Equality.Propositional
open import Prelude
open import ... |
algebraic-stack_agda0000_doc_11188 |
module _ where
module Test₁ where
postulate
id : {X : Set} → X → X
A : Set
x : A
record S : Set where
field
a : A
postulate
B : S → Set
record T : Set where
field
s : S
b : B s
-- Agda hangs here
t : T
t = λ
{ .T.s .S.a → x
; .T.b → id {!!}
... |
algebraic-stack_agda0000_doc_11189 | {-# OPTIONS --cubical --safe #-}
module Data.Maybe.Sugar where
open import Prelude
open import Data.Maybe
_>>=_ : Maybe A → (A → Maybe B) → Maybe B
nothing >>= f = nothing
just x >>= f = f x
pure : A → Maybe A
pure = just
_<*>_ : Maybe (A → B) → Maybe A → Maybe B
nothing <*> xs = nothing
just f <*> nothing = nothi... |
algebraic-stack_agda0000_doc_11190 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Automatic solvers for equations over booleans
------------------------------------------------------------------------
-- See README.Nat for examples of how to use similar solvers
{-# OPTIONS --without-K --safe... |
algebraic-stack_agda0000_doc_11191 | module WithInParModule (A : Set) where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
data Bool : Set where
true : Bool
false : Bool
isZero : Nat -> Bool
isZero zero = true
isZero (suc _) = false
f : Nat -> Nat
f n with isZero n
f n | true = zero
f n | false = suc zero
g : Nat -> Nat
g zero = zero
g (s... |
algebraic-stack_agda0000_doc_11192 | module Issue348 where
import Common.Irrelevance
data _==_ {A : Set1}(a : A) : A -> Set where
refl : a == a
record R : Set1 where
constructor mkR
field
.fromR : Set
reflR : (r : R) -> r == r
reflR r = refl {a = _}
-- issue: unsolved metavars resolved 2010-10-15 by making eta-expansion
-- more lazy (do no... |
algebraic-stack_agda0000_doc_11193 | module Cats.End where
open import Level using (_⊔_)
open import Cats.Category
open import Cats.Category.Wedges using (Wedge ; Wedges)
open import Cats.Profunctor
module _ {lo la l≈ lo′ la′ l≈′}
{C : Category lo la l≈} {D : Category lo′ la′ l≈′}
where
IsEnd : {F : Profunctor C C D} → Wedge F → Set (lo ⊔ la ⊔ ... |
algebraic-stack_agda0000_doc_11194 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- An example of how Algebra.IdempotentCommutativeMonoidSolver can be
-- used
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Algebra.Solver.Idemp... |
algebraic-stack_agda0000_doc_11195 | {-# OPTIONS --allow-unsolved-metas #-}
open import Agda.Builtin.Equality
open import Agda.Builtin.List
postulate
A : Set
nilA : A
consA : A → List A → A
w/e : {x y : A} → x ≡ y
data D : List A → Set where
nil : D []
cons : (x : A) (xs : List A) → D (x ∷ xs)
foo : ∀ {xs} (d : D xs)
(let f : D xs → ... |
algebraic-stack_agda0000_doc_11196 | {-# OPTIONS --without-K --exact-split --safe #-}
module mwe where
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_) public
--------------------------------------------------------------------------------
data ℕ : Set lzero where
zero-ℕ : ℕ
succ-ℕ : ℕ → ℕ
add-ℕ : ℕ → ℕ → ℕ
add-ℕ x zero-ℕ = x
add-ℕ x (s... |
algebraic-stack_agda0000_doc_11197 | -- Andreas, 2012-09-13
-- (The signature on the previous line does not apply to all of the
-- text in this file.)
module RelevanceSubtyping where
-- this naturally type-checks:
one : {A B : Set} → (.A → B) → A → B
one f x = f x
-- Subtyping is no longer supported for irrelevance, so the following
-- code is no longer... |
algebraic-stack_agda0000_doc_11198 | {-# OPTIONS --without-K --safe #-}
module Definition.Typed.EqualityRelation where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Weakening using (_∷_⊆_)
-- Generic equality relation used with the logical relation
record EqRelSet : Set₁ where
constructor eqRel
field
... |
algebraic-stack_agda0000_doc_11199 |
module Agda.Builtin.FromNeg where
open import Agda.Primitive
open import Agda.Builtin.Nat
record Negative {a} (A : Set a) : Set (lsuc a) where
field
Constraint : Nat → Set a
fromNeg : ∀ n → {{_ : Constraint n}} → A
open Negative {{...}} public using (fromNeg)
{-# BUILTIN FROMNEG fromNeg #-}
{-# DISPLAY N... |
algebraic-stack_agda0000_doc_3536 | module SystemF.Syntax where
open import SystemF.Syntax.Type public
open import SystemF.Syntax.Term public
open import SystemF.Syntax.Context public
|
algebraic-stack_agda0000_doc_3537 |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Foundations.Filler where
open import Cubical.Foundations.Prelude
private
variable
ℓ ℓ' : Level
A : Type ℓ
cube-cong : {a b : A}
{p p' q q' : a ≡ b}
(P : p ≡ p') (Q : q ≡ q')
→ (p ≡ q) ≡ (p' ≡ q')
cube-con... |
algebraic-stack_agda0000_doc_3538 | {-# OPTIONS --syntactic-equality=2 --allow-unsolved-metas #-}
-- Limited testing suggests that --syntactic-equality=2 is a little
-- faster than --syntactic-equality=0 and --syntactic-equality=1 for
-- this file.
-- The option --allow-unsolved-metas and the open goal at the end of
-- the file ensure that time is not ... |
algebraic-stack_agda0000_doc_3539 | open import Nat
open import Prelude
open import List
open import statics-core
-- erasure of cursor in the types and expressions is defined in the paper,
-- and in the core file, as a function on zexpressions. because of the
-- particular encoding of all the judgments as datatypes and the agda
-- semantics for pattern ... |
algebraic-stack_agda0000_doc_3540 | {-# OPTIONS --rewriting #-}
module Issue2792 where
open import Issue2792.Safe
|
algebraic-stack_agda0000_doc_3541 | ------------------------------------------------------------------------
-- Equivalences with erased "proofs"
------------------------------------------------------------------------
-- This module contains some basic definitions with few dependencies.
-- See Equivalence.Erased for more definitions. The definitions be... |
algebraic-stack_agda0000_doc_3542 | -- 2012-03-08 Andreas
module NoTerminationCheck4 where
data Bool : Set where
true false : Bool
{-# NON_TERMINATING #-}
private
f : Bool -> Bool
f true = f true
f false = f false
-- error: must place pragma before f
|
algebraic-stack_agda0000_doc_3543 | ------------------------------------------------------------------------------
-- First-order logic (without equality)
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorph... |
algebraic-stack_agda0000_doc_3544 | -- Andreas, 2014-06-12 This feature has been addressed by issue 907
{-# OPTIONS --copatterns #-}
module CopatternsToRHS where
import Common.Level
open import Common.Equality
open import Common.Prelude using (Bool; true; false)
record R (A : Set) : Set where
constructor mkR
field
fst : A → A
snd : Bool
... |
algebraic-stack_agda0000_doc_3545 | ------------------------------------------------------------------------
-- A tactic aimed at making equational reasoning proofs more readable
-- in modules that are parametrised by an implementation of equality
------------------------------------------------------------------------
-- The tactic uses the first insta... |
algebraic-stack_agda0000_doc_3546 | -- Andreas, 2016-12-28, issue #2360 reported by m0davis
-- Ambigous projection in with-clause triggered internal error
postulate
A : Set
a : A
module M (X : Set) where
record R : Set where
field f : X
-- Opening two instantiations of M creates and ambiguous projection
open M A using (module R)
open M A
t... |
algebraic-stack_agda0000_doc_3547 | {-# OPTIONS --safe #-}
module Ferros.Prelude where
open import Relation.Binary.PropositionalEquality
open import Data.Nat
open import Data.Nat.Properties
open import Data.Bool hiding (_≤_)
ℕ-sub : (x y : ℕ) → (y ≤ x) → ℕ
ℕ-sub x .zero z≤n = x
ℕ-sub ._ ._ (s≤s p) = ℕ-sub _ _ p
invert-ℕ-sub : ∀ x y → (p : y ≤ x) → (ℕ... |
algebraic-stack_agda0000_doc_3548 | {-# OPTIONS --without-K --safe #-}
module TypeTheory.Nat.Instance where
-- agda-stdlib
open import Level renaming (zero to lzero; suc to lsuc)
open import Data.Nat using (ℕ; zero; suc)
open import Relation.Binary.PropositionalEquality using (refl)
-- agda-misc
import TypeTheory.Nat.Operations as NatOperations
ℕ-ind... |
algebraic-stack_agda0000_doc_3549 | {-# OPTIONS --warning=error #-}
module UselessPrivateImport2 where
private
open import Common.Issue481ParametrizedModule Set
|
algebraic-stack_agda0000_doc_3550 | module Numeral.Integer.Relation where
|
algebraic-stack_agda0000_doc_3551 | module OpenPublicPlusTypeError where
module X where
postulate D : Set
open X public
postulate x : D
typeIncorrect : Set
typeIncorrect = Set1
|
algebraic-stack_agda0000_doc_2256 | {-# OPTIONS --without-K #-}
open import Base
open import Algebra.Groups
open import Integers
module Algebra.GroupIntegers where
_+_ : ℤ → ℤ → ℤ
O + m = m
pos O + m = succ m
pos (S n) + m = succ (pos n + m)
neg O + m = pred m
neg (S n) + m = pred (neg n + m)
-_ : ℤ → ℤ
- O = O
- (pos m) = neg m
- (neg m) = pos m
+-... |
algebraic-stack_agda0000_doc_2257 | ------------------------------------------------------------------------------
-- Testing the erasing of proof terms
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphis... |
algebraic-stack_agda0000_doc_2258 | module LateMetaVariableInstantiation where
data ℕ : Set where
zero : ℕ
suc : (n : ℕ) → ℕ
{-# BUILTIN NATURAL ℕ #-}
postulate
yippie : (A : Set) → A
slow : (A : Set) → ℕ → A
slow A zero = yippie A
slow A (suc n) = slow _ n
data _≡_ {A : Set} (x : A) : A → Set where
refl : x ≡ x
foo : slow ℕ 1000 ≡ y... |
algebraic-stack_agda0000_doc_2259 |
module _ where
open import Agda.Primitive
open import Agda.Builtin.List
open import Agda.Builtin.Nat hiding (_==_)
open import Agda.Builtin.Equality
open import Agda.Builtin.Unit
open import Agda.Builtin.Bool
infix -1 _,_
record _×_ {a b} (A : Set a) (B : Set b) : Set (a ⊔ b) where
constructor _,_
field fst : A
... |
algebraic-stack_agda0000_doc_2260 | {-# OPTIONS --cubical --safe #-}
module Multidimensional.Data.Extra.Nat where
open import Multidimensional.Data.Extra.Nat.Base public
open import Multidimensional.Data.Extra.Nat.Properties public
|
algebraic-stack_agda0000_doc_2261 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
module homotopy.CircleCover {j} where
record S¹Cover : Type (lsucc j) where
constructor s¹cover
field
El : Type j
{{El-level}} : is-set El
El-auto : El ≃ El
S¹cover-to-S¹-cover : S¹Cover → Cover S¹ j
S¹cover-to-S¹-cover sc = record {
Fiber =... |
algebraic-stack_agda0000_doc_2262 | -- This module closely follows a section of Martín Escardó's HoTT lecture notes:
-- https://www.cs.bham.ac.uk/~mhe/HoTT-UF-in-Agda-Lecture-Notes/HoTT-UF-Agda.html#equivalenceinduction
{-# OPTIONS --without-K #-}
module Util.HoTT.Equiv.Induction where
open import Util.HoTT.HLevel.Core
open import Util.HoTT.Equiv
open i... |
algebraic-stack_agda0000_doc_2263 | {-# OPTIONS --warning=error #-}
A : Set₁
A = Set
{-# POLARITY A #-}
|
algebraic-stack_agda0000_doc_2264 | module UnSized.Console where
open import UnSizedIO.Base hiding (main)
open import UnSizedIO.Console hiding (main)
open import NativeIO
{-# TERMINATING #-}
myProgram : IOConsole Unit
force myProgram = exec' getLine λ line →
delay (exec' (putStrLn line) λ _ →
d... |
algebraic-stack_agda0000_doc_2265 |
module Prelude.Variables where
open import Agda.Primitive
open import Agda.Builtin.Nat
variable
ℓ ℓ₁ ℓ₂ ℓ₃ : Level
A B : Set ℓ
x y : A
n m : Nat
|
algebraic-stack_agda0000_doc_2266 | open import core
module focus-formation where
-- every ε is an evaluation context -- trivially, here, since we don't
-- include any of the premises in red brackets about finality
focus-formation : ∀{d d' ε} → d == ε ⟦ d' ⟧ → ε evalctx
focus-formation FHOuter = ECDot
focus-formation (FHAp1 sub) = ECAp1 (focus... |
algebraic-stack_agda0000_doc_2267 | {-# OPTIONS --without-K #-}
open import HoTT
open import homotopy.PtdAdjoint
open import homotopy.SuspAdjointLoop
open import cohomology.Exactness
open import cohomology.FunctionOver
open import cohomology.MayerVietoris
open import cohomology.Theory
{- Standard Mayer-Vietoris exact sequence (algebraic) derived from
... |
algebraic-stack_agda0000_doc_2268 | --- Sample Sit file
{-# OPTIONS --experimental-irrelevance #-}
{-# OPTIONS --sized-types #-}
open import Base
--; --- Leibniz-equality
Eq : forall (A : Set) (a b : A) -> Set1 --;
Eq = \ A a b -> (P : A -> Set) -> (P a) -> P b
--; --- Reflexivity
refl : forall (A : Set) (a : A) -> Eq A a a --;
refl = \ A a P pa ->... |
algebraic-stack_agda0000_doc_2269 | module PosNat where
open import Nats
open import Data.Product
open import Equality
data ℕ⁺ : Set where
psuc : ℕ → ℕ⁺
_→ℕ : ℕ⁺ → ℕ
psuc zero →ℕ = suc zero
psuc (suc x) →ℕ = suc (psuc x →ℕ)
_⟨_⟩→ℕ⁺ : (a : ℕ) → ∃ (λ x → a ≡ suc x) → ℕ⁺
.(suc x) ⟨ x , refl ⟩→ℕ⁺ = psuc x
|
algebraic-stack_agda0000_doc_2270 | module _ where
module M where
postulate
[_] : Set → Set
Foo = [ M.undefined ]
|
algebraic-stack_agda0000_doc_2271 |
open import Common.Prelude
record Number (A : Set) : Set where
field fromNat : Nat → A
record Negative (A : Set) : Set where
field fromNeg : Nat → A
open Number {{...}} public
open Negative {{...}} public
{-# BUILTIN FROMNAT fromNat #-}
{-# BUILTIN FROMNEG fromNeg #-}
instance
NumberNat : Number Nat
Numbe... |
algebraic-stack_agda0000_doc_7984 | open import Data.List using (List; _∷_; [])
open import Data.Product using (_×_; _,_; Σ)
open import Data.Unit using (⊤; tt)
open import Relation.Binary.PropositionalEquality using (_≡_)
module SystemT where
data _∈_ {A : Set} : (x : A) (l : List A) → Set where -- type \in
i0 : {x : A} {xs : List A} → x ∈... |
algebraic-stack_agda0000_doc_7985 | {-# OPTIONS --universe-polymorphism #-}
-- {-# OPTIONS --verbose tc.records.ifs:15 #-}
-- {-# OPTIONS --verbose tc.constr.findInScope:15 #-}
-- {-# OPTIONS --verbose tc.term.args.ifs:15 #-}
module 05-equality-std1 where
open import Relation.Binary using (IsDecEquivalence; module IsDecEquivalence; Reflexive; module De... |
algebraic-stack_agda0000_doc_7986 | module Thesis.SIRelBigStep.DenSem where
open import Data.Nat
open import Data.Product
open import Thesis.SIRelBigStep.Syntax
open import Data.Nat
⟦_⟧Type : Type → Set
⟦ σ ⇒ τ ⟧Type = ⟦ σ ⟧Type → ⟦ τ ⟧Type
⟦ nat ⟧Type = ℕ
⟦ pair τ1 τ2 ⟧Type = ⟦ τ1 ⟧Type × ⟦ τ2 ⟧Type
import Base.Denotation.Environment
module Den = Ba... |
algebraic-stack_agda0000_doc_7987 | -- Subtyping is no longer supported for irrelevance.
f : {A B : Set} → (.A → B) → A → B
f g = λ .x → g x
|
algebraic-stack_agda0000_doc_7988 |
open import Agda.Builtin.Equality
open import Agda.Builtin.Sigma
postulate X : Set
variable x : X
data C : Σ X (λ x → x ≡ x) → Set where
mkC :
let
eq : x ≡ x -- don't generalize over x at eq
eq = refl {x = x}
in
C (x , eq)
|
algebraic-stack_agda0000_doc_7989 | module Sets.IterativeUSet where
open import Data renaming (Empty to EmptyType)
open import Functional
import Lvl
import Lvl.Decidable as Lvl
open import Structure.Setoid renaming (_≡_ to _≡ₛ_)
open import Syntax.Function
open import Type
open import Type.Dependent
private variable ℓ ℓₒ ℓₑ ℓ₁ ℓ₂ : Lvl.Level
... |
algebraic-stack_agda0000_doc_7990 | module treeThms where
open import lib
-- simple Tree type storing natural numbers
data Tree : Set where
Node : ℕ → Tree → Tree → Tree
Leaf : Tree
mirror : Tree → Tree
mirror (Node x t1 t2) = Node x (mirror t2) (mirror t1)
mirror Leaf = Leaf
mirror-mirror : ∀ (t : Tree) → mirror (mirror t) ≡ t
mirr... |
algebraic-stack_agda0000_doc_7991 |
open import Agda.Builtin.Unit
open import Agda.Builtin.Bool
open import Agda.Builtin.Sigma
open import Agda.Builtin.List
open import Agda.Builtin.Equality
open import Agda.Builtin.Reflection renaming (returnTC to return; bindTC to _>>=_)
_>>_ : ∀ {a} {b} {A : Set a} {B : Set b}
→ TC A → TC B → TC B
x >> y = x >>... |
algebraic-stack_agda0000_doc_7992 | {-# OPTIONS --without-K --rewriting --termination-depth=2 #-}
open import HoTT
open import cohomology.ChainComplex
open import cohomology.Theory
open import groups.KernelImage
open import cw.CW
module cw.cohomology.ReconstructedHigherCohomologyGroups {i : ULevel} (OT : OrdinaryTheory i) where
open OrdinaryTheory O... |
algebraic-stack_agda0000_doc_7993 | module Verifier
(down : Set₁ -> Set)
(up : Set → Set₁)
(iso : ∀ {A} → down (up A) -> A)
(osi : ∀ {A} → up (down A) -> A) where
import UniverseCollapse as UC
open UC down up iso osi using (anything)
check : (A : Set) -> A
check = anything
|
algebraic-stack_agda0000_doc_7994 | module Data.Bin.DivMod where
import Data.Fin
import Data.Product
import Data.Bin
import Data.Nat
import Relation.Binary.PropositionalEquality
import Data.Digit hiding (0b; 1b)
import Data.List
import Algebra
import Algebra.Structures
import Data.Bin.NatHelpers
open Data.Bin using (Bin; toℕ; toBits; fromB... |
algebraic-stack_agda0000_doc_7995 | {-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.ZariskiLattice.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
open im... |
algebraic-stack_agda0000_doc_7996 | ------------------------------------------------------------------------------
-- Agda-Prop Library.
-- Theorems with different connectives.
------------------------------------------------------------------------------
open import Data.Nat using ( ℕ )
module Data.PropFormula.Theorems.Mixies ( n : ℕ ) where
--------... |
algebraic-stack_agda0000_doc_7997 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of non-empty lists
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.NonEmpty.Properties where
open import Category.Monad
o... |
algebraic-stack_agda0000_doc_7998 | {-# OPTIONS --without-K --safe #-}
module Categories.Bicategory where
open import Level
open import Data.Product using (_,_)
open import Relation.Binary using (Rel)
open import Categories.Category using (Category; module Commutation)
open import Categories.Category.Monoidal.Instance.Cats using (module Product)
open ... |
algebraic-stack_agda0000_doc_7999 | {-
Pointed structure: X ↦ X
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Structures.Pointed where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.SIP
open import Cubical.Foundations.Point... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.