id stringlengths 27 136 | text stringlengths 4 1.05M |
|---|---|
algebraic-stack_agda0000_doc_4408 | module BTree.Complete.Alternative.Correctness {A : Set} where
open import BTree {A}
open import BTree.Equality {A}
open import BTree.Equality.Properties {A}
open import BTree.Complete.Base {A}
open import BTree.Complete.Base.Properties {A}
open import BTree.Complete.Alternative {A} renaming (Complete to Complete' ; ... |
algebraic-stack_agda0000_doc_4409 | import Bundles
import Construct.DirectProduct
import Definitions
import Definitions.Semiring
import Morphism.Structures
import Properties.RingWithoutOne
import Structures
|
algebraic-stack_agda0000_doc_4410 | {-# OPTIONS --show-irrelevant #-}
-- {-# OPTIONS -v tc:20 #-}
open import Agda.Primitive
open import Issue2408.LevelDependentOnIrrelevant
-- Provoke error message mentioning (â a)
provokeError : Setâ
provokeError = X
where
X = _
F' : (a : A) â X
F' = F
-- If #2408 is solved by replacing irrelevant vars in ... |
algebraic-stack_agda0000_doc_4411 |
module HasSalvation where
open import OscarPrelude
record HasSalvation (A : Set) : Setâ
where
field
â·_ : A â Set
open HasSalvation ⊠⊠⊠public
{-# DISPLAY HasSalvation.â·_ _ = â·_ #-}
record HasDecidableSalvation (A : Set) : Setâ
where
field
⊠hasSalvation ⊠: HasSalvation A
â·?_ : (x : A) â Dec $... |
algebraic-stack_agda0000_doc_4412 | -- Andreas, 2014-04-23 test case by Andrea Vezzosi
{-# OPTIONS --sized-types --copatterns #-}
-- {-# OPTIONS --show-implicit -v term:60 #-}
module _ where
open import Common.Size
-- Invalid coinductive record, since not recursive.
record âž (A : Size â Set) (i : Size) : Set where
coinductive -- This should b... |
algebraic-stack_agda0000_doc_4414 | {-# OPTIONS --without-K --safe #-}
open import Algebra using (Monoid)
module Data.FingerTree.MonoidSolver {ââ ââ} (mon : Monoid ââ ââ) where
open import Data.Nat as â using (â; suc; zero)
open import Data.List as List using (List; _â·_; []; foldr; _++_)
open import Data.Vec as Vec using (Vec; _â·_; [])
open import Dat... |
algebraic-stack_agda0000_doc_4415 | {-# OPTIONS --cubical --safe #-}
module Data.Pi where
open import Data.Pi.Base public
|
algebraic-stack_agda0000_doc_4413 | {-# OPTIONS --allow-unsolved-metas #-}
module _ where
open import Agda.Builtin.Equality
module Caseâ where
postulate
I : Set
P : I â Set
variable
p : P _
postulate
D : P _ â Set
d : D p
module Caseâ where
postulate
I : Set
P : I â Set
Q : â n â P n â Set
variable
q ... |
algebraic-stack_agda0000_doc_4000 |
module Prelude.Variables where
open import Agda.Primitive
open import Agda.Builtin.Nat
open import Agda.Builtin.List
variable
â ââ ââ ââ : Level
A B C : Set â
F M : Set ââ â Set ââ
x y z : A
xs ys zs : List A
n m : Nat
|
algebraic-stack_agda0000_doc_4001 | -- Solver for functors
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Functor renaming (id to idF)
module Experiment.Categories.Solver.MultiFunctor {o â e} where
import Categories.Morphism.Reasoning as MR
open import Level
open import Relation.Binary using (Rel)
infixr 9... |
algebraic-stack_agda0000_doc_4002 | -- Andreas, 2017-05-17, issue #2574 reported by G. Allais
open import Issue2574Import -- The imported module should be clickable.
open import Issue2574ImportBlank -- The imported module should be clickable.
|
algebraic-stack_agda0000_doc_4003 | -- Currently this test case is broken. Once Issue 3451 has been fixed
-- it should be moved to test/Fail (and this comment should be
-- removed).
-- The option --guardedness turns off sized types.
{-# OPTIONS --guardedness #-}
open import Agda.Builtin.Size
record Stream (A : Set) (i : Size) : Set where
coinductiv... |
algebraic-stack_agda0000_doc_4004 | module Class.MonadTrans where
open import Class.Monad
open import Level
record MonadTrans {a} (T : (Set a -> Set a) -> Set a -> Set a) : Set (suc a) where
field
embed : {A : Set a} {M : Set a -> Set a} {{_ : Monad M}} -> M A -> T M A
open MonadTrans {{...}} public
|
algebraic-stack_agda0000_doc_4005 | module Numeral.Natural.Relation.Order where
import Lvl
open import Functional
open import Logic
open import Logic.Propositional
open import Logic.Predicate
open import Numeral.Natural
open import Numeral.Natural.Oper
open import Relator.Equals
open import Relator.Equals.Proofs
open import Relator.Ordering
-- Inequali... |
algebraic-stack_agda0000_doc_4006 | module Eq.ObsTheory where
open import Prelude
open import T
open import DynTheory
open import SubstTheory
open import Contexts
open import Eq.Defs
open import Eq.KleeneTheory
open ObservEq
---- Proofs about observational equivalence
-- observational equivalence being an equiv reln follows trivially from kleene equiv... |
algebraic-stack_agda0000_doc_4007 | {-# OPTIONS --without-K #-}
module function.fibration where
open import level
open import sum
open import equality.core
open import function.core
open import function.isomorphism.core
open import function.isomorphism.coherent
open import function.isomorphism.lift
open import function.isomorphism.univalence
open impor... |
algebraic-stack_agda0000_doc_4008 | {-# OPTIONS --without-K --rewriting #-}
open import HoTT
module Reflective where
record ReflectiveSubuniverse {â} : Type (lsucc â) where
field
P : Type â â Type â
R : Type â â Type â
η : (A : Type â) â A â R A
-- replete : (A B : Type â) â P A â A â B â P B
|
algebraic-stack_agda0000_doc_4010 | ------------------------------------------------------------------------
-- Pi with partiality algebra families as codomains
------------------------------------------------------------------------
{-# OPTIONS --erased-cubical --safe #-}
module Partiality-algebra.Pi where
open import Equality.Propositional.Cubical
o... |
algebraic-stack_agda0000_doc_4011 | -- {-# OPTIONS -v tc.with.strip:40 #-}
module Issue824 where
record R : Set where
data D : Set â Setâ where
d : â {A} â D A â D A
postulate
dâ² : D R
data P : R â D R â Setâ where
p : {x : R} {y : D R} â P x y â P x (d y)
Foo : P _ (d dâ²) â Setâ
Foo (p _) with Set
Foo (p _) | _ = Set
-- Bug.agda:18,1-19,20
-... |
algebraic-stack_agda0000_doc_4012 | ------------------------------------------------------------------------
-- Call-by-value (CBV) reduction in pure type systems (PTS)
------------------------------------------------------------------------
module Pts.Reduction.Cbv where
open import Data.Fin.Substitution
open import Data.Fin.Substitution.ExtraLemmas
o... |
algebraic-stack_agda0000_doc_4013 | module LocalVsImportedModuleClash where
X = TODO--This-shouldn't-happen-if-the-scope-checker-does-it's-job
|
algebraic-stack_agda0000_doc_4014 | {-# OPTIONS --without-K --safe #-}
module Categories.NaturalTransformation.NaturalIsomorphism.Equivalence where
-- a certain notion of equivalence between Natural Isomorphisms.
open import Level
open import Data.Product using (_Ã_; _,_; map; zip)
open import Relation.Binary using (IsEquivalence)
open import Categori... |
algebraic-stack_agda0000_doc_4015 | {-# OPTIONS --safe #-}
module Cubical.Algebra.Group.Instances.DiffInt where
open import Cubical.HITs.SetQuotients
open import Cubical.Foundations.Prelude
open import Cubical.Data.Int.MoreInts.DiffInt renaming (†to â€Type ; _+_ to _+â€_ ; _-_ to _-â€_)
open import Cubical.Algebra.Group.Base
open import Cubical.Algebra.Se... |
algebraic-stack_agda0000_doc_4009 | {-# OPTIONS --safe #-}
module Cubical.Categories.Morphism where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Sigma
open import Cubical.Categories.Category
private
variable
â â' : Level
-- C needs to be explicit for these definitions as Agda can't infer it
module _ (C : Category â â') where... |
algebraic-stack_agda0000_doc_4464 | {-# OPTIONS --without-K --rewriting #-}
{-
Adapted from Ulrik's work in Lean (released under Apache License 2.0)
https://github.com/leanprover/lean/blob/master/hott/homotopy/cellcomplex.hlean
-}
open import HoTT renaming (pt to ptâ)
open import homotopy.DisjointlyPointedSet
module cw.CW {i} where
open import cw... |
algebraic-stack_agda0000_doc_4465 | module MLib.Finite where
open import MLib.Prelude
import MLib.Fin.Parts as P
import MLib.Fin.Parts.Simple as PS
open import MLib.Prelude.RelProps
open import Data.List.All as All using (All; []; _â·_) hiding (module All)
open import Data.List.Any as Any using (Any; here; there) hiding (module Any)
import Data.List.Mem... |
algebraic-stack_agda0000_doc_4466 | open import Prelude
open import MJ.Classtable.Core
module MJ.LexicalScope c where
open import Data.List
open import Data.List.Membership.Propositional
open import MJ.Types
Ctx : Set
Ctx = List (Ty c)
Var : Ctx â Ty c â Set
Var Î a = a â Î
_+local_ : Ctx â Ty c â Ctx
_+local_ Î a = a â· Î
|
algebraic-stack_agda0000_doc_4467 | {-# OPTIONS --no-qualified-instances #-}
module JVM.Printer.Printer {t} (T : Set t) where
open import Function using (_$_; _â_)
open import Data.Unit
open import Data.Nat
open import Data.Nat.Show as Nat
open import Data.Product
open import Data.List as List
open import Data.List.Relation.Unary.All
open import Relatio... |
algebraic-stack_agda0000_doc_4468 | {-# OPTIONS --without-K -v 2 #-}
module Leftovers.Monad where
open import Category.Functor
open import Category.Applicative
open import Category.Monad
open import Level
open import Data.Unit
open import Data.List
import Reflection as TC
open import Reflection.TypeChecking.Monad.Instances
open import Reflection.Abst... |
algebraic-stack_agda0000_doc_4469 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.DStructures.Structures.Higher 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.Function
open import Cu... |
algebraic-stack_agda0000_doc_4470 | open import Agda.Primitive using (lzero; lsuc; _â_ ;Level)
open import Relation.Binary.PropositionalEquality using (_â¡_; refl; sym; setoid; cong; trans)
import Function.Equality
open import Relation.Binary using (Setoid)
import Categories.Category
import Categories.Functor
import Categories.Category.Instance.Setoids
i... |
algebraic-stack_agda0000_doc_4471 |
module Issue759a where
import Common.Level
abstract
record Wrap (A : Set) : Set where
field wrapped : A
open Wrap public
wrap : {A : Set} â A â Wrap A
wrap a = record { wrapped = a }
-- WAS: Broken error message:
-- Not in scope:
-- Issue759a.recCon-NOT-PRINTED at
-- when checking the definition of wrap... |
algebraic-stack_agda0000_doc_4472 |
open import SOAS.Common
-- Free construction with respect to a forgetful functor between categories
module SOAS.Construction.Free {â ð : Category 1â 0â 0â}
(U : Functor ð â) where
open import Categories.Adjoint
import Categories.Morphism.Reasoning as MR
open import Categories.Categor... |
algebraic-stack_agda0000_doc_4473 | -- The following deeply left-nested expression illustrates both a
-- problem in a previous implementation of the occurrence machinery,
-- and a problem in the one that is current at the time of writing.
F : Set â Set
F X = ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((... |
algebraic-stack_agda0000_doc_4474 | ------------------------------------------------------------------------
-- Function setoids and related constructions
------------------------------------------------------------------------
module Relation.Binary.FunctionSetoid where
open import Data.Function
open import Relation.Binary
infixr 0 _â_ _â¶_ _âš_ _â¡âš_
... |
algebraic-stack_agda0000_doc_4475 | ------------------------------------------------------------------------
-- A binary representation of natural numbers
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
import Erased.Without-box-cong
module Nat.Binary
{câº}
(eq : â {a ... |
algebraic-stack_agda0000_doc_4477 | open import Structures
open import SacTy
module ExtractSac where
open import Data.String as S hiding (_++_) renaming (_â_ to _âs_)
open import Data.List as L hiding (_++_)
open import Data.List.Categorical
open import Data.List.Properties as L
open import Data.Nat as N
open import Agda.Builtin.Nat using (div-helper; m... |
algebraic-stack_agda0000_doc_4478 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties satisfied by strict partial orders
------------------------------------------------------------------------
open import Relation.Binary
module Relation.Binary.Properties.StrictPartialOrder
{sâ... |
algebraic-stack_agda0000_doc_4479 | module Function.DomainRaise where
open import Data
open import Data.Boolean
import Functional as Fn
import Lvl
open import Numeral.Natural
open import Numeral.Natural.Oper.Comparisons
open import Syntax.Number
open import Type
private variable â ââ ââ : Lvl.Level
private variable T X Y Z : Type{â}
private v... |
algebraic-stack_agda0000_doc_4476 | module Structure.Operator.Monoid.Submonoid where
import Lvl
open import Logic
open import Logic.Predicate
open import Logic.Predicate.Equiv
open import Sets.PredicateSet renaming (_â¡_ to _â¡â_)
open import Structure.Setoid
open import Structure.Operator.Monoid
open import Structure.Operator.Properties
open import ... |
algebraic-stack_agda0000_doc_3745 | {-# OPTIONS --cubical #-}
module Multidimensional.Data.DirNum.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Empty
open import Cubical.Data.Prod
open import Cubical.Data.Bool
open import Cubical.Data.Nat
open import Cubical.Relation.Nullary
open import Multidimensional.Data.Dir
op... |
algebraic-stack_agda0000_doc_3746 | {-# OPTIONS --verbose=10 #-}
module leafs where
open import Data.Nat
open import Data.Vec
open import Agda.Builtin.Sigma
open import Data.Product
open import Data.Fin using (fromâ)
open import trees
open import optics
open import lemmas
leafsTree : {A : Set} -> Tree A -> â[ n ] (Vec A n à (Vec ... |
algebraic-stack_agda0000_doc_3747 | {-# OPTIONS --without-K --safe #-}
module Categories.Yoneda where
-- Yoneda Lemma. In total, provides:
-- * the Yoneda Embedding (called embed here) from any Category C into Presheaves C
-- Worth noticing that there is no 'locally small' condition here; however, if one looks at
-- the levels involved, there is in... |
algebraic-stack_agda0000_doc_3748 | module Pi.Everything where
open import Pi.Syntax -- Syntax of Pi
open import Pi.Opsem -- Abstract machine semantics of Pi
open import Pi.AuxLemmas -- Some auxiliary lemmas about opsem for forward/backward deterministic proof
open import Pi.NoRepeat -- Forward/backward deterministic lemmas and Non-repeating ... |
algebraic-stack_agda0000_doc_3749 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Ints.DiffInt where
open import Cubical.HITs.Ints.DiffInt.Base public
open import Cubical.HITs.Ints.DiffInt.Properties public
|
algebraic-stack_agda0000_doc_3750 | {-
This second-order signature was created from the following second-order syntax description:
syntax Sum | S
type
_â_ : 2-ary | l30
term
inl : α -> α â β
inr : β -> α â β
case : α â β α.γ β.γ -> γ
theory
(lβ) a : α f : α.γ g : β.γ |> case (inl(a), x.f[x], y.g[y]) = f[a]
(rβ) b : β f... |
algebraic-stack_agda0000_doc_3751 | -- New feature by Jesper Cockx in commit be89d4a8b264dd2719cb8c601a2c7f45a95ba220 :
-- disabling the universe check for a data or record type.
-- Andreas, 2018-10-27, re issue #3327: restructured test cases.
module _ where
-- Pragma is naturally attached to definition.
module DataDef where
data U : Set
T : U â... |
algebraic-stack_agda0000_doc_3752 | open import Nat
open import Prelude
open import core
open import contexts
open import typed-elaboration
open import lemmas-gcomplete
open import lemmas-complete
open import progress-checks
open import finality
module cast-inert where
-- if a term is compelete and well typed, then the casts inside are all
-- identi... |
algebraic-stack_agda0000_doc_3753 | -- Andreas, 2018-11-03, issue #3364
--
-- Better error when trying to import with new qualified module name.
open import Agda.Builtin.Nat as Builtin.Nat
-- WAS: Error:
-- Not in scope:
-- as at ...
-- when scope checking as
-- NOW: Warning
-- `as' must be followed by an unqualified name
-- when scope checking the ... |
algebraic-stack_agda0000_doc_3754 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
open import Cubical.Relation.Binary.Raw
module Cubical.Relation.Binary.Reasoning.PartialOrder
{c â} {A : Type c} (P : PartialOrder A â) where
open PartialOrder P
import Cubical.Relation.Binary.Raw.Construct.NonStrictToStrict _â€_... |
algebraic-stack_agda0000_doc_3755 | -- exercises
-- * basic logic properties (implication, and, or, bot, not, forall, exists)
-- * data types
-- * records
-- * non-dep, non-rec, non-indexed case splits
-- * including elimination constants as hints
-- * hidden arguments
open import Auto.Prelude
h0 : (A : Set) â A â A
h0 = {!!}
--h0 = λ A z â z
h1 : (A... |
algebraic-stack_agda0000_doc_3756 | module TLP02 where
open import Data.Bool
open import Data.Nat
open import Data.String
open import Relation.Binary.PropositionalEquality
as PropEq using (_â¡_; refl)
-- ----- Staråã®å®çŸ© -----
data Star : Set where
NIL : Star
TRU : Star
N : â â Star
S : String â Star
C : Star â Star â Star
... |
algebraic-stack_agda0000_doc_3757 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Definitions of algebraic structures defined over some other
-- structure, like modules and vector spaces
--
-- Terminology of bundles:
-- * There are both *semimodules* and *modules*.
-- - For M an R-semimodule... |
algebraic-stack_agda0000_doc_3758 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- The universal binary relation
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Relation.Binary.Construct.Always where
open import Relation.Bina... |
algebraic-stack_agda0000_doc_3759 |
module Oscar.Category.Action where
open import Oscar.Category.Setoid
open import Oscar.Function
open import Oscar.Level
record Action {ð¬} (â : Set ð¬) ðð¬ ðð®
: Set (ð¬ â lsuc (ðð¬ â ðð®))
where
field
ð : â â Setoid ðð¬ ðð®
⊠isSetoid ⊠: â {x} â IsSetoid (Setoid.â (ð x)) ðð®
⥠: â â... |
algebraic-stack_agda0000_doc_3744 | module Verifier where
open import ModusPonens using (modusPonens)
check : â {P Q : Set} â (P â Q) â P â Q
check = modusPonens
|
algebraic-stack_agda0000_doc_4320 | import MJ.Classtable.Core as Core
module MJ.Classtable.Membership {c}(Ct : Core.Classtable c) where
open Core c
open Classtable Ct
open import Prelude
open import Data.Star
open import Data.Product hiding (Σ)
open import Data.List
open import Data.List.Relation.Unary.Any
open import Data.List.Relation.Unary.Any.Pro... |
algebraic-stack_agda0000_doc_4321 | {-# OPTIONS --without-K --exact-split #-}
module rings-with-properties where
import rings
open rings public
--------------------------------------------------------------------------------
{- Commutative rings -}
is-commutative-Ring :
{ l : Level} â Ring l â UU l
is-commutative-Ring R =
(x y : type-Ring R) â I... |
algebraic-stack_agda0000_doc_4323 | ------------------------------------------------------------------------
-- Reasoning about _â_
--
-- NOTE: we donât use Relation.Binary.IsEquivalence here, since weâre reasoning
-- about a heterogeneous equivalence relation (i.e., the types of the operands
-- of _â_, which are themselves types, can be of different lev... |
algebraic-stack_agda0000_doc_4324 | {-# OPTIONS --rewriting #-}
module Properties.StrictMode where
import Agda.Builtin.Equality.Rewrite
open import Agda.Builtin.Equality using (_â¡_; refl)
open import FFI.Data.Either using (Either; Left; Right; mapL; mapR; mapLR; swapLR; cond)
open import FFI.Data.Maybe using (Maybe; just; nothing)
open import Luau.Heap... |
algebraic-stack_agda0000_doc_4325 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- An inductive definition of the heterogeneous suffix relation
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Relation.Binary.Suffix.H... |
algebraic-stack_agda0000_doc_4326 |
module PredicateName where
open import OscarPrelude
record PredicateName : Set
where
constructor âš_â©
field
name : Nat
open PredicateName public
instance EqPredicateName : Eq PredicateName
Eq._==_ EqPredicateName _ = decEqâ (cong name) â (_â_ on name $ _)
|
algebraic-stack_agda0000_doc_4327 | {-# OPTIONS --copatterns --sized-types #-}
open import Size
open import Function
open import Relation.Binary
open import Relation.Binary.PropositionalEquality as P
open â¡-Reasoning
open import Algebra.Structures using (IsCommutativeSemiring; IsCommutativeMonoid)
open import Data.Nat
open import Data.Nat.Properties u... |
algebraic-stack_agda0000_doc_4328 |
module _ where
open import Agda.Builtin.Reflection
open import Agda.Builtin.Unit
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
variable
A : Set
super-tac : Term â TC â€
super-tac hole = unify hole (lit (nat 101))
solver : Nat â Term â TC â€
solver n hole = unify hole (lit (nat (n + 1)))
foo : {@(... |
algebraic-stack_agda0000_doc_4329 | {-# OPTIONS --safe #-}
module Cubical.Algebra.NatSolver.HornerForms where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat hiding (isZero)
open import Cubical.Data.FinData
open import Cubical.Data.Vec
open import Cubical.Data.Bool using (Bool; true; false; if_then_else_)
private
variable
â ... |
algebraic-stack_agda0000_doc_4330 |
module Basic.Compiler.SplitCode where
open import Basic.Compiler.Code
open import Basic.AST
open import Basic.BigStep
open import Utils.Monoid
open import Data.Vec hiding (_++_; [_]; _â·Ê³_)
open import Data.Bool renaming (if_then_else_ to ifBool_then_else_)
open import Data.Nat
open import Data.List hiding ([_])
open... |
algebraic-stack_agda0000_doc_4331 | -- Andreas, 2016-05-13 Issue 1973 reported by Nisse
-- Problems with parameters to overloaded projections
-- {-# OPTIONS -v tc.proj.amb:100 #-}
-- {-# OPTIONS -v tc.deftype:100 #-}
record Râ : Setâ where
field
f : Set
open Râ public
postulate
F : â {a} â Set a â Set a
module M (_ : Setâ) where
record Râ... |
algebraic-stack_agda0000_doc_4332 | module Category.Monad.Reader {i}{I : Set i} where
open import Category.Applicative.Indexed
open import Category.Monad
open import Category.Monad.Predicate
open import Relation.Unary
open import Relation.Unary.PredicateTransformer
open import Data.Product
open import Data.Unit
open import Function
open import Level
Re... |
algebraic-stack_agda0000_doc_4333 | -- Andreas, 2019-03-25, issue #3647, reported and bisected by nad.
-- Regression introduced in refactoring a78d7f54e447cadf039da81b50ff40c81aa93909.
{-# OPTIONS --allow-unsolved-metas #-}
-- {-# OPTIONS -v 90 #-}
postulate
A : Set
P : A â Set
Q : A â A â Set
Q _ x = P x
record R (P : A â Set) : Set where
fie... |
algebraic-stack_agda0000_doc_4334 | module Test where
open import IO using (run; putStrLn)
import IO.Primitive as Prim using (IO)
open import Data.Nat.Show as Nat using (show)
open import Data.Unit using (â€)
open import Vector
main : Prim.IO â€
main = run (putStrLn (Nat.show (length gravityâ)))
|
algebraic-stack_agda0000_doc_4335 | module Logic.Linear where
open import Data.Nat using (â; zero; suc)
open import Data.Fin using (Fin; zero; suc)
open import Data.Vec using (Vec; []; _â·_; _++_; map)
open import Data.Empty using (â¥)
-- Operator precedences.
infix 10 _^⥠e?_ e!_
infixl 9 _â_ _&_
infixl 8 _â_ _â
_
infixl 7 _âž_
infixl 6 _â¡_
-- Primitive ... |
algebraic-stack_agda0000_doc_4322 | -- Andreas, 2017-01-12, issue #2386
-- Should be rejected:
data Eq (A : Set) : (x y : A) â Set where
refl : (x y : A) â Eq A x y
{-# BUILTIN EQUALITY Eq #-}
-- Expected error:
-- Wrong type of constructor of BUILTIN EQUALITY
-- when checking the pragma BUILTIN EQUALITY Eq
|
algebraic-stack_agda0000_doc_6368 | module Numeral.Real where
open import Data.Tuple
open import Logic
import Lvl
open import Numeral.Natural
open import Numeral.Natural.Oper
open import Numeral.Rational
open import Numeral.Rational.Oper
open import Relator.Equals
open import Type
open import Type.Quotient
-- TODO: This will not work, but it is th... |
algebraic-stack_agda0000_doc_6369 | ------------------------------------------------------------------------------
-- The division program is correct
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #... |
algebraic-stack_agda0000_doc_6370 | module Data.Num.Bij.Properties where
open import Data.Num.Bij renaming (_+B_ to _+_; _*B_ to _*_)
open import Data.List
open import Relation.Binary.PropositionalEquality as PropEq
using (_â¡_; _â¢_; refl; cong; sym; trans)
open PropEq.â¡-Reasoning
--------------------------------------------------------------------... |
algebraic-stack_agda0000_doc_6371 | {-# OPTIONS --safe #-}
module Cubical.Algebra.OrderedCommMonoid.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Structure
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.SIP using (TypeWithStr)
open import Cubical.Data.Sigma
open import Cubical.Algebra... |
algebraic-stack_agda0000_doc_6372 | {-# OPTIONS --allow-unsolved-metas #-}
-- {-# OPTIONS -v tc.conv.elim:100 #-}
module Issue814 where
record IsMonoid (M : Set) : Set where
field
unit : M
_*_ : M â M â M
record Monoid : Setâ where
field
carrier : Set
is-mon : IsMonoid carrier
record Structure (Struct : Setâ)
(HasS... |
algebraic-stack_agda0000_doc_6374 | open import Nat
open import Prelude
open import List
open import core
open import judgemental-erase
module moveerase where
-- type actions don't change the term other than moving the cursor
-- around
moveeraset : {t t' : ÏÌ} {ÎŽ : direction} â
(t + move ÎŽ +> t') â
(t ât) == (t' ât)
movee... |
algebraic-stack_agda0000_doc_6375 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Data.Bool.Properties where
open import Cubical.Core.Everything
open import Cubical.Functions.Involution
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Found... |
algebraic-stack_agda0000_doc_6376 |
-- There were some serious bugs in the termination checker
-- which were hidden by the fact that it didn't go inside
-- records. They should be fixed now.
module Issue222 where
record R (A : Set) : Set where
module M (a : A) where
-- Bug.agda:4,17-18
-- Panic: unbound variable A
-- when checking that the expressio... |
algebraic-stack_agda0000_doc_6377 | -- {-# OPTIONS -v scope.decl.trace:50 #-}
data D : Set where
D : Set
|
algebraic-stack_agda0000_doc_6378 | -- A Simple selection of modules with some renamings to
-- make my (your) life easier when starting a new agda module.
--
-- This includes standard functionality to work on:
-- 1. Functions,
-- 2. Naturals,
-- 3. Products and Coproducts (projections and injections are p1, p2, i1, i2).
-- 4. Finite Types (zero and s... |
algebraic-stack_agda0000_doc_6379 | module Control.Monad.Free.Quotiented where
open import Prelude
open import Data.List hiding (map)
open import Data.Fin.Sigma
open import Algebra
postulate
uip : isSet A
--------------------------------------------------------------------------------
-- Some functors
------------------------------------------------... |
algebraic-stack_agda0000_doc_6380 | ------------------------------------------------------------------------
-- Container combinators
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
module Indexed-container.Combinators where
open import Equality.Propositional
open import Logical-equivalence using ... |
algebraic-stack_agda0000_doc_6381 | module Lib.Vec where
open import Common.Nat renaming (zero to Z; suc to S)
open import Lib.Fin
open import Common.Unit
import Common.List -- using (List ; [] ; _â·_)
data Vec (A : Set) : Nat -> Set where
_â·_ : forall {n} -> A -> Vec A n -> Vec A (S n)
[] : Vec A Z
infixr 30 _++_
_++_ : {A : Set}{m n : Nat} ->... |
algebraic-stack_agda0000_doc_6382 | {-# OPTIONS --without-K #-}
module Agda.Builtin.Nat where
open import Agda.Builtin.Bool
data Nat : Set where
zero : Nat
suc : (n : Nat) â Nat
{-# BUILTIN NATURAL Nat #-}
infix 4 _==_ _<_
infixl 6 _+_ _-_
infixl 7 _*_
_+_ : Nat â Nat â Nat
zero + m = m
suc n + m = suc (n + m)
{-# BUILTIN NATPLUS _+_ #-}
_... |
algebraic-stack_agda0000_doc_6383 | {-# OPTIONS --allow-unsolved-metas #-}
open import Agda.Builtin.List
open import Agda.Builtin.Nat
infixl 6 _â·Ê³_
_â·Ê³_ : {A : Set} â List A â A â List A
[] â·Ê³ x = x â· []
(hd â· tl) â·Ê³ x = hd â· tl â·Ê³ x
infixl 5 _â·Ê³â²_
data InitLast {A : Set} : List A â Set where
[] : InitLast []
_â·Ê³â²_ : (xs : List A) (x :... |
algebraic-stack_agda0000_doc_6373 | {-# OPTIONS --rewriting #-}
module Properties.Subtyping where
open import Agda.Builtin.Equality using (_â¡_; refl)
open import FFI.Data.Either using (Either; Left; Right; mapLR; swapLR; cond)
open import FFI.Data.Maybe using (Maybe; just; nothing)
open import Luau.Subtyping using (_<:_; _â®:_; Tree; Language; ¬Language... |
algebraic-stack_agda0000_doc_12928 | {-# OPTIONS --cubical-compatible #-}
module Issue1025 where
data _â¡_ {A : Set} (x : A) : A â Set where
refl : x â¡ x
postulate mySpace : Set
postulate myPoint : mySpace
data Foo : myPoint â¡ myPoint â Set where
foo : Foo refl
test : {e : myPoint â¡ myPoint} â (a : Foo e) â (i : a â¡ a) â i â¡ refl
test foo refl = {... |
algebraic-stack_agda0000_doc_12929 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Non empty trie, basic type and operations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --sized-types #-}
open import Relation.Binary using (StrictTotal... |
algebraic-stack_agda0000_doc_12930 |
module Basic where
open import Prelude
data List (A : Set) : Set
data List A where
nil : List A
cons : A -> List A -> List A
append : {A : Set} -> List A -> List A -> List A
append nil ys = ys
append (cons x xs) ys = cons x (append xs ys)
record Equiv {A : Set} (R : A -> A -> Set) : Set
record Equiv {A} R wh... |
algebraic-stack_agda0000_doc_12931 | {-
This file contains:
- An implementation of the free groupoid (a free group that has no limitiations
over the high dimensional path structure). An intermediate construction used
to calculate the fundamental group of a Bouquet.
-}
{-# OPTIONS --safe #-}
module Cubical.HITs.FreeGroupoid.Base where
open import ... |
algebraic-stack_agda0000_doc_12932 | {-# OPTIONS --without-K --exact-split #-}
module encode-decode where
import 05-identity-types
open 05-identity-types public
record Lift {i j : Level} (A : UU i) : UU (i â j) where
field
raise : A
module Coprod where
code-left : {i j : Level} {A : UU i} {B : UU j} â A â (coprod A B) â (UU i)
code-left aâ (... |
algebraic-stack_agda0000_doc_12933 | ------------------------------------------------------------------------------
-- Properties of the mirror function
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism... |
algebraic-stack_agda0000_doc_12934 |
module UnequalTerms where
data Zero : Set where
data One : Set where one : One
err1 : Zero
err1 = one
err2 : One -> One
err2 = \(x : Zero) -> one
|
algebraic-stack_agda0000_doc_12935 | -- Andreas, 2015-02-26
-- {-# OPTIONS -v interaction:100 #-}
data D : Set where
c : D
goal : D
goal = {! !} -- C-c C-r gave a parse error here, as there was a (single) space.
g1 : D
g1 = {! !}
g2 : D
g2 = {! !}
-- works now
|
algebraic-stack_agda0000_doc_12936 | ------------------------------------------------------------------------
-- The Agda standard library
--
-- Code related to vector equality over propositional equality that
-- makes use of heterogeneous equality
------------------------------------------------------------------------
{-# OPTIONS --with-K --safe #-}
m... |
algebraic-stack_agda0000_doc_12937 | {-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Relation.Binary.Construct.Constant where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels using (hProp)
open import Cubical.Relation.Binary
open import Cubical.Structures.Carrier
-----... |
algebraic-stack_agda0000_doc_12939 | {-# OPTIONS --cubical #-}
module Numeral.Natural.Equiv.Path where
open import Data.Boolean.Equiv.Path
open import Functional
open import Logic.Propositional
open import Numeral.Natural.Oper.Comparisons
open import Numeral.Natural
open import Relator.Equals.Proofs.Equivalence using () renaming ([â¡]-equiv to Id-equiv ;... |
algebraic-stack_agda0000_doc_12940 | module List.Order.Bounded {A : Set}(_â€_ : A â A â Set) where
open import Bound.Total A
open import Bound.Total.Order _â€_
open import Data.List
data _â€*_ : List A â Bound â Set where
lenx : {t : Bound} â [] â€* t
lecx : {t : Bound}{x : A}{xs : List A} â LeB (val x) t â xs â€* t â (x â· xs) â€* t
data _*â€_ : Bound â ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.