text stringlengths 4 690k |
|---|
infixr 2 _×_
infixr 2 _,_
record Σ (A : Set) (B : A → Set) : Set where
constructor _,_
field
fst : A
snd : B fst
_×_ : Set → Set → Set
A × B = Σ A λ _ → B
syntax Σ A (λ x → B) = Σ[ x ∶ A ] B
data W (A : Set) (B : A → Set) : Set where
sup : (x : A) → ((p : B x) → W A B) → W A B
-- Should be able to ge... |
-- Raw terms, weakening (renaming) and substitution.
{-# OPTIONS --safe #-}
module Definition.Untyped where
open import Tools.Nat
open import Tools.Product
open import Tools.List
import Tools.PropositionalEquality as PE
import Data.Fin as Fin
import Data.Nat as Nat
infixl 30 _∙_^_
infix 30 Π_^_°_▹_°_°_
infixr 22 _... |
{-# OPTIONS --cubical --safe #-}
module Data.List.Membership where
open import Data.List
open import Data.Fin
open import Data.Fin.Properties
open import Prelude
open import Relation.Nullary
open import Path.Reasoning
open import Data.List.Relation.Unary as Relation using (module Exists; module Congruence; ◇; ◇!)
imp... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Category.Monoidal
module Experiment.Categories.Category.Monoidal.Coherence
{o ℓ e} {𝒞 : Category o ℓ e} (M : Monoidal 𝒞) where
open import Level
open import Data.Product using (Σ)
open import Categories.Morphism 𝒞
open im... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
{-
This file defines
sucPred : ∀ (i : Int) → sucInt (predInt i) ≡ i
predSuc : ∀ (i : Int) → predInt (sucInt i) ≡ i
discreteInt : discrete Int
isSetInt : isSet Int
addition of Int is defined _+_ : Int → Int → Int
as well as its commutativity and associativity
+-co... |
module UniDB.Examples.Lc where
open import UniDB
data Tm (γ : Dom) : Set where
var : (i : Ix γ) → Tm γ
abs : (t : Tm (suc γ)) → Tm γ
app : (t₁ t₂ : Tm γ) → Tm γ
instance
iVrTm : Vr Tm
vr {{iVrTm}} = var
vr-inj {{iVrTm}} refl = refl
iApTm : Ap Tm Tm
ap {{iApTm}} ξ (var i) = lk ξ i
ap {... |
-- Andreas, 2018-10-18, re #2757
-- Runtime-irrelevance analogue to issue #2640
-- {-# OPTIONS -v tc.lhs.unify:65 #-}
-- {-# OPTIONS -v tc.irr:20 #-}
-- {-# OPTIONS -v tc:30 #-}
-- {-# OPTIONS -v treeless:20 #-}
open import Common.Prelude
data D : (n : Nat) → Set where
c : (m : Nat) → D m
test : (@0 n : Nat) → D ... |
-- Fast exponentiation
module Numeric.Nat.Pow where
open import Prelude
open import Numeric.Nat.DivMod
open import Control.WellFounded
open import Tactic.Nat
open import Tactic.Cong
module _ {a} {A : Set a} {{_ : Semiring A}} where
private
expAcc : A → (n : Nat) → Acc _<_ n → A
expAcc a zero wf = one
... |
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' ; ... |
import Bundles
import Construct.DirectProduct
import Definitions
import Definitions.Semiring
import Morphism.Structures
import Properties.RingWithoutOne
import Structures
|
{-# 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 ... |
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 $... |
-- 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... |
{-# 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 ... |
{-# 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... |
{-# OPTIONS --cubical --safe #-}
module Data.Pi where
open import Data.Pi.Base public
|
------------------------------------------------------------------------------
-- The Agda standard library
--
-- Additional properties for setoids
------------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
module Relation.Binary.Prop... |
module cedille-options where
open import general-util
open import options-types public
open import cedille-types
record options : Set where
constructor mk-options
field include-path : 𝕃 string × stringset
use-cede-files : 𝔹
make-rkt-files : 𝔹
generate-logs : 𝔹
show-qualified-var... |
{-# OPTIONS --without-K --safe #-}
module Categories.Functor.Duality where
open import Level
open import Data.Product using (Σ; _,_)
open import Categories.Category
open import Categories.Category.Construction.Cones as Con
open import Categories.Category.Construction.Cocones as Coc
open import Categories.Functor
ope... |
open import Data.Product using ( _,_ ; proj₁ ; proj₂ )
open import Data.Sum using ( inj₁ ; inj₂ )
open import Relation.Unary using ( _⊆_ )
open import Relation.Binary.PropositionalEquality using ( _≡_ ; refl ; sym ; cong )
open import Web.Semantic.DL.ABox using ( ε ; _,_ ; _∼_ ; _∈₁_ ; _∈₂_ ; ⟨ABox⟩ ; Assertions )
open... |
{-# OPTIONS --erased-cubical #-}
-- Modules that use --cubical can be imported when --erased-cubical is
-- used.
import Erased-cubical-Module-application.Cubical
module EC = Erased-cubical-Module-application.Cubical Set
-- However, definitions from such modules can only be used in erased
-- contexts.
_ : {A : Set} ... |
------------------------------------------------------------------------
-- Definition of the size of an expression, along with some properties
------------------------------------------------------------------------
module Expression-size where
open import Equality.Propositional
open import Prelude hiding (const)
o... |
-- Andreas, 2020-04-12, issue #4580
-- Highlighting for builtins FROMNAT, FROMNEG, FROMSTRING
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
record Number (A : Set) : Set where
field fromNat : Nat → A
record Negative (A : Set) : Set where
field fromNeg : Nat → A
open Number {{...}} public
open N... |
-- Andreas, 2016-11-19 issue #2308
-- Since fix of #2197, in mutual blocks, records are no-eta-equality
-- until the positivity checker has run.
-- Thus, the record pattern translation might not kick in.
-- Now, there is another pass of record pattern translation
-- after the mutual block has finished.
data Unit : S... |
open import Oscar.Prelude
open import Oscar.Class.HasEquivalence
import Oscar.Data.Constraint
module Oscar.Class.Properthing where
record Properthing {𝔬} ℓ (𝔒 : Ø 𝔬) : Ø 𝔬 ∙̂ ↑̂ ℓ where
infixr 15 _∧_
field
➊ : 𝔒
_∧_ : 𝔒 → 𝔒 → 𝔒
⦃ ⌶HasEquivalence ⦄ : HasEquivalence 𝔒 ℓ
Nothing : 𝔒 → Ø ℓ
... |
-- Andreas, 2016-07-21
-- Test case to ensure postfix printing of projections.
{-# OPTIONS --postfix-projections #-}
open import Common.Product
open import Common.Equality
testProj : {A : Set}{B : A → Set}(y z : Σ A B) →
let X : Σ A B
X = _
in X .proj₁ ≡ y .proj₁ → X .proj₂ ≡ z .proj₂
testProj y z = _ , _
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Unsafe String operations and proofs
------------------------------------------------------------------------
{-# OPTIONS --with-K #-}
module Data.String.Unsafe where
import Data.List.Base as List
import Data.L... |
module Formalization.ClassicalPropositionalLogic.Semantics where
import Lvl
open import Data.Boolean
open import Data.Boolean.Stmt
open import Formalization.ClassicalPropositionalLogic.Syntax
open import Functional
open import Logic
import Logic.Propositional as Logic
import Logic.Predicate as Logic... |
{-# OPTIONS --safe --without-K #-}
module Generics.Mu.All where
open import Generics.Prelude hiding (lookup)
open import Generics.Telescope
open import Generics.Desc
open import Generics.Mu
private
variable
P : Telescope ⊤
p : ⟦ P ⟧tel tt
V I : ExTele P
ℓ c : Level
n : ℕ
AllIndArgωω
... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of All predicate transformer for fresh lists
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Fresh.Relation.Unary.All.Prop... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of operations on machine words
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Word.Properties where
import Data.Nat.Base as ℕ... |
{-# OPTIONS --without-K #-}
module function.extensionality.proof where
open import level
open import sum
open import equality
open import function.extensionality.core
open import hott.univalence
open import hott.level.core
open import hott.level.closure.core
open import hott.equivalence.core
open import sets.unit
top... |
module Oscar.AgdaPatternSyntaxTrick where
record ⊤ : Set where
constructor tt
data List (A : Set) : Set where
∅ : List A
_∷_ : A → List A → List A
Nat = List ⊤
pattern ‼ xs = tt ∷ xs
syntax ‼ xs = ! xs
data Fin : Nat → Set where
∅ : ∀ {n} → Fin (! n)
! : ∀ {n} → Fin n → Fin (! n)
test : Fin (! (! ∅)) --... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
module groups.CoefficientExtensionality where
module _ {i} {A : Type i} (dec : has-dec-eq A) where
Word-coef : Word A → (A → ℤ)
Word-coef nil a = 0
Word-coef (inl a' :: w) a with dec a' a
Word-coef (inl a' :: w) a | inl a'=a = succ $ Word-coef w a
W... |
open import Agda.Primitive
_∘_ : ∀ {a b c}
{A : Set a} {B : A → Set b} {C : {x : A} → B x → Set c} →
(∀ {x} (y : B x) → C y) → (g : (x : A) → B x) →
((x : A) → C (g x))
f ∘ g = λ x → f (g x)
data D {a} (A : Set a) : Set a where
d : D A → D A
data E {a} (A : Set a) : Set a where
e : A → E A
... |
module Data.Char where
postulate Char : Set
{-# BUILTIN CHAR Char #-}
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import groups.Cokernel
open import cohomology.Theory
open import cw.CW
module cw.cohomology.ZerothCohomologyGroup {i} (OT : OrdinaryTheory i)
(⊙skel : ⊙Skeleton {i} 1) (ac : ⊙has-cells-with-choice 0 ⊙skel i) where
open OrdinaryTheory OT
open import cw.... |
{-
Definitions for functions
-}
{-# OPTIONS --cubical --safe #-}
module Cubical.Foundations.Function where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
-- The identity function
idfun : ∀ {ℓ} → (A : Type ℓ) → A → A
idfun _ x = x
infixr 9 _∘_
_∘_ : ∀ {ℓ ℓ′ ℓ″} {A : Type ℓ} {B : A → T... |
{-# OPTIONS --without-K --rewriting #-}
open import PathInduction
open import Pushout
module JamesFirstComposite {i} (A : Type i) (⋆A : A) where
open import JamesTwoMaps A ⋆A
ap-from-αJ-δJ : (a : A) (x : JA) → ap from (ap (αJ a) (δJ x)) == ap (α∞ a) (δ∞ (from x))
ap-from-αJ-δJ a x = ap-from-αJ a (δJ x) ∙ ap (ap (α∞... |
-- A binding to a Haskell natural numbers type
open import Data.Nat using ( ℕ ) renaming ( zero to zero' ; suc to suc' )
module Data.Natural where
open import Data.Natural.Primitive public
using ( Natural ; zero ; suc ; _+_ ; toString ; foldl ; foldl' ; foldr )
renaming ( fromℕ to # )
% : Natural → ℕ
% = foldr ... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import cohomology.Theory
module cw.cohomology.InnerGrid {i} (OT : OrdinaryTheory i)
(n : ℤ) {X Y Z W : Ptd i} (f : X ⊙→ Y) (g : Y ⊙→ Z) (h : Z ⊙→ W) where
open OrdinaryTheory OT
open import cohomology.PtdMapSequence cohomology-theory
{-
X --> Y ... |
-- {-# OPTIONS -v tc.meta:50 #-}
-- Andreas 2012-03-27, record pattern unification
{-# OPTIONS --irrelevant-projections #-}
module Issue376-irrelevant-projections where
open import Common.Equality
open import Common.Irrelevance
bla4 : (A : Set) ->
let A' = Squash (Squash A) in
let X : .(z : A') -> (C : .A' -> Se... |
{- 1. Booleans -}
data Bool : Set where
true : Bool
false : Bool
not : Bool → Bool
not true = false
not false = true
_∧_ : Bool → Bool → Bool
true ∧ true = true
true ∧ false = false
false ∧ true = false
false ∧ false = false
_∨_ : Bool → Bool → Bool
true ∨ true = true
true ∨ false = true
false ∨ true = true
fal... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of left-scaling
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
-- The properties are parameterised by the two... |
------------------------------------------------------------------------------
-- Discussion about the inductive approach
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymo... |
{-# OPTIONS --safe --without-K #-}
module Generics.Telescope where
open import Data.String using (String)
open import Generics.Prelude hiding (curry)
private variable
l : Level
A B : Set l
a x y : A
data Telescope (A : Set l) : Setω
private variable T : Telescope A
levelOfTel : Telescope A → Level
⟦_... |
{-
Basic properties of the Can function and utilities used in the reasoning.
The basic properties of the Can function include
- Can-θ function shadows the environment
canθ-shadowing-irr' : ∀ sigs' S'' p S status θ θo →
S ∈ map (_+_ S'') (SigMap.keys sigs') →
Canθ sigs' S'' p ((θ ← [ (S ₛ) ↦ stat... |
{-# OPTIONS --allow-unsolved-metas #-}
-- Andreas, 2014-12-06
-- Reported by sanzhiyan, Dec 4 2014
open import Data.Vec
open import Data.Fin
open import Data.Nat renaming (_+_ to _+N_)
open import Data.Nat.Solver
open import Relation.Binary.PropositionalEquality hiding ([_])
open +-*-Solver using (prove; solve; _:=_;... |
{-# OPTIONS --without-K #-}
-- Inspired by Thorsten Altenkirch's definition of Groupoids
-- see his OmegaCats repo on github. And copumpkin's definition of
-- Category (see his categories repo, also on github).
module Groupoid where
open import Level using (zero)
open import Data.Empty using (⊥)
open import Data.S... |
{-# OPTIONS --without-K --safe #-}
module Categories.Functor.Instance.Discrete where
-- Discrete Functor
-- from Sets to Cats. This works, unlike in the previous version of the library,
-- because the equality in Cats is properly NaturalIsomorphism instead of something stricter,
-- no need for that pesky Heterog... |
-- Andreas, 2018-06-14, issue #2513, surviving shape-irrelevance annotations.
data Wrap (A : Set) : Set where
@shape-irrelevant wrap : A → Wrap A
|
module Lec2 where
data Zero : Set where
{-
cannaeMake : Zero
cannaeMake = cannaeMake
-}
magic : {X : Set} -> Zero -> X
magic ()
record One : Set where
constructor <>
tryit : One
tryit = <>
tryit2 : One
tryit2 = record {}
data List (X : Set) : Set where
[] : List X
_::_ : X -> List X -> List X
NonEmpty : {... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.DirectSum.DirectSumHIT.UniversalProperty where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Data.Sigma
open import Cubical.Algebra.Group.Morphisms
open import Cubical.Algebra.Group.MorphismProperties
open import Cubi... |
module Nat where
open import Eq
data ℕ : Set where
Z : ℕ
S : ℕ → ℕ
{-# BUILTIN NATURAL ℕ #-}
infixl 6 _+_
infixl 7 _×_
_+_ : ℕ → ℕ → ℕ
Z + n = n
(S k) + n = S(k + n)
{-# BUILTIN NATPLUS _+_ #-}
_×_ : ℕ → ℕ → ℕ
Z × n = Z
S m × n = n + m × n
{-# BUILTIN NATTIMES _×_ #-}
*-right-zero : ∀ (n : ℕ) → n × Z ... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.Monoid.Instances.NatVec where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat using (ℕ ; isSetℕ)
open import Cubical.Data.Vec
open import Cubical.Data.Vec.OperationsNat
open import Cubical.Algebra.Monoid
NatVecMonoid : (n : ℕ) → Monoid ℓ-zero
fst (... |
{-# OPTIONS --without-K --rewriting --exact-split #-}
open import lib.Basics
open import lib.types.Paths
open import lib.types.Coproduct
open import Graphs.Definition
open import Coequalizers.Definition
module Coequalizers.TrivialExtension where
module TExtensionCoeq-l {i : ULevel} {V : Type i} (v : V) where
ins... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Instance.Properties.Setoids.Exact where
open import Categories.Category using (Category)
open import Categories.Category.Exact using (Exact)
open import Categories.Category.Instance.Properties.Setoids.Limits.Canonical using (pullback; FiberProduct; mk-×; F... |
open import Data.List renaming (_∷_ to _∷ₗ_ ; [_] to [_]ₗ)
open import Data.Maybe
open import Data.Product
open import Data.Sum
open import AEff
open import EffectAnnotations
open import Preservation
open import Renamings
open import Substitutions
open import Types
open import Relation.Binary.PropositionalEquality hi... |
{-# OPTIONS --without-K #-}
module TheSame where
open import Level using (_⊔_) renaming (zero to l0; suc to lsuc)
open import Universe using (Universe)
open import Categories.Category using (Category)
open import Categories.Groupoid using (Groupoid)
open import Categories.Functor using (Functor)
open import Data.Em... |
open import Data.List
open import Data.Product
open import Relation.Unary hiding (_∈_)
open import Relation.Ternary.Separation
module Relation.Ternary.Separation.Monad.State where
open import Level hiding (Lift)
open import Function using (_∘_; case_of_)
open import Relation.Binary.PropositionalEquality using (refl; ... |
module Formalization.Monoid where
import Lvl
open import Numeral.Finite using (𝕟)
open import Numeral.Natural using (ℕ)
open import Type
open import Type.Dependent
open import Syntax.Function
private variable ℓ ℓₑ : Lvl.Level
private variable T : Type{ℓ}
private variable n n₁ n₂ : ℕ
module Semigroup where
--... |
module Issue452 where
data Bool : Set where
true false : Bool
data ⊥ : Set where
record ⊤ : Set where
constructor tt
abstract
id : Bool → Bool
id b = b
If_then_else_ : Bool → Set → Set → Set
If true then t else f = t
If false then t else f = f
data D : (b : Bool) → If b then ⊤ else ⊥ → Set where
d : D... |
module Delta (K : Set) \{\{bij : bij K Nat\}\} where
DL : (V : Set) \altRArr Set
DL V = List (Nat \altAnd V)
data DD (V : Set) : Set where
DD : DL V \altRArr DD V
delta
: \altFAll\{n m\} \altRArr n < m \altRArr Nat
delta n<m =
difference (n<m\altRArr1+n\ensuremath{\leq}m n<m) -- i.e. m - n - 1
-- lookup
_\alt... |
{-# OPTIONS --prop --rewriting #-}
open import Calf.CostMonoid
module Calf.Types.BoundedFunction (costMonoid : CostMonoid) where
open CostMonoid costMonoid
open import Calf.Prelude
open import Calf.Metalanguage
open import Calf.Step costMonoid
open import Calf.Types.Bounded costMonoid
open import Level using (_⊔_)... |
{-# 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... |
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... |
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 ∷ Γ
|
{-# 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... |
{-# 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... |
{-# 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... |
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... |
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... |
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... |
-- 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 = ((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((((... |
------------------------------------------------------------------------
-- Function setoids and related constructions
------------------------------------------------------------------------
module Relation.Binary.FunctionSetoid where
open import Data.Function
open import Relation.Binary
infixr 0 _↝_ _⟶_ _⇨_ _≡⇨_
... |
------------------------------------------------------------------------
-- A binary representation of natural numbers
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
import Erased.Without-box-cong
module Nat.Binary
{c⁺}
(eq : ∀ {a ... |
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 ... |
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... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties satisfied by strict partial orders
------------------------------------------------------------------------
open import Relation.Binary
module Relation.Binary.Properties.StrictPartialOrder
{s₁... |
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... |
data Unit : Set where
tt : Unit
f : Unit
mutual
f = tt
|
{-# OPTIONS --without-K --exact-split --rewriting #-}
module index where
-- An organised list of modules:
import Pi.Everything
-- An exhaustive list of all modules:
|
open import Oscar.Prelude
open import Oscar.Class
open import Oscar.Class.Transitivity
module Oscar.Class.Transassociativity where
module Transassociativity
{𝔬} {𝔒 : Ø 𝔬}
{𝔯} (_∼_ : 𝔒 → 𝔒 → Ø 𝔯)
{ℓ} (_∼̇_ : ∀ {x y} → x ∼ y → x ∼ y → Ø ℓ) (let infix 4 _∼̇_ ; _∼̇_ = _∼̇_)
(transitivity : Transitivity.ty... |
{-# 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... |
module QualifiedConstructors where
data Nat₁ : Set where
zero : Nat₁
suc : Nat₁ → Nat₁
data Nat₂ : Set where
zero : Nat₂
suc : Nat₂ → Nat₂
zero₁ = Nat₁.zero
one₂ = Nat₂.suc Nat₂.zero
record Suc : Set where
constructor suc
field n : Nat₁
one₃ = Suc.suc zero₁
pred : Suc → Nat₁
pred s = Suc.n s
conv... |
----------------------------------------------------------------------
-- Copyright: 2013, Jan Stolarek, Lodz University of Technology --
-- --
-- License: See LICENSE file in root of the repo --
-- Repo address: https://github.com/... |
{-# OPTIONS --without-K --safe --overlapping-instances #-}
module Examples where
open import Data.Nat
-- local imports
open import Interpreter
pf : y' ∈ y' ::: `ℕ , (x' ::: `ℕ , ·)
pf = H
pf2 : x' ∈ y' ::: `ℕ , (x' ::: `ℕ , ·)
pf2 = TH
testSimpleLambda : · ⊢ `ℕ
testSimpleLambda = (`λ x' `: `ℕ ⇨ (`v x' `+ `v x'))... |
module Data.Bin.Rec where
open import Data.Bin hiding (suc; fromℕ)
open import Induction.WellFounded
open import Data.Nat using (ℕ; zero; suc) renaming (_<_ to _ℕ<_)
open import Data.Nat.Properties
open import Relation.Binary.PropositionalEquality
open import Data.Bin.Bijection
import Induction.Nat
wf : Well-found... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Core lemmas needed to make list argmin/max functions work
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (Trans; To... |
{-# OPTIONS -W error #-}
module Issue2596a where
{-# REWRITE #-}
-- We will never encounter this, because the harmless warning above
-- has been turned into an error
f : Set
f = f
|
module Issue450 where
open import Common.Level
open import Common.Coinduction
data _≡_ {A : Set}(x : A) : A → Set where
refl : x ≡ x
data Wrap (A : Set) : Set where
con : A -> Wrap A
out : forall {A} -> Wrap A -> A
out (con x) = x
out' : forall {A} -> ∞ (Wrap A) -> A
out' y = out (♭ y)
inn : forall {A} -> A... |
-- Andreas, 2017-09-09, re issue #2732
-- eta-contraction needed in termination checker
-- {-# OPTIONS -v term:30 #-}
open import Agda.Builtin.Equality
data O (A : Set) : Set where
leaf : O A
node : (A → O A) → O A
postulate
A : Set
a : A
test1 : (t u : O A) → O A
test1 leaf leaf = leaf
test1 leaf ... |
-- Andreas, 2017-10-11, issue #2796
-- A failed check for projection-likeness
-- made the overloaded projection not resolve.
-- {-# OPTIONS -v tc.proj.like:100 #-}
-- {-# OPTIONS -v tc.proj.amb:100 #-}
postulate
L : Set
lzero : L
Type : L → Set
El : ∀{l} → Type l → Set
record Pred (A : Set) l : Set ... |
-- Andreas, 2012-01-13, error reported by Rob Simmons
module Issue555 where
data Exp : Set
data Exp Γ where -- internal error
|
open import Oscar.Prelude
open import Oscar.Data.𝟘
module Oscar.Data.Decidable where
data Decidable {a} (A : Ø a) : Ø a where
↑_ : A → Decidable A
↓_ : ¬ A → Decidable A
|
open import Relation.Binary hiding (_⇒_)
module Category.Monad.Monotone.Error {i}(pre : Preorder i i i)(Exc : Set i) where
open Preorder pre renaming (Carrier to I; _∼_ to _≤_; refl to ≤-refl)
open import Function
open import Level hiding (lift)
open import Data.Sum
open import Relation.Unary
open import Relation.U... |
{-# OPTIONS --cubical-compatible --sized-types #-}
------------------------------------------------------------------------
-- From the Agda standard library
--
-- Sizes for Agda's sized types
------------------------------------------------------------------------
module Common.Size where
open import Agda.Builtin.Si... |
{-# OPTIONS --experimental-irrelevance #-}
-- Andreas, 2015-05-18 Irrelevant module parameters
-- should not be resurrected in module body.
postulate
A : Set
module M .(a : A) where
bad : (..(_ : A) -> Set) -> Set
bad f = f a
-- SHOULD FAIL: variable a is declared irrelevant,
-- so it cannot be used ... |
module Capability where
open import Relation.Nullary
using (yes; no)
open import Data.List
using (List; []; [_]; _∷_; _++_)
open import Data.String
using (String; _≟_)
open import Relation.Binary.PropositionalEquality
using (_≢_; refl; _≡_)
-- Local modules -------------------------------------... |
{-# OPTIONS --without-K #-}
open import HoTT.Base
open import HoTT.Identity
module HoTT.Transport.Identity where
open variables
unitₗᵣ : {x y : A} {p : x == y} → p == refl ∙ p ∙ refl
unitₗᵣ {p = refl} = refl
-- Theorem 2.11.3
transport= : {a a' : A} (f g : A → B) (p : a == a') (q : f a == g a) →
transp... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.