text stringlengths 4 690k |
|---|
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.two-semi-categories.Functor
open import lib.two-semi-categories.FundamentalCategory
open import lib.two-semi-categories.FunctorInverse
open import lib.types.Pi using ()
module lib.two-semi-categories.FunextFunctors where
module FunextFunc... |
------------------------------------------------------------------------------
-- An inductive predicate for representing functions
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-unive... |
-- Andreas, 2020-03-20, issue #4482, reported by gallai
-- Precise range for unexpected implicit argument.
_ : Set → {A : Set} → {B : Set} → {C : Set} → Set
_ = λ { _ {B = B} {A = A} → {!!} }
-- Unexpected implicit argument
-- when checking the clause left hand side
-- .extendedlambda0 _ {B = B} {A = A}
-- ... |
{-# OPTIONS --prop --rewriting #-}
module Examples.Queue where
open import Calf.CostMonoid
open import Calf.CostMonoids using (ℕ-CostMonoid)
costMonoid = ℕ-CostMonoid
open CostMonoid costMonoid using (ℂ)
open import Calf costMonoid
open import Calf.Types.Nat
open import Calf.Types.Unit
open import Calf.Types.Sum
op... |
module Data.Either where
import Lvl
open import Data.Boolean using (Bool ; 𝑇 ; 𝐹)
open import Functional using (id ; _∘_)
open import Type
infixr 100 _‖_
private variable ℓ ℓ₁ ℓ₂ ℓ₃ ℓ₄ : Lvl.Level
private variable A B C A₁ A₂ B₁ B₂ : Type{ℓ}
data _‖_ (A : Type{ℓ₁}) (B : Type{ℓ₂}) : Type{ℓ₁ Lvl.⊔ ℓ₂} where
... |
{-
A possible implementation of the following HIT arr. Note that this type is
mutually defined with App, that is to say, they are defined by
induction-recursion!
Inductive arr (A,B:Set) : Set :=
| base : B -> arr A B
| step : (A -> arr A B) -> arr A B.
| path : (forall x : A, App f x = App g x) -> f = g.
where App i... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Some derivable properties
------------------------------------------------------------------------
open import Algebra
module Algebra.Properties.BooleanAlgebra
{b₁ b₂} (B : BooleanAlgebra b₁ b₂)
... |
{-# OPTIONS --universe-polymorphism #-}
-- Should fail with S i != i
module Issue216 where
postulate
Level : Set
O : Level
S : Level → Level
{-# BUILTIN LEVEL Level #-}
{-# BUILTIN LEVELZERO O #-}
{-# BUILTIN LEVELSUC S #-}
Foo : {i : Level} → Set i
Foo {i} = (R : Set i) → R
|
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl)
open import Data.Nat using (ℕ; zero; suc)
open import Relation.Nullary using (¬_; Dec; yes; no)
data _≤_ : ℕ → ℕ → Set where
z≤n : ∀ {n : ℕ} → zero ≤ n
s≤s : ∀ {m n : ℕ} → m ≤ n → suc m ≤ suc n
¬s≤z : ∀ {m : ℕ} → ¬ (suc m ≤ zero)
¬s≤z ()... |
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module Examples where
data _∨_ (A B : Set) : Set where
inl : A → A ∨ B
inr : B → A ∨ B
postulate commOr : {A B : Set} → A ∨ B → B ∨ A
{-# ATP... |
_ : Set₁
_ = Set
_ : Set₁
_ = Set
module _ where
_ : Set₁
_ = Set
|
------------------------------------------------------------------------
-- Coinductive "natural" numbers
------------------------------------------------------------------------
module Data.Conat where
open import Coinduction
open import Data.Nat using (ℕ; zero; suc)
------------------------------------------------... |
{-# OPTIONS --safe #-}
module Definition.Typed.Consequences.Equality where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.EqRelInstance
open import Definition.LogicalRelation
open import Definition.LogicalRelation.Properties.Escape
open... |
{-# OPTIONS --without-K #-}
module function.isomorphism.utils where
open import sum
open import equality.core
open import equality.calculus
open import function.core
open import function.overloading
open import function.isomorphism.core
open import function.isomorphism.coherent
open import function.extensionality.pro... |
-- Basic intuitionistic modal logic S4, without ∨, ⊥, or ◇.
-- Basic Kripke-style semantics with abstract worlds, for soundness only.
-- Ono-style conditions.
module BasicIS4.Semantics.BasicKripkeOno where
open import BasicIS4.Syntax.Common public
-- Intuitionistic modal Kripke models, with frame conditions given b... |
------------------------------------------------------------------------------
-- Agda-Prop Library.
------------------------------------------------------------------------------
open import Data.Nat using ( ℕ )
module Data.PropFormula.Dec ( n : ℕ ) where
------------------------------------------------------------... |
postulate
A : Set
variable
{xx} : A
record R : Set₁ where
field
P : A → Set
a : P xx
b : P xx
c : P xx
d : P xx
e : P xx
f : P xx
g : P xx
h : P xx
i : P xx
j : P xx
k : P xx
l : P xx
m : P xx
n : P xx
o : P xx
p : P xx
q : P xx
r : P ... |
module BBSTree {A : Set}(_≤_ : A → A → Set) where
open import Bound.Total A
open import Bound.Total.Order _≤_
open import Data.List
open import List.Order.Simple _≤_
data BBSTree : Bound → Bound → Set where
bslf : {b t : Bound}
→ LeB b t
→ BBSTree b t
bsnd : {x : A}{b t : ... |
open import Prelude
open import core
open import contexts
open import weakening
module typed-expansion where
mutual
typed-expansion-synth : ∀{Φ Γ p e τ} →
Φ , Γ ⊢ p ~~> e ⇒ τ →
Γ ⊢ e => τ
typed-expansion-synth SPEConst = SConst
t... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category using (Category; module Commutation)
-- Defines the induced Monoidal structure of a Cartesian Category
module Categories.Category.Cartesian.Monoidal {o ℓ e} {𝒞 : Category o ℓ e} where
open Category 𝒞
open HomReasoning
open import Categories.Categ... |
{-# OPTIONS --no-qualified-instances #-}
module NoQualifiedInstances-InAnonymousModule where
postulate
A : Set
f : {{A}} → A
module _ where postulate instance a : A
test : A
test = f
|
open import Relation.Binary.Core
module PLRTree.Everything {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_)
(trans≤ : Transitive _≤_) where
open import PLRTree.Complete.Correctness.Base {A}
open import PLRTree.Drop.Complete _≤_ tot≤
open import PLRTree.Drop.Heap _... |
module Control.Exception.Primitive where
open import IO.Primitive
postulate
bracket : ∀ {a b c} {A : Set a} {B : Set b} {C : Set c} → IO A → (A → IO B) → (A → IO C) → IO C
{-# IMPORT Control.Exception #-}
{-# COMPILED bracket (\_ _ _ _ _ _ -> Control.Exception.bracket) #-}
|
open import Data.Nat using (ℕ; suc ; zero; _+_; _≤′_; _<′_; _<_; _≤_;
z≤n; s≤s; ≤′-refl; ≤′-step; _≟_) renaming (_⊔_ to max)
open import Data.Nat.Properties
using (n≤0⇒n≡0; ≤-refl; ≤-trans; m≤m⊔n; n≤m⊔n; ≤-step; ⊔-mono-≤;
+-mono-≤; +-mono-≤-<; +-mono-<-≤; +-comm; +-assoc; n≤1+n;
≤-pred; m≤m+n; ... |
-- Andreas, 2012-09-07
-- {-# OPTIONS -v tc.polarity:10 -v tc.conv.irr:20 -v tc.conv.elim:25 -v tc.conv.term:10 #-}
module Issue691 where
open import Common.Equality
data Bool : Set where
true false : Bool
assert : (A : Set) → A → Bool → Bool
assert _ _ true = true
assert _ _ false = false
g : Bool -> Bool -> Bo... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Container combinators
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Container.Combinator where
open import Level using (Level; _⊔_; Lif... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
{-
This file contains:
1. The iso π₃S²≅ℤ
2. A proof that π₃S² is generated by the Hopf map
-}
module Cubical.Homotopy.Group.Pi3S2 where
open import Cubical.Homotopy.Loopspace
open import Cubical.Homotopy.Group.LES
open import Cubical.Homotopy.Group.PinSn
open im... |
-- Andreas, 2014-01-24, Issue 1411
-- First split might not succeed in the unifier,
-- so try later splits also.
-- {-# OPTIONS -v tc.lhs:10 #-}
open import Common.Prelude
open import Common.Equality
data Fin : Nat → Set where
fzero : (n : Nat) → Fin (suc n)
fsuc : (n : Nat) → (i : Fin n) → Fin (suc n)
data _≅... |
{-# OPTIONS --without-K #-}
module EnumEquiv where
open import Data.Empty using (⊥; ⊥-elim)
open import Data.Nat using (ℕ; _+_)
open import Data.Fin using (Fin; inject+; raise)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Data.Product using (_,_; proj₁; proj₂)
open import Function using (_∘_)
open impo... |
------------------------------------------------------------------------
-- Progress of CBV reductions in Fω with interval kinds
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
-- This module contains a variant of the "progress" theorem for Fω
-- with interv... |
-- Andreas & James, 2016-04-18 pre-AIM XXIII
-- order of clauses should not matter here!
{-# OPTIONS --exact-split #-}
open import Common.Prelude
record R A : Set where
field out : A
T : (x y : Bool) → Set
T true y = R Bool
T false true = R Nat
T false false = R String
test : (x y : Bool) → T x y
R.out (test... |
{- 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
-}
module Haskell.Modules.RWS.RustAnyHow where
open import Haskell.Modules.RWS
... |
module STLC.Type where
open import Data.Fin using (Fin)
open import Data.Fin.Substitution
open import Data.Fin.Substitution.Lemmas using (TermLemmas)
open import Data.Nat using (ℕ; _+_)
open import Relation.Binary.Construct.Closure.ReflexiveTransitive
using (Star; ε; _◅_)
open import Data.Vec using (Vec; []; _∷_... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category using (Category; _[_≈_])
-- Karoubi Envelopes. These are the free completions of categories under split idempotents
module Categories.Category.Construction.KaroubiEnvelope {o ℓ e} (𝒞 : Category o ℓ e) where
open import Level
open import Categories.... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Results concerning function extensionality for propositional equality
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Axiom.Extensionality.Prop... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.EilenbergMacLane
open import homotopy.EilenbergMacLane1
open import homotopy.EilenbergMacLaneFunctor
module cohomology.CupProduct.OnEM.CommutativityInLowDegrees where
module _ {i} {j} (G : AbGroup i) (H : AbGroup j) where
private
mo... |
module EqBase where
import PolyDepPrelude
open PolyDepPrelude using
( Bool; true; false; _&&_
; Unit; unit
; Pair; pair
; Either; left; right
; Absurd
; Datoid; datoid; pElem
; True )
-- import And
And = Pair
-- import Sigma
data Sigma (A : Set)(B : A -> Set) : Set where
si : (a : A) -> (b : B a) -> S... |
open import Data.Nat hiding (_^_)
open import Data.List as List hiding (null)
open import Data.List.Membership.Propositional
open import Data.List.Relation.Unary.Any
open import Data.List.Relation.Unary.All
open import Data.List.Prefix
open import Data.Product hiding (map)
open import Data.Unit
open import Relation.Bin... |
module Haskell.RangedSetsProp.RangedSetProperties where
open import Haskell.RangedSetsProp.library
open import Haskell.RangedSetsProp.RangesProperties
open import Agda.Builtin.Equality
open import Agda.Builtin.Bool
open import Haskell.Prim
open import Haskell.Prim.Ord
open import Haskell.Prim.Bool
open import Haskell... |
module _ where
module A where
data D₁ : Set where
a : D₁
c : D₁ → D₁
module B where
data D₂ : Set where
b : D₂
c : D₂ → D₂
syntax c x = ⟦ x ⟧
open A
open B
test : D₁
test = ⟦ a ⟧ -- The syntax declaration applies to B.c, not A.c.
|
module Logic.DiagonalProof {ℓ₁} {ℓ₂} where
import Lvl
open import Logic.Propositional{ℓ₁ Lvl.⊔ ℓ₂}
open import Logic.Predicate{ℓ₁}{ℓ₂}
open import Functional
open import Relator.Equals{ℓ₁}{ℓ₂}
open import Relator.Equals.Proofs{ℓ₁}{ℓ₂}
open import Type{ℓ₂}
diagonal-proof : ∀{T₁ T₂ : Type}(diff-oper : T₂ → T₂) → (... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Monoidal.Instance.One where
open import Level
open import Data.Unit using (⊤; tt)
open import Categories.Category
open import Categories.Category.Instance.One
open import Categories.Category.Monoidal
open import Categories.Functor.Bifunctor
open import Ca... |
module CoinductiveBuiltinNatural where
open import Common.Coinduction
data ℕ : Set where
zero : ℕ
suc : (n : ∞ ℕ) → ℕ
{-# BUILTIN NATURAL ℕ #-}
|
{-# OPTIONS --safe --warning=error --without-K #-}
open import Functions.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import LogicalFormulae
open import Setoids.Subset
open import Setoids.Setoids
open import Setoids.Orders.Partial.Definition
open import Fields.Fields
open import Rings.Ord... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.NatSolver.EvalHom where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat
open import Cubical.Data.FinData
open import Cubical.Data.Vec
open import Cubical.Algebra.NatSolver.HornerForms
private
variable
ℓ : Level
module HomomorphismProperties w... |
------------------------------------------------------------------------------
-- Testing Agsy arithmetic properties used by the McCarthy 91 function
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Integer Literals
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Integer.Literals where
open import Agda.Builtin.FromNat
open import Agda... |
module TelescopingLet where
module Star where
★ : Set₁
★ = Set
★₁ : Set₂
★₁ = Set₁
module MEndo (open Star) (A : ★) where
Endo : ★
Endo = A → A
module Batch1 where
f : (let ★ = Set) (A : ★) → A → A
f A x = x
g : (let ★ = Set
Endo = λ A → A → A) (A : ★) → Endo A
g = f
h : (open Sta... |
-- The purpose of this universe construction is to get some definitional
-- equalities in the model. Specifically, if we define ⟦σ⟧ : ⟦Δ⟧ → ⟦Ω⟧
-- (a functor) for the "canonical" notion of subsitution, then we have
-- ⟦Wk⟧ (δ , m) ≡ δ propositionally, but *not* definitionally. This then
-- complicates proofs involving ... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.DirectSum.DirectSumHIT.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Empty as ⊥
open import Cubical.Data.Sigma
open import Cubical.Relation.Nullary
open import Cubical.Algebra.Group
open import Cubical.Algebra.AbGroup
open import Cubi... |
-- Check that unquoted functions are termination checked.
module _ where
open import Common.Prelude hiding (_>>=_)
open import Common.Reflection
`⊥ : Type
`⊥ = def (quote ⊥) []
{-
Generate
aux : ⊥
aux = aux
loop : ⊥
loop = aux
-}
makeLoop : QName → TC ⊤
makeLoop loop =
freshName "aux" >>= λ aux →
declar... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Definitions for types of functions that only require an equality
-- relation over the domain.
------------------------------------------------------------------------
-- The contents of this file should usually ... |
------------------------------------------------------------------------
-- Parsers containing non-terminals, and grammars using such parsers
------------------------------------------------------------------------
module StructurallyRecursiveDescentParsing.Grammar where
open import Data.Bool
open import Data.Empty
o... |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Square where
open import Level
open import Function renaming (id to idᶠ; _∘_ to _©_)
open import Categories.Support.PropositionalEquality
open import Categories.Category
import Categories.Morphisms as Mor
open import Relation.Binary hiding (_⇒_)
module Glue... |
-- Andreas, 2016-06-09 issue during refactoring for #1963
-- Shrunk this issue with projection-like functions from std-lib
-- {-# OPTIONS --show-implicit #-}
-- {-# OPTIONS -v tc.proj.like:10 #-}
open import Common.Level
open import Common.Nat renaming ( Nat to ℕ )
data ⊥ : Set where
record ⊤ : Set where
construc... |
open import Level using (_⊔_; suc; Lift; lift)
open import Function using (_$_; _∘_; _⤖_)
open import Relation.Nullary using (¬_)
open import Relation.Nullary.Decidable using (False)
open import Relation.Binary using (Rel; Decidable; Setoid; DecSetoid; IsEquivalence; IsDecEquivalence)
open import Data.Empty using (⊥)
... |
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
record Eq (A : Set) : Set₁ where
field
_≈_ : A → A → Set
open Eq {{...}} public
record Setoid : Set₁ where
field
∣_∣ : Set
{{eq}} : Eq ∣_∣
open Setoid public
-- instance
-- EqNat : Eq Nat
-- _≈_ {{EqNat}} = _≡_
NatSetoid : Seto... |
open import Data.Bool
module GUIgeneric.GUIExample where
open import GUIgeneric.Prelude renaming (inj₁ to secondBtn; inj₂ to firstBtn; WxColor to Color) hiding (addButton; _>>_)
open import GUIgeneric.GUIDefinitions renaming (add to add'; add' to add)
open import GUIgeneric.GUI
open import GUIgeneric.GUIExampleLi... |
-- {-# OPTIONS -v tc.conv.level:60 #-}
-- {-# OPTIONS -v tc.conv:30 #-}
{- Agda development version: Wed Oct 30 16:30:06 GMT 2013
The last line of code triggers the following error,
but replacing '_' with 'a' typechecks just fine.
Bug.agda:32,8-11
tt != a of type ⊤
when checking that the expression s ... |
module x01-842Naturals where
-- This is a comment.
{-
This is a multi-line comment
-}
-- Definition of datatype representing natural numbers. ♭
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
-- A couple of definitions using this datatype.
one : ℕ
one = suc zero
two : ℕ
two = suc (suc zero)
-- I could have also... |
-- Andreas, 2018-05-28, issue #3095, fail on attempt to make hidden parent variable visible
data Nat : Set where
suc : {n : Nat} → Nat
data IsSuc : Nat → Set where
isSuc : ∀{n} → IsSuc (suc {n})
test : ∀{m} → IsSuc m → Set
test p = aux p
where
aux : ∀{n} → IsSuc n → Set
aux isSuc = {!.m!} -- Split on .m h... |
{-# OPTIONS --without-K --safe #-}
module Categories.Minus2-Category.Properties where
-- All -2-Categories are equivalent to One
open import Level
open import Data.Product using (Σ; _,_; proj₁; proj₂)
open import Data.Unit using (⊤; tt)
open import Categories.Minus2-Category
open import Categories.Category
import C... |
module gc where
open import lib
-- we will model addresses in memory as just natural numbers
Address : Set
Address = ℕ
-- a value of type (Bounded n) is an address a together with a proof that a is less than n
Bounded : Address → Set
Bounded n = Σ Address (λ a → a < n ≡ tt)
-- a (Cell a) models an addre... |
{-
In this file we apply the cubical machinery to Martin Hötzel-Escardó's
structure identity principle:
https://www.cs.bham.ac.uk/~mhe/HoTT-UF-in-Agda-Lecture-Notes/HoTT-UF-Agda.html#sns
-}
{-# OPTIONS --cubical --safe #-}
module Cubical.Foundations.SIP where
open import Cubical.Foundations.Prelude
open import Cubi... |
------------------------------------------------------------------------
-- Validity of canonical kinding in Fω with interval kinds
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module FOmegaInt.Kinding.Canonical.Validity where
open import Data.Product us... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of the extensional sublist relation over setoid equality.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary hidin... |
-- Andreas, 2013-10-26
-- What if user tried to eliminate function type by copattern?
{-# OPTIONS --copatterns #-}
-- {-# OPTIONS -v tc.lhs.split:30 #-}
module CopatternsSplitErrorWithUnboundDBIndex where
import Common.Level
record _×_ (A B : Set) : Set where
constructor _,_
field
fst : A
snd : B
open _... |
-- This file is imported by other tests, can't just remove (Andreas, 2015-07-15).
module Nat where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
|
module Function.Domains.Id where
import Lvl
open import Functional using (_∘_)
open import Type
open import Type.Dependent
private variable ℓₒ₁ ℓₒ₂ ℓₑ₁ ℓₑ₂ : Lvl.Level
module _ {X : Type{ℓₒ₁}} {Y : Type{ℓₒ₂}} where
data Image (f : X → Y) : Y → Type{ℓₒ₁ Lvl.⊔ ℓₒ₂} where
intro : (x : X) → Image f (f(x))
... |
{- Example by Andrew Pitts, 2016-05-23 -}
{-# OPTIONS --rewriting --cubical-compatible #-}
open import Agda.Builtin.Equality public
infix 6 I─_
postulate
𝕀 : Set
O : 𝕀
I : 𝕀
I─_ : 𝕀 → 𝕀
{-# BUILTIN REWRITE _≡_ #-}
postulate
I─O≡I : I─ O ≡ I
{-# REWRITE I─O≡I #-}
dat... |
-- The Agda primitives (preloaded).
{-# OPTIONS --without-K --no-subtyping --no-import-sorts #-}
module Agda.Primitive where
------------------------------------------------------------------------
-- Universe levels
------------------------------------------------------------------------
infixl 6 _⊔_
{-# BUILTIN ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Indexed unary relations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Relation.Unary.Indexed where
open import Data.Product using (∃; _×_)
... |
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.NType2
open import lib.types.Group
open import lib.types.Sigma
open import lib.types.Truncation
open import lib.groups.Homomorphisms
module lib.groups.PropSubgroup where
module _ {i} (G : Group i) where
private
module G = Group G
module Pro... |
{-
This second-order equational theory was created from the following second-order syntax description:
syntax Naturals | Nat
type
N : 0-ary
term
ze : N
su : N -> N
nrec : N α (α,N).α -> α
theory
(zeβ) z : α s : (α,N).α |> nrec (ze, z, r m. s[r,m]) = z
(suβ) z : α s : (α,N).α ... |
module DuplicateBuiltinBinding where
postulate Int : Set
{-# BUILTIN INTEGER Int #-}
{-# BUILTIN INTEGER Int #-}
|
module HiddenLambda where
postulate
A : Set
T : A -> Set
H : Set
H = {x : A} -> T x -> T x
-- H doesn't reduce when checking the body of h
h : H
h = \tx -> tx
|
import Lvl
-- TODO: Just testing how it goes with creating an axiomatic system
module Geometry.Test3 (Point : Set(Lvl.𝟎)) where
open import Functional
open import Logic.Propositional{Lvl.𝟎}
open import Logic.Predicate{Lvl.𝟎}{Lvl.𝟎}
open import Relator.Equals{Lvl.𝟎}{Lvl.𝟎} renaming (_≡_ to _≡ₚ_ ; _≢_ to _≢ₚ_)
op... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- An either-or-both data type, basic type and operations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.These.Base where
open import Level... |
{- 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 Optics.All
open import LibraBFT.Prelude
open import LibraBFT... |
{-# OPTIONS --rewriting --confluence-check #-}
open import Agda.Builtin.Bool
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
{-# BUILTIN REWRITE _≡_ #-}
record R : Set₁ where
constructor c
field unD : Set
open R
id : unD (c (Nat → Nat))
id x = x
postulate rew : c (Nat → Nat) ≡ c (Nat → Bool)
{-... |
open import Data.Nat using ( ℕ ; zero ; suc )
open import Data.Product using ( ∃ ; _×_ ; _,_ )
open import Data.Sum using ( _⊎_ ; inj₁ ; inj₂ )
open import Relation.Binary.PropositionalEquality using ( _≡_ ; _≢_ ; refl ; cong )
open import Relation.Nullary using ( ¬_ )
open import FRP.LTL.Time using
( Time ; _<_ ; _... |
-- Andreas, 2019-03-28, issue #3600
--
-- Problem WAS: The size conversion checker produced invalid
-- constraints when getting stuck during checking, e.g., a <= max b a'.
-- The failing attempt of a <= b would produce constraints, which is unsound.
-- Now, we fail hard if a <= b gets stuck; this gives us a chance to s... |
{-# OPTIONS --cubical --safe #-}
module Data.Empty.Base where
open import Cubical.Data.Empty
using (⊥; isProp⊥)
public
open import Level
infix 4.5 ¬_
¬_ : Type a → Type a
¬ A = A → ⊥
⊥-elim : ⊥ → A
⊥-elim ()
|
open import Oscar.Prelude
open import Oscar.Class
open import Oscar.Class.Reflexivity
open import Oscar.Class.Symmetry
open import Oscar.Class.Transitivity
open import Oscar.Class.IsEquivalence
open import Oscar.Class.Setoid
open import Oscar.Data.Proposequality
module Oscar.Property.Setoid.Proposequality where
modu... |
{- 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
-}
{-# OPTIONS --allow-unsolved-metas #-}
open import LibraBFT.Base.Types... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import cw.CW
open import cw.DegreeByProjection
open import cohomology.ChainComplex
module cw.cohomology.cellular.ChainComplex {i : ULevel} where
chain-template : ∀ {n} (skel : Skeleton {i} n) {m}
→ Dec (m ≤ n) → AbGroup i
chain-template skel (inl ... |
module Data.Maybe.Properties where
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
open import Data.Maybe
just-not-nothing : ∀ {ℓ}{A : Set ℓ}{x : Maybe A}{y : A} → x ≡ just y → ¬ (x ≡ nothing)
just-not-nothing refl = λ ()
|
{-# OPTIONS --no-termination-check #-}
module Data.Real.CReal where
import Prelude
import Data.Bool
import Data.String
import Data.Real.Complete
import Data.Real.Base
import Data.Nat
import Data.Integer
import Data.Rational as Rational
import Data.Interval
import Data.Real.Gauge
import Data.Show
import Data.List
impo... |
module agda where
open import IO
main = run (putStrLn "Hello, World!")
|
module Spire.Operational where
----------------------------------------------------------------------
data Level : Set where
zero : Level
suc : Level → Level
----------------------------------------------------------------------
data Context : Set
data Type (Γ : Context) : Set
data Value (Γ : Context) : Type Γ ... |
open import Type
module Relator.Equals.Proofs.Equiv {ℓ} {T : Type{ℓ}} where
import Relator.Equals.Proofs.Equivalence
open Relator.Equals.Proofs.Equivalence.One {T = T} public
open Relator.Equals.Proofs.Equivalence.Two {A = T} public
open Relator.Equals.Proofs.Equivalence.Three {A = T} public
open Relator.Equals.... |
{-# OPTIONS --rewriting --confluence-check #-}
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
open import Agda.Builtin.Equality.Rewrite
data Unit : Set where
unit : Unit
Foo : Unit → Set
Foo unit = Unit
Bar : Unit → Unit → Set
Bar unit = Foo
bar : ∀ x y → Bar x y ≡ Unit
bar unit unit = refl
{-#... |
module Imports.Issue5357-C where
import Imports.Issue5357-D
|
module Selective.Examples.Chat where
open import Selective.ActorMonad
open import Selective.Libraries.Call
open import Prelude
hiding (Maybe)
open import Data.Maybe as Maybe
hiding (map)
open import Data.Maybe.Categorical as CMaybe
open import Data.List.Properties
open import Category.Monad
open imp... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Reflection utilities for ℕ
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Nat.Reflection where
open import Data.Nat.Base as ℕ
open impor... |
-- 2012-01-17 Bug found by Rob Simmons, example simplified by Nisse
-- {-# OPTIONS -v tc.proj.like:50 #-}
-- {-# OPTIONS -v tc.conv.atom:50 #-}
module Issue553b where
data E : Set where
module M (A : Set) where
data D : Set where
d₁ d₂ : D
data B : Set where
b : D → B
-- T must not be classified as ... |
-- This test case was reported by Andrea Vezzosi.
{-# OPTIONS --no-guardedness #-}
open import Agda.Builtin.Size
data Σ (A : Set) (B : A → Set) : Set where
_,_ : (x : A) → B x → Σ A B
data ⊥ : Set where
record T (i : Size) : Set where
constructor con
coinductive
field
force : Σ (Size< i) λ{ j → T j }
... |
{-# OPTIONS --without-K --safe #-}
-- Some properties of 'heterogeneous' identity morphisms
module Categories.Morphism.HeterogeneousIdentity.Properties where
open import Level
open import Data.Product using (curry) renaming (_,_ to _,,_)
open import Relation.Binary.PropositionalEquality
open import Categories.Categ... |
module PrintFloat where
import AlonzoPrelude
import PreludeShow
import PreludeList
import PreludeString
import PreludeNat
open AlonzoPrelude
open PreludeShow
open PreludeList, hiding(_++_)
open PreludeString
open PreludeNat
typeS : Char -> Set
typeS 'f' = Float
show : (c : Char) -> (typeS c) -> String
show 'f' f = s... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
module homotopy.CoHSpace where
record CoHSpaceStructure {i} (X : Ptd i) : Type i where
constructor coHSpaceStructure
field
⊙coμ : X ⊙→ X ⊙∨ X
coμ : de⊙ X → X ∨ X
coμ = fst ⊙coμ
field
⊙unit-l : ⊙projr ⊙∘ ⊙coμ ⊙∼ ⊙idf X
⊙unit-r : ⊙projl ⊙... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.