text stringlengths 4 690k |
|---|
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
|
-- 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... |
-- 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.
|
-- 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... |
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
|
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... |
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... |
{-# 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... |
{-# 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
|
{-# 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... |
------------------------------------------------------------------------
-- Pi with partiality algebra families as codomains
------------------------------------------------------------------------
{-# OPTIONS --erased-cubical --safe #-}
module Partiality-algebra.Pi where
open import Equality.Propositional.Cubical
o... |
-- {-# 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
-... |
------------------------------------------------------------------------
-- 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... |
module LocalVsImportedModuleClash where
X = TODO--This-shouldn't-happen-if-the-scope-checker-does-it's-job
|
{-# 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... |
{-# 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... |
open import Common.Size
postulate
A : Set
f : Size → A
-- k' < k < j <= i + 2 =/=> ∃ l < i
test : ∀ i (j : Size< (↑ ↑ ↑ i)) (k : Size< j) (k' : Size< k) → Size → Set → (((l : Size< i) → A) → A) → A
test i j k k' _ _ ret = ret λ l → f l
|
module RTP where
open import RTN public
{-
data Bool : Set where
False : Bool
True : Bool
-}
postulate
Int : Set
String : Set
Float : Set
Char : Set
{-# BUILTIN FLOAT Float #-}
{-# BUILTIN STRING String #-}
{-# BUILTIN CHAR Char #-}
-- postulate primShowBool : Bool -> St... |
open import Agda.Primitive using (lzero; lsuc; _⊔_; Level)
open import Relation.Binary.PropositionalEquality using (_≡_; refl; subst)
open import Relation.Binary using (Setoid)
-- A formalization of raw syntax
module Syntax where
-- Syntactic classes
data ObjectClass : Set where
Ty Tm : ObjectClass
data ... |
-- 2011-10-01 Andreas
module EtaContractIrrelevant where
import Common.Level
data _≡_ {a}{A : Set a}(x : A) : A → Set where
refl : x ≡ x
subst : ∀ {a b}{A : Set a}(P : A → Set b){x y : A} → x ≡ y → P x → P y
subst P refl x = x
postulate
Val : Set
Pred = Val → Set
fam : Pred → Set1
fam A = {a : Val} → .(A a... |
------------------------------------------------------------------------
-- Termination
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
open import Prelude
module Delay-monad.Termination {a} {A : Type a} where
open import Equality.Propositional
open import Logi... |
-- Module shadowing using generated modules for records and datatypes
module Issue260a where
module D where
data D : Set where
|
interleaved mutual
data Nat : Set
record IsNat (n : Nat) : Set
isNat : (n : Nat) → IsNat n
|
module string-thms where
open import bool
open import eq
open import string
postulate
=string-refl : (s : string) → s =string s ≡ tt
=string-to-≡ : (a b : string) → a =string b ≡ tt → a ≡ b
≡string-to-= : (a b : string) → a ≡ b → a =string b ≡ tt
≡string-to-= a .a refl = =string-refl a
|
{-# OPTIONS --without-K #-}
module hott.truncation.core where
open import sum
open import equality
open import function.core
open import function.fibration
open import function.extensionality
open import function.isomorphism
open import sets.nat.core
open import hott.equivalence
open import hott.level.core
open import... |
module Human.Humanity where
-- Use agda-prelude instead of agda-stdlib?
open import Human.JS public
open import Human.Unit public
open import Human.Nat public
open import Human.List public
open import Human.Bool public
open import Human.String public
open import Human.IO public
open import Human.Float public
open imp... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Interleavings of lists using setoid equality
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (Setoid)
module Data.L... |
-- Andreas, 2015-12-29
record ⊤ : Set where
data P : ⊤ → Set where
c : P record{}
test : (x : ⊤) (p : P x) → Set
test _ c with ⊤
test _ y | z = ⊤
-- Expected error: with-clause pattern mismatch.
-- The error should be printed nicely, like:
--
-- With clause pattern x is not an instance of its parent pattern
-- re... |
{-
Product of structures S and T: X ↦ S X × T X
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Structures.Product where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Transport
open import... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.Group.EilenbergMacLane.WedgeConnectivity where
open import Cubical.Algebra.Group.EilenbergMacLane.Base
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Algebra.Group.Base
open import Cubi... |
-- Andreas, 2014-10-23
-- If you must, you can split on a shadowed hidden var...
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
f : {n n : ℕ} → Set₁
f = Set
where
g : {n n : ℕ} → Set → Set
g _ = {!.n!}
|
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2021, Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.Base.Types
import LibraBFT.Impl.Consensus.Consensus... |
{-# OPTIONS --without-K --safe #-}
-- a categorical (i.e. non-skeletal) version of Lawvere Theory,
-- as per https://ncatlab.org/nlab/show/Lawvere+theory
module Categories.Theory.Lawvere where
open import Data.Nat using (ℕ)
open import Data.Product using (Σ; _,_)
open import Level
open import Categories.Category.Ca... |
{-# OPTIONS --without-K --safe #-}
module Data.Maybe.Base where
open import Level
data Maybe (A : Type a) : Type a where
nothing : Maybe A
just : A → Maybe A
maybe : {B : Maybe A → Type b} → B nothing → ((x : A) → B (just x)) → (x : Maybe A) → B x
maybe b f nothing = b
maybe b f (just x) = f x
mapMaybe : ... |
{-# OPTIONS --cubical --safe #-}
-- First and second species counterpoint
module Counterpoint where
open import Data.Bool using (Bool; true; false; if_then_else_; _∨_; _∧_; not)
open import Data.Fin using (Fin; #_)
open import Data.Integer using (+_)
open import Data.List using (List; []; _∷_; mapMaybe; map; zip; _++... |
{-# OPTIONS --rewriting #-}
open import Agda.Builtin.Equality
open import Agda.Builtin.Equality.Rewrite
open import Agda.Builtin.Unit
postulate
A : Set
a : A
f : {X : Set} → X → A
g : {X : Set} → A → X
rew-fg : {X : Set} (a : A) → f (g {X} a) ≡ a
{-# REWRITE rew-fg #-}
test : f tt ≡ a
test = refl
|
module VecFlip where
open import AgdaPrelude
goodNil : Vec Nat Zero
goodNil = Nil Nat
badNil : Vec Zero Nat
badNil = Nil Nat
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
module groups.HomSequence where
infix 15 _⊣|ᴳ
infixr 10 _→⟨_⟩ᴳ_
data HomSequence {i} : (G : Group i) (H : Group i) → Type (lsucc i) where
_⊣|ᴳ : (G : Group i) → HomSequence G G
_→⟨_⟩ᴳ_ : (G : Group i) {H K : Group i}
→ (G →ᴳ H) → HomSequence H K
→... |
------------------------------------------------------------------------------
-- Conversion rules for inequalities
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism... |
--{-# OPTIONS --with-K #-}
open import Data
open import Data.Tuple using (_⨯_ ; _,_)
open import Logic.Predicate
import Lvl
open import Syntax.Number
import Type as Meta
-- `Constants` is the type of all possible constant terms.
-- `Sort` is a subset of `Constants` that indicate the sorts of the type system... |
------------------------------------------------------------------------
-- Vectors
------------------------------------------------------------------------
module Data.Vec where
open import Data.Nat
open import Data.Fin using (Fin; zero; suc)
open import Data.List as List using (List)
open import Data.Product using ... |
module bool where
open import level
----------------------------------------------------------------------
-- datatypes
----------------------------------------------------------------------
open import unit
open import empty
data 𝔹 : Set where
tt : 𝔹
ff : 𝔹
-- this is an alias for Mac users who cannot see bl... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.PushoutSplit
module cw.cohomology.CofiberGrid {i j k}
{A : Type i} {B : Type j} {C : Type k}
(f : A → B) (g : B → C) where
{-
A -------> B -----------> C
| | _/|
| | _/ |
| ... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Diagram.Pullback.Limit {o ℓ e} (C : Category o ℓ e) where
open import Data.Product using (∃₂; _,_)
open import Function using (_$_)
open import Categories.Category.Instance.Span
open import Categories.Functor
open import Categories... |
{-# OPTIONS --without-K --safe #-}
module Dodo.Binary.Domain where
-- Stdlib imports
open import Level using (Level; _⊔_)
open import Function.Base using (flip; _∘_)
open import Data.Product using (_×_; _,_; ∃; ∃-syntax; proj₁; proj₂)
open import Data.Sum using (_⊎_; inj₁; inj₂; swap)
open import Relation.Un... |
{-# OPTIONS --without-K --safe #-}
module Dodo.Binary.Empty where
-- Stdlib imports
open import Level using (Level; _⊔_)
open import Relation.Nullary using (¬_)
open import Relation.Binary using (REL; Rel)
-- # Definitions
-- | A predicate stating no inhabitants exist for the given relation
Empty₂ : ∀ {a b ℓ : Lev... |
module Text.Greek.SBLGNT.Heb where
open import Data.List
open import Text.Greek.Bible
open import Text.Greek.Script
open import Text.Greek.Script.Unicode
ΠΡΟΣ-ΕΒΡΑΙΟΥΣ : List (Word)
ΠΡΟΣ-ΕΒΡΑΙΟΥΣ =
word (Π ∷ ο ∷ ∙λ ∷ υ ∷ μ ∷ ε ∷ ρ ∷ ῶ ∷ ς ∷ []) "Heb.1.1"
∷ word (κ ∷ α ∷ ὶ ∷ []) "Heb.1.1"
∷ word (π ∷ ο ∷ ∙λ ∷ ... |
------------------------------------------------------------------------------
-- Totality of predecessor function
------------------------------------------------------------------------------
{-# OPTIONS --allow-unsolved-metas #-}
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types ... |
postulate
F : Set → Set
_ : {@0 A : Set} → F λ { → A }
|
-- Andreas 2019-11-06, issue #4172, examples by nad.
-- Single constructor matches for non-indexed types should be ok
-- even when argument is erased, as long as pattern variables
-- are only used in erased context on the rhs.
-- https://github.com/agda/agda/issues/4172#issue-517690102
record Erased (A : Set) : Set ... |
S : Set; S = S
|
------------------------------------------------------------------------
-- A formalization of the polymorphic lambda calculus extended with
-- iso-recursive types
------------------------------------------------------------------------
-- Author: Sandro Stucki
-- Copyright (c) 2015 EPFL
-- The code in this directory... |
-- Andreas, 2016-09-28
-- Level constraints X <= a and a <= X should solve X = a.
-- {-# OPTIONS -v tc.constr.add:40 #-}
open import Common.Level
module _ (a : Level) where
mutual
X : Level
X = _
data C : Set (lsuc X) where
c : Set a → C -- constrains X by a <= X
data D : Set (lsuc a) where
c : S... |
{-# OPTIONS --allow-unsolved-metas #-}
{-# OPTIONS --show-implicit #-}
module HeapProperties where
open import HeapPropertiesDefs public
open import HeapLemmasForSplitting public
|
{-# OPTIONS --without-K #-}
open import HoTT
{- A proof that (A * B) * C ≃ (C * B) * A, which combined with commutativity
- proves associativity.
-
- Agda has a hard time compiling this but sometimes it succeeds.
-
- Favonia (2016 May): I have consistent success in compiling this file.
-
-}
open import homoto... |
-- {-# OPTIONS -v tc.meta:25 #-}
-- Andreas, 2013-05-23
module DontPruneBlocked where
open import Common.Equality
open import Common.Product
data Bool : Set where
true false : Bool
if : {A : Set} → Bool → A → A → A
if true a b = a
if false a b = b
test1 :
let Fst : Bool → Bool → Bool
Fst = _
I : Bo... |
-- The following file contains various examples of highlighting.
-- It does not necessarily typecheck (but it should parse)
a : A → Set
a b : A → Set
postulate a : A → Set
abstract a b : A → Set
abstracta : A → Set
postulate abstract a : A → Set
private
a b : A → Set
abstract a : A → Set
pattern-a : A → Set
abstra... |
-- Andreas, 2014-02-11 issue raised by Niccolo Veltri
-- {-# OPTIONS -v term.matrices:40 #-}
open import Common.Equality
data _=⟨_⟩⇒*_ {X : Set}(x : X)(f : X → X) : X → Set where
done : x =⟨ f ⟩⇒* x
next : ∀{y z} → f y ≡ z → x =⟨ f ⟩⇒* y → x =⟨ f ⟩⇒* z
trans* : ∀{X}{x y z}{f : X → X} → x =⟨ f ⟩⇒* y → y =⟨ f ⟩⇒* ... |
-- This file comes from the agda class taught by Peter Selinger at
-- Dalhousie University. It contains a bonus question that
-- propostional logic is complete. We will show this in
-- Kalmar.agda.
-- The course link:
-- https://www.mathstat.dal.ca/~selinger/agda-lectures/
{-# OPTIONS --without-K --safe #-}
module Pr... |
{-# OPTIONS --safe #-}
module Cubical.Data.Queue where
open import Cubical.Data.Queue.Base public
open import Cubical.Data.Queue.Finite public
|
--------------------------------------------------------------------------------
-- This is part of Agda Inference Systems
{-# OPTIONS --sized-types #-}
open import Agda.Builtin.Equality
open import Data.Product
open import Data.Sum
open import Size
open import Codata.Thunk
open import Level
open import Relation.Una... |
module ShadowModule where
module A where
module B where
data D : Set where
open A
module B where
|
module Metalogic.Classical.Propositional.ProofSystem {ℓₚ} (Proposition : Set(ℓₚ)) where
import Lvl
open import Data hiding (empty)
import Data.List
open Data.List using (List ; ∅ ; _⊰_ ; _++_ ; [_ ; _])
open Data.List.Notation
import Data.List.Relation.Membership
import Data.List.Rela... |
module nodcap.NF.Axiom where
open import Data.Nat as ℕ using (ℕ; suc; zero)
open import Data.Pos as ℕ⁺
open import Data.List as L using (List; []; _∷_; _++_)
open import Function using (_$_)
open import Relation.Binary.PropositionalEquality as P using (_≡_; _≢_)
open import Data.Environment
open import nodcap.Base
ope... |
module Levitation where
open import Data.Product
record ⊤ : Set1 where
constructor tt
data Desc : Set2 where
`1 : Desc
`Σ : (S : Set1)(D : S → Desc) → Desc
`ind× : (D : Desc) → Desc
`hind× : (H : Set)(D : Desc) → Desc
⟦_⟧ : Desc → Set1 → Set1
⟦ `1 ⟧ X = ⊤
⟦ `Σ S D ⟧ X = Σ S (\s → ⟦ D s ⟧ X)... |
--
-- Created by Dependently-Typed Lambda Calculus on 2020-10-08
-- Connective
-- Author: dplaindoux
--
{-# OPTIONS --without-K #-}
module Connective where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl)
open Eq.≡-Reasoning
open import Data.Nat using (ℕ)
open import Function using (_∘_)
... |
module Generic.Test.Elim where
open import Generic.Core
open import Generic.Function.Elim
open import Generic.Test.Data.Vec
-- Is it possible to get rid of these `lift`s?
elimVec′ : ∀ {n α π} {A : Set α}
-> (P : ∀ {n} -> Vec A n -> Set π)
-> (∀ {n} {xs : Vec A n} x -> P xs -> P (x ∷ᵥ xs))
-... |
------------------------------------------------------------------------
-- Some corollaries
------------------------------------------------------------------------
module TotalParserCombinators.Derivative.Corollaries where
open import Data.List
open import Function.Base
open import Function.Inverse using (_↔_)
impo... |
{-# OPTIONS --safe --sized-types #-}
module STLC.Operational where
open import STLC.Operational.Base
|
{-# OPTIONS --cubical-compatible #-}
module WithoutK-PatternSynonyms2 where
-- Equality defined with two indices.
data _≡_ {A : Set} : A → A → Set where
refl : ∀ x → x ≡ x
pattern r x = refl x
-- The --cubical-compatible option works with pattern synonyms.
K : (A : Set) (x : A) (P : x ≡ x → Set) → P (refl x) → (p... |
open import Relation.Binary.Core
module BBHeap.Insert {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_)
(trans≤ : Transitive _≤_) where
open import BBHeap _≤_
open import BBHeap.Properties _≤_
open import BBHeap.Subtyping.Properties _≤_ trans≤
open import Bound.... |
------------------------------------------------------------------------
-- Some definitions related to the binary sum type former
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
module Sum {c⁺} (eq : ∀ {a p} → Equality-with-J a p c⁺) w... |
module StdLibStuff where
{-
-- Data.Empty
data ⊥ : Set where
-- Relation.Nullary.Core
infix 3 ¬_
¬_ : Set → Set
¬ P = P → ⊥
data Dec (P : Set) : Set where
yes : ( p : P) → Dec P
no : (¬p : ¬ P) → Dec P
-}
-- Relation.Binary.Core
infix 4 _≡_ -- _≢_
data _≡_ {A : Set} (x : A) : A → Set where
refl : x ≡... |
-- Andreas, 2021-04-14, #1154
-- Andreas, 2021-04-12, BNFC/bnfc#354
-- Make sure we confirm tentative layout columns on first newline.
private private private A : Set
B : Set -- all three blocks (8,16,24) should be confirmed here
private -- the column for this block ne... |
module LC.Base where
open import Data.Nat
--------------------------------------------------------------------------------
-- de Bruijn indexed lambda calculus
infix 5 ƛ_
infixl 7 _∙_
infix 9 var_
data Term : Set where
var_ : (x : ℕ) → Term
ƛ_ : (M : Term) → Term
_∙_ : (M : Term) → (N : Term) → Term
|
module posts.agda.typed-protocols where
open import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl)
open import Relation.Nullary using (¬_)
open import Data.Empty using (⊥; ⊥-elim)
open import Data.List
open import Data.Nat
open import Data.Unit using (⊤; tt)
open import Function.Base using (_$_;... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.Vec.Relation.Binary.Pointwise.Extensional directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
modu... |
open import MJ.Types
import MJ.Classtable.Core as Core
module MJ.Classtable.Code {c}(Ct : Core.Classtable c) where
open import Prelude
open import Data.Maybe as Maybe using (Maybe; just; nothing)
open import Data.Star as Star
open import Data.List
open import Data.List.Relation.Unary.All hiding (construct)
open impor... |
-- Andreas, Jesper, 2017-05-13, issue #2578 reported by nad
-- Jesper, 2017-07-06, absurd clauses are no longer highlighted as catchall,
-- so the test case had to be changed to reproduce the intended behaviour.
data _⊎_ (A B : Set) : Set where
inj₁ : A → A ⊎ B
inj₂ : B → A ⊎ B
record ⊤ : Set where
constructor ... |
-- Check that errors from tactics are displayed properly.
module _ where
open import Common.Prelude hiding (_>>=_)
open import Common.Equality
open import Common.Reflection
failTactic : Term → TC ⊤
failTactic hole =
inferType hole >>= λ goal →
typeError (strErr "Surprisingly the" ∷ nameErr (quote failTactic) ∷
... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- The Maybe type
------------------------------------------------------------------------
-- The definitions in this file are reexported by Data.Maybe.
module Data.Maybe.Core where
open import Level
data Maybe ... |
module Type.Identity.Proofs where
import Lvl
open import Structure.Function
open import Structure.Relator.Properties
open import Structure.Relator
open import Structure.Type.Identity
open import Type.Identity
open import Type
private variable ℓ ℓ₁ ℓ₂ ℓₑ ℓₑ₁ ℓₑ₂ ℓₚ : Lvl.Level
private variable T A B : Type{ℓ}
pri... |
-- Abstract constructors
module Issue476c where
module M where
data D : Set
abstract
data D where
c : D
x : M.D
x = M.c |
module Array.APL where
open import Array.Base
open import Array.Properties
open import Data.Nat
open import Data.Nat.DivMod hiding (_/_)
open import Data.Nat.Properties
open import Data.Fin using (Fin; zero; suc; raise; toℕ; fromℕ≤)
open import Data.Fin.Properties using (toℕ<n)
open import Data.Vec
open import Data.Ve... |
module Numeral.Natural.Coprime.Proofs where
open import Functional
open import Logic
open import Logic.Classical
open import Logic.Propositional
open import Logic.Propositional.Theorems
import Lvl
open import Numeral.Finite
open import Numeral.Natural
open import Numeral.Natural.Coprime
open import Numeral.Natura... |
{-# 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... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- The Stream type and some operations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --sized-types #-}
module Codata.Stream where
open import Size
open im... |
------------------------------------------------------------------------------
-- ABP auxiliary lemma
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIO... |
-- Andreas, 2019-02-24, issue #3457
-- Error messages for illegal as-clause
import Agda.Builtin.Nat Fresh-name as _
-- Previously, this complained about a duplicate module definition
-- with unspeakable name.
-- Expected error:
-- Not in scope: Fresh-name
|
module Classes where
open import Agda.Primitive
open import Agda.Builtin.Equality
open import Relation.Binary.PropositionalEquality.Core
open ≡-Reasoning
id : ∀ {ℓ} {A : Set ℓ} → A → A
id x = x
_$_ : ∀ {ℓ} {A B : Set ℓ} → (A → B) → A → B
_$_ = id
_∘_ : ∀ {ℓ} {A B C : Set ℓ} → (B → C) → (A → B) → A → C
f ∘ g = λ ... |
data Bool : Set where
true false : Bool
record Top : Set where
foo : Top
foo with true
... | true = _
... | false = top
where
top = record{ } -- the only purpose of this was to force
-- evaluation of the with function clauses
-- which were in an __IMPOSSIBLE__ stat... |
open import Prelude
open import Nat
open import dynamics-core
open import contexts
module lemmas-disjointness where
-- disjointness is commutative
##-comm : {A : Set} {Δ1 Δ2 : A ctx} → Δ1 ## Δ2 → Δ2 ## Δ1
##-comm (π1 , π2) = π2 , π1
-- the empty context is disjoint from any context
empty-disj : {A : Set} (Γ... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.Group.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Structure
open import Cubical.Foundations.GroupoidLaws hiding (assoc)
open import Cubical.Data.Sigma
open import Cubical.Algebra.Semigrou... |
{-# OPTIONS --safe #-}
module Cubical.HITs.Cost where
open import Cubical.HITs.Cost.Base
|
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020, 2021, Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import Level using (0ℓ)
open import Util.Prelude
-- This module i... |
module Cats.Category.Setoids.Facts where
open import Cats.Category
open import Cats.Category.Setoids using (Setoids)
open import Cats.Category.Setoids.Facts.Exponentials using (hasExponentials)
open import Cats.Category.Setoids.Facts.Initial using (hasInitial)
open import Cats.Category.Setoids.Facts.Products
using ... |
module AML where
open import Level
open import Data.Product
data satisfied (a : Set) (m : Set → Set) : Set where
s : m a → satisfied a m
data reachability (m₀ : Set → Set) (m : Set → Set) : Set where
tt : reachability m₀ m
data necessarity (m₀ : Set → Set) (a : Set) : Set₁ where
n : ∀ m → (reachability m₀ m) ... |
module Array.Properties where
open import Array.Base
open import Data.Fin using (Fin; zero; suc; raise; fromℕ≤; fromℕ<; fromℕ)
open import Data.Nat
open import Data.Nat.Properties
open import Data.Vec
open import Data.Vec.Properties
open import Relation.Binary.PropositionalEquality
open import Function using (_$_; _∘... |
module Oscar.Class.Symmetry where
open import Oscar.Class.Extensionality
open import Oscar.Function
open import Oscar.Level
record Symmetry {a} {A : Set a} {ℓ} (_≤_ : A → A → Set ℓ) : Set (a ⊔ ℓ) where
field
⦃ ′extensionality ⦄ : Extensionality _≤_ (λ ⋆ → flip _≤_ ⋆) id id
symmetry : ∀ {x y} → x ≤ y → y ≤ x... |
import cedille-options
module elaboration (options : cedille-options.options) where
open import lib
options' = record options
{during-elaboration = tt;
erase-types = ff;
show-qualified-vars = ff}
open import general-util
open import monad-instances
open import cedille-types
open import classify options' {id}... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.