id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_5964 | module reverse_string where
open import Data.String
open import Data.List
reverse_string : String → String
reverse_string s = fromList (reverse (toList s))
|
algebraic-stack_agda0000_doc_5965 | {-# OPTIONS --safe --without-K #-}
open import Algebra.Bundles using (Monoid)
module Categories.Category.Construction.MonoidAsCategory o {c ℓ} (M : Monoid c ℓ) where
open import Data.Unit.Polymorphic
open import Level
open import Categories.Category.Core
open Monoid M
-- A monoid is a category with one object
Mono... |
algebraic-stack_agda0000_doc_5966 | ------------------------------------------------------------------------------
-- Non-terminating GCD
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIO... |
algebraic-stack_agda0000_doc_5967 | module Structure.Signature where
open import Data.Tuple.Raise
open import Data.Tuple.Raiseᵣ.Functions
import Lvl
open import Numeral.Natural
open import Structure.Function
open import Structure.Setoid
open import Structure.Relator
open import Type
private variable ℓ ℓᵢ ℓᵢ₁ ℓᵢ₂ ℓᵢ₃ ℓd ℓd₁ ℓd₂ ℓᵣ ℓᵣ₁ ℓᵣ₂ ℓₑ ℓₑ₁ ℓₑ... |
algebraic-stack_agda0000_doc_272 |
module Issue59 where
data Nat : Set where
zero : Nat
suc : Nat → Nat
-- This no longer termination checks with the
-- new rules for with.
bad : Nat → Nat
bad n with n
... | zero = zero
... | suc m = bad m
-- This shouldn't termination check.
bad₂ : Nat → Nat
bad₂ n with bad₂ n
... | m = m
|
algebraic-stack_agda0000_doc_273 | module Cats.Util.SetoidMorphism.Iso where
open import Data.Product using (_,_ ; proj₁ ; proj₂)
open import Level using (_⊔_)
open import Relation.Binary using (Setoid ; IsEquivalence)
open import Cats.Util.SetoidMorphism as Mor using
( _⇒_ ; arr ; resp ; _≈_ ; ≈-intro ; ≈-elim ; ≈-elim′ ; _∘_ ; ∘-resp ; id ; IsInje... |
algebraic-stack_agda0000_doc_274 | {-
T R U N C A T I O N L E V E L S
I N
H O M O T O P Y T Y P E T H E O R Y
======= ELECTRONIC APPENDIX =======
NICOLAI KRAUS
February 2015
-}
{-# OPTIONS --without-K #-}
module INDEX where
-- Chapter 2
open import Preliminaries
-- Parts of Chapter 2 are in a separa... |
algebraic-stack_agda0000_doc_275 | {-# OPTIONS --verbose tc.constr.findInScope:20 #-}
module InstanceArgumentsConstraints where
data Bool : Set where
true false : Bool
postulate A1 A2 B C : Set
a1 : A1
a2 : A2
someF : A1 → C
record Class (R : Bool → Set) : Set where
field f : (t : Bool) → R t
open Class {{...}}
cl... |
algebraic-stack_agda0000_doc_276 | {-# OPTIONS --cubical --safe #-}
module Data.Bool where
open import Level
open import Agda.Builtin.Bool using (Bool; true; false) public
open import Data.Unit
open import Data.Empty
bool : ∀ {ℓ} {P : Bool → Type ℓ} (f : P false) (t : P true) → (x : Bool) → P x
bool f t false = f
bool f t true = t
not : Bool → Bool
... |
algebraic-stack_agda0000_doc_277 | ------------------------------------------------------------------------
-- Example: Left recursive expression grammar
------------------------------------------------------------------------
module TotalParserCombinators.Examples.Expression where
open import Codata.Musical.Notation
open import Data.Char as Char usin... |
algebraic-stack_agda0000_doc_278 |
module Tactic.Nat.Reflect where
open import Prelude hiding (abs)
open import Control.Monad.State
open import Control.Monad.Transformer
import Agda.Builtin.Nat as Builtin
open import Builtin.Reflection
open import Tactic.Reflection
open import Tactic.Reflection.Quote
open import Tactic.Reflection.Meta
open import Ta... |
algebraic-stack_agda0000_doc_279 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Group.Algebra where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Function using (_∘_)
open import Cubical.Foundations.GroupoidLaws
op... |
algebraic-stack_agda0000_doc_280 | module Relations where
-- Imports
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong)
open import Data.Nat using (ℕ; zero; suc; _+_)
open import Data.Nat.Properties using (+-comm)
-- Defining relations
data _≤_ : ℕ → ℕ → Set where
z≤n : ∀ {n : ℕ}
--------
→ zero ≤ n
s≤... |
algebraic-stack_agda0000_doc_281 | module Data.Nat.Instance where
open import Agda.Builtin.Nat
open import Class.Equality
open import Class.Monoid
open import Class.Show
open import Data.Char
open import Data.List
open import Data.Nat renaming (_≟_ to _≟ℕ_; _+_ to _+ℕ_)
open import Data.String
open import Function
private
postulate
primShowNat ... |
algebraic-stack_agda0000_doc_282 | open import Data.Product using ( _×_ ; _,_ ; swap )
open import Data.Sum using ( inj₁ ; inj₂ )
open import Relation.Nullary using ( ¬_ ; yes ; no )
open import Relation.Unary using ( _∈_ )
open import Web.Semantic.DL.ABox using ( ABox ; ε ; _,_ ; _∼_ ; _∈₁_ ; _∈₂_ )
open import Web.Semantic.DL.ABox.Interp using
( Int... |
algebraic-stack_agda0000_doc_283 | {-# OPTIONS --without-K --safe #-}
module Fragment.Examples.CSemigroup.Types where
|
algebraic-stack_agda0000_doc_284 | -- This document shows how to encode GADTs using `IFix`.
{-# OPTIONS --type-in-type #-}
module ScottVec where
-- The kind of church-encoded type-level natural numbers.
Nat = (Set -> Set) -> Set -> Set
zero : Nat
zero = λ f z -> z
suc : Nat -> Nat
suc = λ n f z -> f (n f z)
plus : Nat -> Nat -> Nat
plus = λ n m f ... |
algebraic-stack_agda0000_doc_285 | module EqTest where
import Common.Level
open import Common.Maybe
open import Common.Equality
data ℕ : Set where
zero : ℕ
suc : ℕ -> ℕ
_≟_ : (x y : ℕ) -> Maybe (x ≡ y)
suc m ≟ suc n with m ≟ n
suc .n ≟ suc n | just refl = just refl
suc m ≟ suc n | nothing = nothing
zero ≟ suc _ = nothing
suc m ≟ ze... |
algebraic-stack_agda0000_doc_286 | -- Andreas, 2012-09-26 disable projection-likeness for recursive functions
-- {-# OPTIONS -v tc.proj.like:100 #-}
module ProjectionLikeRecursive where
open import Common.Prelude
open import Common.Equality
if_then_else_ : {A : Set} → Bool → A → A → A
if true then t else e = t
if false then t else e = e
infixr 5 _∷_ ... |
algebraic-stack_agda0000_doc_287 |
module HasNegation where
record HasNegation (A : Set) : Set
where
field
~ : A → A
open HasNegation ⦃ … ⦄ public
{-# DISPLAY HasNegation.~ _ = ~ #-}
|
algebraic-stack_agda0000_doc_6112 |
module _ where
open import Common.Prelude
open import Common.Equality
primitive
primForce : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) → (∀ x → B x) → B x
primForceLemma : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) (f : ∀ x → B x) → primForce x f ≡ f x
force = primForce
forceLemma = primForceLemma
seq :... |
algebraic-stack_agda0000_doc_6113 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
open import Cubical.Foundations.HLevels
module Cubical.Algebra.Semigroup.Construct.Right {ℓ} (Aˢ : hSet ℓ) where
open import Cubical.Foundations.Prelude
open import Cubical.Algebra.Semigroup
import Cubical.Algebra.Magma.Construct... |
algebraic-stack_agda0000_doc_6114 | module _ where
abstract
data Nat : Set where
Zero : Nat
Succ : Nat → Nat
countDown : Nat → Nat
countDown x with x
... | Zero = Zero
... | Succ n = countDown n
|
algebraic-stack_agda0000_doc_6115 | {-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.types.Sigma
open import lib.types.Group
open import lib.types.CommutingSquare
open import lib.groups.Homomorphism
open import lib.groups.Isomorphism
module lib.groups.CommutingSquare where
-- A new type to keep the parameters.
record Comm... |
algebraic-stack_agda0000_doc_6116 | -- this is effectively a CM make file. it just includes all the files that
-- exist in the directory in the right order so that one can check that
-- everything compiles cleanly and has no unfilled holes
-- data structures
open import List
open import Nat
open import Prelude
-- basic stuff: core definitions, etc
open... |
algebraic-stack_agda0000_doc_6117 | module consoleExamples.passwordCheckSimple where
open import ConsoleLib
open import Data.Bool.Base
open import Data.Bool
open import Data.String renaming (_==_ to _==str_)
open import SizedIO.Base
main : ConsoleProg
main = run (GetLine >>= λ s →
if s ==str "passwd"
then WriteString "Success"... |
algebraic-stack_agda0000_doc_6118 | {-# OPTIONS --cubical --safe #-}
module Cubical.Data.Universe where
open import Cubical.Data.Universe.Base public
open import Cubical.Data.Universe.Properties public
|
algebraic-stack_agda0000_doc_6119 | {-# OPTIONS --without-K --safe #-}
open import Categories.Bicategory using (Bicategory)
-- A Pseudofunctor is a homomorphism of Bicategories
-- Follow Bénabou's definition, which is basically that of a Functor
-- Note that what is in nLab is an "exploded" version of the simpler version below
module Categories.Pseudo... |
algebraic-stack_agda0000_doc_6120 | module Tactic.Reflection.Replace where
open import Prelude
open import Container.Traversable
open import Tactic.Reflection
open import Tactic.Reflection.Equality
{-# TERMINATING #-}
_r[_/_] : Term → Term → Term → Term
p r[ r / l ] =
ifYes p == l
then r
else case p of λ
{ (var x ... |
algebraic-stack_agda0000_doc_6121 | module Numeral.Natural.Relation.Order.Decidable where
open import Functional
open import Logic.IntroInstances
open import Logic.Propositional.Theorems
open import Numeral.Natural
open import Numeral.Natural.Oper.Comparisons
open import Numeral.Natural.Oper.Proofs
open import Numeral.Natural.Relation.Order
open import ... |
algebraic-stack_agda0000_doc_6122 | {-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Order
open import Numbers.Naturals.Order.WellFounded
open import Numbers.Naturals.Order.Lemmas
open import Numbers.Integers.Definition
open import Numbers.Integers.Integers
... |
algebraic-stack_agda0000_doc_6123 |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.DStructures.Equivalences.PeifferGraphS2G where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
... |
algebraic-stack_agda0000_doc_6124 | ------------------------------------------------------------------------------
-- Arithmetic properties (added for the Collatz function example)
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIO... |
algebraic-stack_agda0000_doc_6125 | module OlderBasicILP.Direct.Translation where
open import Common.Context public
-- import OlderBasicILP.Direct.Hilbert.Sequential as HS
import OlderBasicILP.Direct.Hilbert.Nested as HN
import OlderBasicILP.Direct.Gentzen as G
-- open HS using () renaming (_⊢×_ to HS⟨_⊢×_⟩ ; _⊢_ to HS⟨_⊢_⟩) public
open HN using () re... |
algebraic-stack_agda0000_doc_6126 |
module Oscar.Class.Semifunctor where
open import Oscar.Class.Semigroup
open import Oscar.Class.Extensionality
open import Oscar.Class.Preservativity
open import Oscar.Function
open import Oscar.Level
open import Oscar.Relation
record Semifunctor
{𝔞₁} {𝔄₁ : Set 𝔞₁} {𝔰₁} {_►₁_ : 𝔄₁ → 𝔄₁ → Set 𝔰₁}
(_◅₁_ : ... |
algebraic-stack_agda0000_doc_6127 | module nform where
open import Data.PropFormula (3) public
open import Data.PropFormula.NormalForms 3 public
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
p : PropFormula
p = Var (# 0)
q : PropFormula
q = Var (# 1)
r : PropFormula
r = Var (# 2)
φ : PropFormula
φ = ¬ ((p ∧ (p ⊃ q)) ⊃ q) -- (p ... |
algebraic-stack_agda0000_doc_17152 | open import Nat
open import Prelude
open import contexts
open import core
open import type-assignment-unicity
module canonical-indeterminate-forms where
-- this type gives somewhat nicer syntax for the output of the canonical
-- forms lemma for indeterminates at base type
data cif-base : (Δ : hctx) (d : ihexp) ... |
algebraic-stack_agda0000_doc_17153 | module Cats.Util.SetoidReasoning where
open import Relation.Binary.SetoidReasoning public
open import Relation.Binary using (Setoid)
open import Relation.Binary.EqReasoning as EqR using (_IsRelatedTo_)
infixr 2 _≡⟨⟩_
_≡⟨⟩_ : ∀ {c l} {S : Setoid c l} → ∀ x {y} → _IsRelatedTo_ S x y → _IsRelatedTo_ S x y
_≡⟨⟩_ {S ... |
algebraic-stack_agda0000_doc_17154 | {-# OPTIONS --without-K --exact-split --safe #-}
module Fragment.Extensions.CSemigroup.Base where
open import Fragment.Equational.Theory.Bundles
open import Fragment.Algebra.Signature
open import Fragment.Algebra.Free Σ-magma hiding (_~_)
open import Fragment.Algebra.Homomorphism Σ-magma
open import Fragment.Algebra... |
algebraic-stack_agda0000_doc_17155 | {-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
open import Light.Library.Data.Natural as ℕ using (ℕ ; predecessor ; zero)
open import Light.Package using (Package)
module Light.Literals.Level ⦃ natural‐package : Package record { ℕ } ⦄ where
open import Light.Literals.Definition.Natur... |
algebraic-stack_agda0000_doc_17156 | {-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Paths
open import lib.types.Pi
open import lib.types.Unit
module lib.types.Circle where
{-
Idea :
data S¹ : Type₀ where
base : S¹
loop : base == base
I’m using Dan Licata’s trick to have a higher inductive type with definitional
reduction... |
algebraic-stack_agda0000_doc_17157 | -- Andreas, 2015-06-24
{-# OPTIONS --copatterns #-}
-- {-# OPTIONS -v tc.with.strip:20 #-}
module _ where
open import Common.Equality
open import Common.Product
module SynchronousIO (I O : Set) where
F : Set → Set
F S = I → O × S
record SyncIO : Set₁ where
field
St : Set
tr : St → F St
m... |
algebraic-stack_agda0000_doc_17158 | -- 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_17159 | ------------------------------------------------------------------------
-- A type for values that should be erased at run-time
------------------------------------------------------------------------
-- Most of the definitions in this module are reexported, in one way
-- or another, from Erased.
-- This module impor... |
algebraic-stack_agda0000_doc_17160 | {-# OPTIONS --safe #-}
module Cubical.Categories.Instances.FunctorAlgebras where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism renaming (Iso to _≅_)
open import Cubical.Foundations.Univalence
open im... |
algebraic-stack_agda0000_doc_17161 | module Prelude where
--------------------------------------------------------------------------------
open import Agda.Primitive public
using (Level ; _⊔_)
renaming (lzero to ℓ₀)
id : ∀ {ℓ} → {X : Set ℓ}
→ X → X
id x = x
_◎_ : ∀ {ℓ ℓ′ ℓ″} → {X : Set ℓ} {P : X → Set ℓ′} {Q : ∀ {x} → P x → Set ℓ″}
... |
algebraic-stack_agda0000_doc_17162 | -- Andreas, 2013-11-23
-- checking that postulates are allowed in new-style mutual blocks
open import Common.Prelude
-- new style mutual block
even : Nat → Bool
postulate
odd : Nat → Bool
even zero = true
even (suc n) = odd n
-- No error
|
algebraic-stack_agda0000_doc_17163 | module Data.Num.Bijective where
open import Data.Nat
open import Data.Fin as Fin using (Fin; #_; fromℕ≤)
open import Data.Fin.Extra
open import Data.Fin.Properties using (bounded)
open ≤-Reasoning renaming (begin_ to start_; _∎ to _□; _≡⟨_⟩_ to _≈⟨_⟩_)
open import Level using () renaming (suc to lsuc)
open import Func... |
algebraic-stack_agda0000_doc_17164 | module z-06 where
open import Data.Nat using (ℕ; zero; suc; _+_; _*_; _<?_; _<_; ≤-pred)
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
import Relation.Binary.PropositionalEquality.Core as PE
{-
--------------------------------------------------------------------... |
algebraic-stack_agda0000_doc_17165 | module TrustMe where
open import Data.String
open import Data.String.Unsafe
open import Data.Unit.Polymorphic using (⊤)
open import IO
import IO.Primitive as Prim
open import Relation.Binary.PropositionalEquality
open import Relation.Nullary
-- Check that trustMe works.
testTrustMe : IO ⊤
testTrustMe with "apa" ≟ "a... |
algebraic-stack_agda0000_doc_17166 | -- Mapping of Haskell types to Agda Types
module Foreign.Haskell.Types where
open import Prelude
open import Builtin.Float
{-# FOREIGN GHC import qualified GHC.Float #-}
{-# FOREIGN GHC import qualified Data.Text #-}
HSUnit = ⊤
HSBool = Bool
HSInteger = Int
HSList = List
HSChar = Char
HSString = HSList HSChar
HSTe... |
algebraic-stack_agda0000_doc_17167 | open import Prelude
module Implicits.Resolution.Termination.Lemmas
where
open import Induction.WellFounded
open import Induction.Nat
open import Data.Fin.Substitution
open import Implicits.Syntax
open import Implicits.Syntax.Type.Unification
open import Implicits.Substitutions
open import Implicits.Substitutions.Le... |
algebraic-stack_agda0000_doc_4080 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- The Maybe type
------------------------------------------------------------------------
-- The definitions in this file are reexported by Data.Maybe.
module Data.Maybe.Core where
open import Level
data Maybe ... |
algebraic-stack_agda0000_doc_4081 | module Type.Identity.Proofs where
import Lvl
open import Structure.Function
open import Structure.Relator.Properties
open import Structure.Relator
open import Structure.Type.Identity
open import Type.Identity
open import Type
private variable ℓ ℓ₁ ℓ₂ ℓₑ ℓₑ₁ ℓₑ₂ ℓₚ : Lvl.Level
private variable T A B : Type{ℓ}
pri... |
algebraic-stack_agda0000_doc_4082 | -- Abstract constructors
module Issue476c where
module M where
data D : Set
abstract
data D where
c : D
x : M.D
x = M.c |
algebraic-stack_agda0000_doc_4083 | module Array.APL where
open import Array.Base
open import Array.Properties
open import Data.Nat
open import Data.Nat.DivMod hiding (_/_)
open import Data.Nat.Properties
open import Data.Fin using (Fin; zero; suc; raise; toℕ; fromℕ≤)
open import Data.Fin.Properties using (toℕ<n)
open import Data.Vec
open import Data.Ve... |
algebraic-stack_agda0000_doc_4084 | module Numeral.Natural.Coprime.Proofs where
open import Functional
open import Logic
open import Logic.Classical
open import Logic.Propositional
open import Logic.Propositional.Theorems
import Lvl
open import Numeral.Finite
open import Numeral.Natural
open import Numeral.Natural.Coprime
open import Numeral.Natura... |
algebraic-stack_agda0000_doc_4085 | {-# OPTIONS --universe-polymorphism #-}
-- {-# OPTIONS --verbose tc.records.ifs:15 #-}
-- {-# OPTIONS --verbose tc.constr.findInScope:15 #-}
-- {-# OPTIONS --verbose tc.term.args.ifs:15 #-}
-- {-# OPTIONS --verbose cta.record.ifs:15 #-}
-- {-# OPTIONS --verbose tc.section.apply:25 #-}
-- {-# OPTIONS --verbose tc.mod.ap... |
algebraic-stack_agda0000_doc_4086 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- The Stream type and some operations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --sized-types #-}
module Codata.Stream where
open import Size
open im... |
algebraic-stack_agda0000_doc_4087 | ------------------------------------------------------------------------------
-- ABP auxiliary lemma
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIO... |
algebraic-stack_agda0000_doc_4088 | -- Andreas, 2019-02-24, issue #3457
-- Error messages for illegal as-clause
import Agda.Builtin.Nat Fresh-name as _
-- Previously, this complained about a duplicate module definition
-- with unspeakable name.
-- Expected error:
-- Not in scope: Fresh-name
|
algebraic-stack_agda0000_doc_4089 | module Classes where
open import Agda.Primitive
open import Agda.Builtin.Equality
open import Relation.Binary.PropositionalEquality.Core
open ≡-Reasoning
id : ∀ {ℓ} {A : Set ℓ} → A → A
id x = x
_$_ : ∀ {ℓ} {A B : Set ℓ} → (A → B) → A → B
_$_ = id
_∘_ : ∀ {ℓ} {A B C : Set ℓ} → (B → C) → (A → B) → A → C
f ∘ g = λ ... |
algebraic-stack_agda0000_doc_4090 |
data Bool : Set where
true false : Bool
record Top : Set where
foo : Top
foo with true
... | true = _
... | false = top
where
top = record{ } -- the only purpose of this was to force
-- evaluation of the with function clauses
-- which were in an __IMPOSSIBLE__ stat... |
algebraic-stack_agda0000_doc_4091 | open import Prelude
open import Nat
open import dynamics-core
open import contexts
module lemmas-disjointness where
-- disjointness is commutative
##-comm : {A : Set} {Δ1 Δ2 : A ctx} → Δ1 ## Δ2 → Δ2 ## Δ1
##-comm (π1 , π2) = π2 , π1
-- the empty context is disjoint from any context
empty-disj : {A : Set} (Γ... |
algebraic-stack_agda0000_doc_4092 | {-# OPTIONS --safe #-}
module Cubical.Algebra.Group.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Structure
open import Cubical.Foundations.GroupoidLaws hiding (assoc)
open import Cubical.Data.Sigma
open import Cubical.Algebra.Semigrou... |
algebraic-stack_agda0000_doc_4093 | {-# OPTIONS --safe #-}
module Cubical.HITs.Cost where
open import Cubical.HITs.Cost.Base
|
algebraic-stack_agda0000_doc_4094 | {- 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 Level using (0ℓ)
open import Util.Prelude
-- This module i... |
algebraic-stack_agda0000_doc_4095 | module Cats.Category.Setoids.Facts where
open import Cats.Category
open import Cats.Category.Setoids using (Setoids)
open import Cats.Category.Setoids.Facts.Exponentials using (hasExponentials)
open import Cats.Category.Setoids.Facts.Initial using (hasInitial)
open import Cats.Category.Setoids.Facts.Products
using ... |
algebraic-stack_agda0000_doc_3696 | {- 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 Util.Prelude
-- This module defines types used in the specificat... |
algebraic-stack_agda0000_doc_3697 | {-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Properties {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Type... |
algebraic-stack_agda0000_doc_3698 | module Self where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong; sym)
data B : Set where
T : B
F : B
_&&_ : B -> B -> B
infixl 20 _&&_
T && T = T
T && F = F
F && _ = F
_||_ : B -> B -> B
infixl 15 _||_
T || _ = T
F || T = T
F || F = F
p||p≡p : ∀ (p : B) -> p || p ≡ p
p||p≡p ... |
algebraic-stack_agda0000_doc_3699 | module my-vector where
open import nat
open import bool
open import eq
data 𝕍 {ℓ}(A : Set ℓ) : ℕ → Set ℓ where
[] : 𝕍 A 0
_::_ : {n : ℕ} (x : A) (xs : 𝕍 A n) → 𝕍 A (suc n)
infixr 6 _::_ _++𝕍_
_++𝕍_ : ∀ {ℓ} {A : Set ℓ}{n m : ℕ} →
𝕍 A n → 𝕍 A m → 𝕍 A (n + m)
[] ++𝕍 ys = ys
(x :: xs) ++𝕍 ys = x ... |
algebraic-stack_agda0000_doc_3700 | -- 2016-01-05, Jesper: In some cases, the new unifier is still too restrictive
-- when --cubical-compatible is enabled because it doesn't do generalization of datatype
-- indices. This should be fixed in the future.
-- 2016-06-23, Jesper: Now fixed.
{-# OPTIONS --cubical-compatible #-}
data _≡_ {a} {A : Set a} (x :... |
algebraic-stack_agda0000_doc_3701 |
module _ where
module M (A : Set) where
record R : Set where
postulate
B : Set
postulate
A : Set
r : M.R A
module M' = M A
open import Agda.Builtin.Reflection
open import Agda.Builtin.List
postulate
any : {A : Set} → A
macro
m : Term → TC _
m goal =
bindTC (inferType goal) λ goal-type →... |
algebraic-stack_agda0000_doc_3702 | {-# OPTIONS --no-positivity-check #-}
module Clowns where
import Equality
import Isomorphism
import Derivative
import ChainRule
open import Sets
open import Functor
open import Zipper
open import Dissect
open Functor.Recursive
open Functor.Semantics
-- Natural numbers
NatF : U
NatF = K [1] + Id
Nat : Set
Nat = μ N... |
algebraic-stack_agda0000_doc_3703 |
module Numeric.Nat.GCD.Properties where
open import Prelude
open import Numeric.Nat.Properties
open import Numeric.Nat.Divide
open import Numeric.Nat.Divide.Properties
open import Numeric.Nat.GCD
open import Numeric.Nat.GCD.Extended
open import Tactic.Nat
open import Tactic.Cong
gcd-is-gcd : ∀ d a b → gcd! a b ≡ d →... |
algebraic-stack_agda0000_doc_3704 | {-# OPTIONS --safe #-}
module Cubical.Algebra.CommAlgebra.QuotientAlgebra where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Powerset using (_∈_)
open import Cubical.HITs.SetQuotients hiding (_/_)
open import Cubical.Algebra.CommRing
open import Cubic... |
algebraic-stack_agda0000_doc_3705 | -- Example by Ian Orton
{-# OPTIONS --rewriting #-}
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
_∧_ : Bool → Bool → Bool
true ∧ y = y
false ∧ y = false
data ⊥ : Set where
⊥-elim : ∀ {a} {A : Set a} → ⊥ → A
⊥-elim ()
¬_ : ∀ {a} → Set a → Set a
¬ A = A → ⊥
contradiction : ∀ {a b} {A : Set a} {B... |
algebraic-stack_agda0000_doc_3706 | {-# OPTIONS --without-K #-}
open import Base
open import Homotopy.Pushout
open import Homotopy.VanKampen.Guide
{-
This module provides the function code⇒path
for the homotopy equivalence for
van Kampen theorem.
-}
module Homotopy.VanKampen.CodeToPath {i} (d : pushout-diag i)
(l : legend i (pushout-diag.C d))... |
algebraic-stack_agda0000_doc_3707 | module Example.Test where
open import Data.Maybe using (Is-just)
open import Prelude.Init
open import Prelude.DecEq
open import Prelude.Decidable
_ : (¬ ¬ ((true , true) ≡ (true , true)))
× (8 ≡ 18 ∸ 10)
_ = auto
|
algebraic-stack_agda0000_doc_3708 | -- Export only the experiments that are expected to compile (without
-- any holes)
{-# OPTIONS --cubical --no-import-sorts #-}
module Cubical.Experiments.Everything where
open import Cubical.Experiments.Brunerie public
open import Cubical.Experiments.EscardoSIP public
open import Cubical.Experiments.Generic public
ope... |
algebraic-stack_agda0000_doc_3709 | module Web.URI.Port where
open import Web.URI.Port.Primitive public using ( Port? ; :80 ; ε )
|
algebraic-stack_agda0000_doc_3710 | {-# OPTIONS --experimental-irrelevance #-}
-- {-# OPTIONS -v tc:10 #-}
module ExplicitLambdaExperimentalIrrelevance where
postulate
A : Set
T : ..(x : A) -> Set -- shape irrelevant type
test : .(a : A) -> T a -> Set
test a = λ (x : T a) -> A
-- this should type check and not complain about irrelevance of a
modu... |
algebraic-stack_agda0000_doc_3711 | module Numeral.Integer where
open import Data.Tuple
open import Logic
import Lvl
open import Numeral.Natural
open import Numeral.Natural.Oper
open import Relator.Equals
open import Type
open import Type.Quotient
-- Equivalence relation of difference equality.
-- Essentially (if one would already work in the inte... |
algebraic-stack_agda0000_doc_12480 | ------------------------------------------------------------------------
-- A definitional interpreter
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
module Lambda.Delay-monad.Interpreter where
open import Equality.Propositional
open import Prelude
open import ... |
algebraic-stack_agda0000_doc_12481 | {-
This file contains:
Properties of FreeGroupoid:
- Induction principle for the FreeGroupoid on hProps
- ∥freeGroupoid∥₂ is a Group
- FreeGroup A ≡ ∥ FreeGroupoid A ∥₂
-}
{-# OPTIONS --safe #-}
module Cubical.HITs.FreeGroupoid.Properties where
open import Cubical.HITs.FreeGroupoid.Base
open import Cubical.HITs.Fr... |
algebraic-stack_agda0000_doc_12482 | {- 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 ... |
algebraic-stack_agda0000_doc_12483 | module Data.List.Primitive where
-- In Agda 2.2.10 and below, there's no FFI binding for the stdlib
-- List type, so we have to roll our own. This will change.
data #List (X : Set) : Set where
[] : #List X
_∷_ : X → #List X → #List X
{-# COMPILED_DATA #List [] [] (:) #-}
|
algebraic-stack_agda0000_doc_12484 | {-# OPTIONS --safe --experimental-lossy-unification #-}
-- This file could be proven using the file Sn
-- However the proofs are easier than in Sn
-- And so kept for pedagologic reasons
module Cubical.ZCohomology.CohomologyRings.S1 where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Functio... |
algebraic-stack_agda0000_doc_12485 | {-# OPTIONS --type-in-type
--no-termination-check
--no-positivity-check #-}
module IMDesc where
--********************************************
-- Prelude
--********************************************
-- Some preliminary stuffs, to avoid relying on the stdlib
--****************
-- Sigma and ... |
algebraic-stack_agda0000_doc_12486 |
module Lib.Fin where
open import Lib.Nat
open import Lib.Bool
open import Lib.Id
data Fin : Nat -> Set where
zero : {n : Nat} -> Fin (suc n)
suc : {n : Nat} -> Fin n -> Fin (suc n)
fromNat : (n : Nat) -> Fin (suc n)
fromNat zero = zero
fromNat (suc n) = suc (fromNat n)
toNat : {n : Nat} -> Fin n -> Nat
toN... |
algebraic-stack_agda0000_doc_12487 | ------------------------------------------------------------------------
-- Integer division
------------------------------------------------------------------------
module Data.Nat.DivMod where
open import Data.Nat
open import Data.Nat.Properties
open SemiringSolver
open import Data.Fin as Fin using (Fin; zero; suc;... |
algebraic-stack_agda0000_doc_12488 | {-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
-- {-# OPTIONS --without-K #-}
-- [1] Hofmann, Martin and Thomas Streicher (1998). “The groupoid
-- interpretation on type theory”. In: Twenty-five Years of
-- Constru... |
algebraic-stack_agda0000_doc_12489 | -- Jesper, 2019-05-20: When checking confluence of two rewrite rules,
-- we disable all reductions during unification of the left-hand
-- sides. However, we should not disable reductions at the type-level,
-- as shown by this (non-confluent) example.
{-# OPTIONS --rewriting --confluence-check #-}
open import Agda.Bui... |
algebraic-stack_agda0000_doc_12490 |
module UniDB.Morph.Weaken where
open import UniDB.Spec
--------------------------------------------------------------------------------
data Weaken : MOR where
weaken : {γ : Dom} (δ : Dom) → Weaken γ (γ ∪ δ)
instance
iLkWeaken : {T : STX} {{vrT : Vr T}} → Lk T Weaken
lk {{iLkWeaken}} (weaken δ) i = vr (wk δ ... |
algebraic-stack_agda0000_doc_12491 | -- Jesper, 2017-01-23: when instantiating a variable during unification,
-- we should check that the type of the variable is equal to the type
-- of the equation (and not just a subtype of it). See Issue 2407.
open import Agda.Builtin.Equality
open import Agda.Builtin.Size
data D : Size → Set where
J= : ∀ {ℓ} {s : ... |
algebraic-stack_agda0000_doc_12492 | -- WARNING: This file was generated automatically by Vehicle
-- and should not be modified manually!
-- Metadata
-- - Agda version: 2.6.2
-- - AISEC version: 0.1.0.1
-- - Time generated: ???
open import AISEC.Utils
open import Data.Real as ℝ using (ℝ)
open import Data.List
module MyTestModule where
f : Tensor ℝ (... |
algebraic-stack_agda0000_doc_12493 | module Numeral.Natural.Oper.Proofs.Structure where
open import Logic.Predicate
open import Numeral.Natural
open import Numeral.Natural.Oper.Proofs
open import Numeral.Natural.Oper
open import Relator.Equals
open import Relator.Equals.Proofs
open import Structure.Operator.Monoid
instance
[+]-monoid : Monoid(_+_)
M... |
algebraic-stack_agda0000_doc_12494 | {-# OPTIONS --without-K #-}
module Computability.Function where
open import Computability.Prelude
import Function
variable
l₀ l₁ : Level
Injective : {A : Set l₀}{B : Set l₁} → (A → B) → Set _
Injective = Function.Injective _≡_ _≡_
Surjective : {A : Set l₀}{B : Set l₁} → (A → B) → Set _
Surjective {A = A} {B = B} ... |
algebraic-stack_agda0000_doc_12495 | {-# OPTIONS --safe #-}
module Cubical.HITs.FreeGroup where
open import Cubical.HITs.FreeGroup.Base public
open import Cubical.HITs.FreeGroup.Properties public
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.