text stringlengths 4 690k |
|---|
module TakeDropDec where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; sym; trans; cong; cong₂; _≢_)
open import Data.Empty using (⊥; ⊥-elim)
open import Data.List using (List; []; _∷_)
open import Data.List.All using (All; []; _∷_)
open import Data.Bool using (Bool; true; false; T)
open... |
module PLRTree.Compound {A : Set} where
open import PLRTree {A}
data Compound : PLRTree → Set where
compound : {t : Tag}{x : A}{l r : PLRTree} → Compound (node t x l r)
|
module Class.Monoid where
open import Level
open import Data.List using (List; []; _∷_)
record Monoid {a} (M : Set a) : Set (suc a) where
infixl 6 _+_
field
mzero : M
_+_ : M -> M -> M
open Monoid {{...}} public
concat : ∀ {a} {M : Set a} {{_ : Monoid M}} -> List M -> M
concat [] = mzero
concat (x ∷ l) ... |
module Oscar.Data.Nat where
open import Agda.Builtin.Nat public using (Nat; zero; suc)
|
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Category.Slice.Properties {o ℓ e} (C : Category o ℓ e) where
open import Categories.Category.Equivalence using (StrongEquivalence)
open import Categories.Functor
open import Categories.Object.Product
open import Categories.Diagram.P... |
module Generic.Lib.Prelude where
open import Generic.Lib.Intro public
open import Generic.Lib.Equality.Propositional public
open import Generic.Lib.Equality.Coerce public
open import Generic.Lib.Equality.Heteroindexed public
open import Generic.Lib.Equality.Congn public
open import Gene... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of the pointwise lifting of a predicate to a binary tree
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Tree.Binary.Relation.U... |
{-# OPTIONS --guarded #-}
module _ where
primitive
primLockUniv : _
postulate
A B : primLockUniv
c : A → B
foo : (@tick x y : B) → Set
bar : (@tick x y : A) → Set
bar x y = foo (c x) (c y)
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Core definition of divisibility
------------------------------------------------------------------------
-- The definition of divisibility is split out from
-- `Data.Nat.Divisibility` to avoid a dependency cycle... |
{-# OPTIONS --without-K --safe #-}
-- We do not parameterize this module since we do not have access to _+_ or _*_
-- for the fields that we want (real numbers)
open import Level using (Level)
open import Relation.Binary.PropositionalEquality hiding (Extensionality)
open ≡-Reasoning
open import Data.Nat using (ℕ) re... |
-- Occurs when different mixfix patterns use similar names.
module Issue147b where
data X : Set where
f : X -> X
f_ : X -> X
x : X
bad : X -> X
bad (f x) = x
bad _ = x
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Bisimilarity for M-types
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --sized-types #-}
module Codata.M.Bisimilarity where
open import Level
open impo... |
------------------------------------------------------------------------
-- Least upper bounds
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
module Delay-monad.Least-upper-bound where
open import Equality.Propositional
open import Prelude hiding (_⊔_)
open imp... |
module Normalize where
open import Data.List
open import Data.Product
open import PiLevel0
-- We are going to use all the coherence as follows; make the right
-- hand side canonical and rewrite the left hand side to the right
-- hand side. Brute force below cannot work!
-- Use the same structure as
-- https://agda... |
module Prelude.Maybe where
open import Prelude.Unit
open import Prelude.Empty
open import Prelude.Function
open import Prelude.Functor
open import Prelude.Applicative
open import Prelude.Monad
open import Prelude.Equality
open import Prelude.Decidable
data Maybe {a} (A : Set a) : Set a where
nothing : Maybe A
ju... |
{-# OPTIONS --without-K --safe #-}
module Categories.Functor.Properties where
-- Properties valid of all Functors
open import Level
open import Data.Product using (proj₁; proj₂; _,_)
open import Function.Surjection using (Surjective)
open import Function.Equivalence using (Equivalence)
open import Function.Equality hi... |
module Experiment.Expr.Expr where
open import Data.Fin
open import Data.Empty
open import Level
open import Data.Bool
open import Data.Nat hiding (_⊔_)
open import Data.Product
open import Data.List as List hiding (or; and)
data Expr {v} (V : Set v) : Set v where
var : V -> Expr V
or and : Expr V -> Expr V -> Exp... |
module UniDB.Subst.Sum where
open import UniDB.Subst.Core
open import UniDB.Morph.Sum
--------------------------------------------------------------------------------
module _
(T : STX) {{vrT : Vr T}} {{wkT : Wk T}}
(X : STX) {{wkX : Wk X}} {{apTX : Ap T X}} {{apRelTX : ApRel T X}}
(Ξ : MOR) {{lkTΞ : Lk T Ξ}} ... |
open import Prelude
open import Reflection renaming (Term to AgTerm; Type to AgType)
open import Data.String using (String)
open import RW.Language.RTerm
open import RW.Language.RTermUtils
open import RW.Language.FinTerm
open import RW.Language.GoalGuesser 1
open import RW.Strategy
module RW.RW (db : TStratDB) where... |
{-# OPTIONS --cubical --safe #-}
module Cardinality.Finite.SplitEnumerable.Inductive where
open import Data.List public
open import Data.List.Membership
open import Prelude
ℰ! : Type a → Type a
ℰ! A = Σ[ xs ⦂ List A ] ((x : A) → x ∈ xs)
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
open import Cubical.Relation.Binary.Raw
module Cubical.Relation.Binary.Reasoning.Equivalence {c ℓ} {A : Type c} (E : Equivalence A ℓ) where
open Equivalence E
----------------------------------------------------------------------... |
{-# OPTIONS --without-K #-}
open import HoTT
open import homotopy.OneSkeleton
module homotopy.ConstantToSetFactorization
{i j} {A : Type i} {B : Type j} (B-is-set : is-set B)
(f : A → B) (f-is-const : ∀ a₁ a₂ → f a₁ == f a₂) where
private
Skel : Type i
Skel = Trunc ⟨0⟩ (OneSkeleton f)
abstract
... |
{-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.Id {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.Prop... |
{-# OPTIONS --cubical --safe #-}
open import Algebra
module Control.Monad.Weighted {ℓ} (rng : Semiring ℓ) where
open import Control.Monad.Weighted.Definition rng public
open import Control.Monad.Weighted.Union rng using (_∪_) public
open import Control.Monad.Weighted.Cond rng using (_⋊_) public
open impor... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
module homotopy.TruncationLoopLadder where
⊙Ω-Trunc : ∀ {i} {n : ℕ₋₂} (X : Ptd i)
→ ⊙Ω (⊙Trunc (S n) X) ⊙≃ ⊙Trunc n (⊙Ω X)
⊙Ω-Trunc X = ≃-to-⊙≃ (Trunc=-equiv [ pt X ] [ pt X ]) idp
step : ∀ {i j} n {X : Ptd i} {Y : Ptd j} (f : X ⊙→ Y)
→ ⊙CommSqu... |
open import Relation.Binary.PropositionalEquality using (_≡_; refl; sym; cong; cong₂)
open import Data.Nat using (ℕ; zero; suc; _≤_; z≤n; s≤s)
open import Data.Nat.Properties using (≤-total)
open import Data.Fin using (Fin; zero; suc)
open import Data.Product using (∃; ∃-syntax; _×_; _,_)
open import Data.Sum using ([_... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
module groups.Image where
module _ {i j k} {G : Group i} {H : Group j}
{K : Group k} (φ : H →ᴳ K) (ψ : G →ᴳ H) where
abstract
im-sub-im-∘ : is-surjᴳ ψ → im-propᴳ φ ⊆ᴳ im-propᴳ (φ ∘ᴳ ψ)
im-sub-im-∘ ψ-is-surj k = Trunc-rec Trunc-level
(λ{(h , ... |
{-# OPTIONS --allow-unsolved-metas #-}
open import Everything
module Test.ProblemWithLevelZero where
module _ (𝔓 : Ø₀) where
open Substitunction 𝔓
open Term 𝔓
fails : ∀ {m n} (f : Substitunction m n) → Substitunction m n
fails f = transitivity f ε -- FIXME
refl-works : ∀ {m} → Substitunction m m
re... |
{-# OPTIONS --safe #-}
module Cubical.HITs.Bouquet where
open import Cubical.HITs.Bouquet.Base public
open import Cubical.HITs.Bouquet.FundamentalGroupProof public
|
module Issue224 where
data Maybe (A : Set) : Set where
nothing : Maybe A
just : A → Maybe A
data D (A : Set) : Maybe A → Set where
d₁ : (x : A) → D A (just x)
d₂ : ∀ {x} → D A x → D A x
data S : ∀ {A x} → D A x → Set₁ where
s : ∀ {A x} {d : D A x} → S d → S (d₂ d)
foo : {A : Set} → S (d₂ (d₁ (nothing ... |
module Issue133 where
data Nat : Set where
zz : Nat
ss : Nat → Nat
data _==_ {X : Set}(x : X) : X → Set where
refl : x == x
data Zero : Set where
data Eq? (x : Nat) : Nat → Set where
same : Eq? x x
diff : {y : Nat} → (x == y → Zero) → Eq? x y
-- This failed before due to absurd lambda checking not getti... |
-- Andreas, 2017-01-18, issue #2408
-- DLubs were not serialized, thus, there was a problem with
-- level dependent on irrelevant values.
{-# OPTIONS --show-irrelevant #-}
-- {-# OPTIONS -v tc:70 #-}
open import Agda.Primitive
postulate
A : Set
l : .(a : A) → Level
F : .(a : A) → Set (l a)
-- checked type s... |
{-# OPTIONS --without-K #-}
module hott.functions where
open import hott.core.universe
open import hott.core.equality
-- Composition of functions.
_∘_ : ∀ {ℓ₀ ℓ₁ ℓ₂ : Level} → {A : Type ℓ₀} {B : Type ℓ₁} {C : Type ℓ₂}
→ (B → C) → (A → B) → A → C
f ∘ g = λ x → f (g x)
-- The identity function.
id : ∀{ℓ} {A : Typ... |
-- Non-indexed (plain) monads in form of Kleisli triple, presented in point-free style.
module Control.Monad.KleisliTriple where
open import Function using (id) renaming (_∘′_ to _∘_)
open import Relation.Binary.PropositionalEquality
open ≡-Reasoning
open import Axiom.FunctionExtensionality
open import Control.Funct... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- An either-or-both data type
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.These where
open import Level
open import Data.Sum.Base using... |
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.Nullification.Properties where
open import Cubical.Foundations.Everything
open isPathSplitEquiv
open import Cubical.Modalities.Everything
open Modality
open import Cubical.HITs.Localization renaming (rec to Localize-rec)
open import Cubical.Data.Unit
open import Cu... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.DunceCap.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.GroupoidLaws
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import C... |
{-# OPTIONS --safe #-}
module Definition.Typed.Consequences.Syntactic 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.Substitution
open imp... |
-- Andreas, 2012-03-15, example by Ulf
-- {-# OPTIONS -v tc.meta:20 #-}
module Issue479 where
import Common.Level
open import Common.Equality
data ⊥ : Set where
data Bool : Set where true false : Bool
X : Bool
X=true : X ≡ true
X≠false : X ≡ false → ⊥
X = _
X≠false ()
X=true = refl
-- The emptyness check for... |
-- Andreas, 2017-10-02, issue #2785, reported by ...
-- {-# OPTIONS -v scope.extendedLambda:100 #-}
{-# OPTIONS --allow-unsolved-metas #-}
foo : _
foo = {!foo λ {x y → foo}!} -- C-c C-r
-- Upon refine (C-c C-r), error was:
--
-- An internal error has occurred. Please report this as a bug.
-- Location of the error:... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties related to All
------------------------------------------------------------------------
module Data.List.All.Properties where
open import Data.Bool
open import Data.Bool.Properties
open import Data.E... |
open import slots.imports
open import slots.defs
module slots.bruteforce {cfg : config}(g : game cfg) where
open config cfg
open game g
total : ℕ
total = V.foldl _ (λ i r → i * L.length r) 1 reels
lineWin : Line → Win/Bet
lineWin [] = 0
lineWin (f₀ ∷ fs) = lineWin′ w ws fs where
winLine = V.lookup f₀ winTable
w... |
{-# OPTIONS --without-K #-}
module ConcretePermutationProperties where
open import Relation.Binary.PropositionalEquality
using (_≡_; refl; sym; trans; cong; module ≡-Reasoning; proof-irrelevance)
--
-- open import FinVecProperties using (∘̂-assoc; ∘̂-lid; ∘̂-rid)
open import ConcretePermutation
------------------... |
------------------------------------------------------------------------
-- An implementation of the Thue-Morse sequence
------------------------------------------------------------------------
-- This module is a variant of ThueMorse. The difference is that, in
-- this module, the cast operation takes an inequality i... |
{-# OPTIONS --warning=error #-}
module UnknownNameInFixityDecl where
infix 40 _+_
infixr 60 _*_
|
module Structure.Relator.Function.Multi where
open import Data.Tuple.RaiseTypeᵣ
import Data.Tuple.RaiseTypeᵣ.Functions as RaiseType
open import Function.Multi
import Function.Multi.Functions as Multi
import Lvl
import Lvl.MultiFunctions as Lvl
open import Logic
open import Logic.Predicate
open impo... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Instance.Rels where
open import Data.Product
open import Function
open import Level
open import Relation.Binary
open import Relation.Binary.Construct.Composition
open import Relation.Binary.PropositionalEquality
open import Categories.Category.Core
-- the... |
module Imports.Issue5198 (Y : Set₁) where
record R : Set₂ where
constructor mkR
field
A : Set₁
|
module Formalization.SKICombinatorCalculus where
import Lvl
import Function
open import Functional using (_∘_)
open import Type
open import Structure.Relator.Properties
open import Syntax.Transitivity
data Term : Type{Lvl.𝟎} where
S : Term -- Fusion
K : Term -- Constant
... |
{-# OPTIONS --cubical #-}
module Cubical.Foundations.Equiv.Fiberwise where
open import Cubical.Core.Everything
open import Cubical.Foundations.Everything
module _ {a p q} {A : Type a} (P : A → Type p) (Q : A → Type q)
(f : ∀ x → P x → Q x)
where
private
total : (Σ A P) → (Σ A Q)
total = (... |
{-# OPTIONS --without-K #-}
open import HoTT
{- Useful lemmas for computing the effect of transporting a function
- across an equivalence in the domain or codomain -}
module cohomology.FunctionOver where
{- transporting a function along an equivalcence or path in the domain -}
module _ {i} {j} {B : Type i} {C : Ty... |
module Issue396b where
import Common.Irrelevance
data A : Set where
-- just an irrelevant field
record PrfA : Set where
field
.f : A
Foo : Set -> Set1
Foo R = (P : R → Set) → ((x : R) → P x → P x) →
(x y : R) → P x → P y
foo : Foo PrfA
foo P hyp x y = hyp x
-- Error was:
-- x != y of... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Maybe-related properties
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Maybe.Properties where
open import Algebra
import Algebra.Struct... |
-- 2014-05-26 Andrea & Andreas, AIM XIX
-- Too eager pruning
module succeed.Issue1147 where
open import Common.Equality
open import Common.Product
open import Common.Prelude
postulate
A : Set
if_then_else1_ : ∀ {A : Set1} → Bool → A → A → A
if true then t else1 f = t
if false then t else1 f = f
test1 : let H : ... |
------------------------------------------------------------------------------
-- Well-founded relation on lists
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-... |
module Issue486 where
record ⊤ : Set where
constructor tt
record Pub (A : Set) : Set where
field
fi : A
abstract
abs : ⊤
abs = fi
where open Pub record {fi = tt}
|
------------------------------------------------------------------------
-- A definability result: A "closed value" is the semantics of a
-- closed term if and only if it satisfies all "Kripke predicates"
------------------------------------------------------------------------
-- This module is based on parts of Frede... |
module UntypedLambda where
open import Basics
open import Pr
open import Nom
import Syntacticosmos
data Tag : Set where
lamT : Tag
appT : Tag
open module ULam = Syntacticosmos TT TT (\_ -> Tag)
LAM : Kind
LAM = Ty _
SigLAM : Kind
SigLAM = Pi _ conk where
conk : Tag -> Kind
conk lamT = (LAM |> LAM) |> LAM
... |
{-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Semiring -- for length
open import Numbers.Naturals.Order
open import Semirings.Definition
open import Maybe
module Lists.Lists where
open import Lists.Definition public
open import Lists.Length public
open im... |
module CTL.Proof.EG where
open import CTL.Modalities.EG
open import FStream.Bisimulation
open import FStream.Core
open import FStream.FVec
open import Library
infixr 5 _▻EG_
infix 6 ⟨_▻EG
infix 7 _⟩EG
infixr 5 _▻EGᵢ_
infix 7 _⟩EGᵢ
data proofEG {ℓ₁ ℓ₂} {C : Container ℓ₁} : {n : ℕ} →
(props : FVec C (Set ℓ₂) n)... |
module Point where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
record Point : Set where
field
x : Nat
y : Nat
data _==_ {A : Set}(x : A) : A -> Set where
refl : x == x
open Point renaming (x to getX; y to getY)
<_,_> : Nat -> Nat -> Point
< x , y > = record { x = x; y = y }
η : (p : Point) ... |
open import Nat
open import Prelude
open import aasubsume-min
open import contexts
open import judgemental-erase
open import lemmas-matching
open import statics-core
open import synth-unicity
module determinism where
-- since we do not specify the name of newly inserted hole names,
-- we only have determinism up t... |
open import Agda.Builtin.Bool
module Issue4166.Import {b : Bool} where
instance
i : Bool
i = b
|
{-# OPTIONS --without-K #-}
module SEquivSCPermEquiv where
-- Data types from standard library
open import Level using (zero)
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 (_,_... |
module OlderBasicILP.Direct.Hilbert.Nested where
open import Common.Context public
-- Propositions of intuitionistic logic of proofs, without ∨, ⊥, or +.
mutual
infixr 10 _⦂_
infixl 9 _∧_
infixr 7 _▻_
data Ty : Set where
α_ : Atom → Ty
_▻_ : Ty → Ty → Ty
_⦂_ : Box → Ty → Ty
_∧_ : Ty → Ty → ... |
open import Agda.Builtin.Equality
record Box (B : Set) : Set₁ where
constructor box
field
unbox : B
-- here: .unbox is a valid forced pattern
=box : {B : Set} {Γ₀ Γ₁ : Box B} → Box.unbox Γ₀ ≡ Box.unbox Γ₁ → Γ₀ ≡ Γ₁
=box {Γ₀ = box unbox} {box r} p = ?
open Box public
-- here: .unbox is now the name of a p... |
module UnSized.SimpleCell where
open import Data.Product
open import Data.String.Base
open import UnSizedIO.Object
open import UnSizedIO.IOObject
open import UnSizedIO.ConsoleObject
open import UnSizedIO.Base hiding (main)
open import UnSizedIO.Console hiding (main)
open import NativeIO
data CellMethod A : Set whe... |
{-# OPTIONS --without-K #-}
module PiLevel1Alternative where
open import Relation.Binary.PropositionalEquality
open import Data.Nat
open import Data.Vec
open import FinVec
open F
open import ConcretePermutation
------------------------------------------------------------------------------
-- Equivalences between p... |
module Naturals where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_ ; refl ; cong )
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_; _∎ )
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
{-# BUILTIN NATURAL ℕ #-}
infixl 6 _+_
_+_ : ℕ → ℕ → ℕ
zero + x = x
(suc a) + x = suc (a + x)
-- Exercise: Write the ... |
module OpAppP where
data Bool
: Set
where
false
: Bool
true
: Bool
_&&_
: Bool
→ Bool
→ Bool
false && _
= false
true && b
= b
|
module SizedIO.coIOIOObject where
open import Data.Unit.Base
open import Data.Product
open import Data.String.Base
open import Size
open import SizedIO.Object
open import SizedIO.Base
open import SizedIO.Console
open import SizedIO.coIOIO
-- open import SizedIO.IOObject
record IOObject' (i : Size) (iface : Interf... |
{-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Library.Data.Empty where
open import Light.Level using (Level ; Setω)
open import Light.Variable.Sets
record Dependencies : Setω where
record Library (dependencies : Dependencies) : Setω where
field
ℓ : Le... |
open import Everything
module Test.Test6 where
module TestReflexivity where
postulate
X : Set
F : X → X → Set
instance ReflexivityF : Reflexivity.class F
test : ∀ {y} → F y y
test {y = y} = reflexivity
{-
Goal: F y y
Have: {𝔬 : Ł} {𝔒 : Set 𝔬} {𝔯 : Ł} {_∼_ : 𝔒 → 𝔒 → Set 𝔯}
{... |
{-# OPTIONS --cubical-compatible --rewriting -v rewriting:50 #-}
open import Agda.Primitive using (Level; _⊔_; Setω; lzero; lsuc)
module Issue4020 where
data _≡_ {ℓ : Level} {A : Set ℓ} (a : A) : A → Set ℓ where
refl : a ≡ a
{-# BUILTIN REWRITE _≡_ #-}
ap : ∀ {a b} {A : Set a} {B : Set b} (f : A → B) {a₁ a₂} → a... |
{-# OPTIONS --without-K #-}
module PComp where
open import Data.Empty
open import Data.Sum
open import Data.Nat as Nat
open import Data.Nat.Properties.Simple
open import Data.Nat.Properties
open import Data.Product
open import Data.Bool renaming (Bool to 𝔹)
open import Data.Bool.Properties
open import Relation.Nulla... |
{-# BUILTIN NATURAL ℕ #-}
------------------------------------------------------------------------
-- The Integers
--
-- or an extension of the Naturals (see the-naturals.agda)
------------------------------------------------------------------------
module the-integer where
open import Data.Nat as ℕ
using (ℕ) renam... |
-- {-# OPTIONS -v tc.lhs.unify.flexflex:100 -v tc.lhs.unify.assign:100 -v tc.lhs:100 #-}
module Multisplit where
postulate
Level : Set
lzero : Level
lsuc : Level → Level
_⊔_ : Level → Level → Level
{-# BUILTIN LEVEL Level #-}
{-# BUILTIN LEVELZERO lzero #-}
{-# BUILTIN LEVELSUC lsuc #-}
{-# BUILTIN L... |
{-# OPTIONS -v tc.meta:20 #-}
-- Andreas, 2011-04-15
-- source: Conor's post "foldl Miller magic" on the Agda list (2008)
module Issue325b where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
data Vec (X : Set) : Nat -> Set where
[] : Vec X zero
cons : (n : Nat) -> X -> Vec X n -> Vec X (suc n)
foldl ... |
{-# OPTIONS --without-K --safe #-}
module Definition.Typed.Consequences.Inversion where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.Consequences.Syntactic
open import Definition.Typed.Consequences.Substitution
open import Definition... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Interleavings of lists using propositional equality
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (Setoid)
module... |
open import Agda.Builtin.Nat
data Tree : Set where
` : Nat → Tree
_`+_ : Tree → Tree → Tree
⟦_⟧ : Tree → Nat
⟦ ` n ⟧ = n
⟦ t `+ u ⟧ = ⟦ t ⟧ + ⟦ u ⟧
data Target : Tree → Set where
0+_ : ∀ e → Target (` 0 `+ e)
_+0 : ∀ e → Target (e `+ ` 0)
[_] : ∀ e → Target e
target : ∀ e → Target e
target (` 0 `+ e... |
{-
Groupoid quotients:
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.GroupoidQuotients.Properties where
open import Cubical.HITs.GroupoidQuotients.Base
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cu... |
-- {-# OPTIONS -v tc.lhs.problem:10 #-}
-- Do not normalize goals!
module Issue734 where
id : Set → Set
id A = A
g : (A : Set) → id A
g A = {!!}
-- goal should be displayed as "id A", not as "A"
|
-- Solutions to ExerciseSession3
{-# OPTIONS --cubical #-}
module SolutionsSession3 where
open import Part1
open import Part2
open import Part3
open import Part4 hiding (ℤ)
open import ExerciseSession1 hiding (B)
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Nat
open import Cubical.Data.Int hid... |
module subst where
open import constants
open import cedille-types
open import ctxt-types
open import free-vars
open import rename
open import general-util
open import syntax-util
open import type-util
substh-ret-t : Set → Set
substh-ret-t T = ctxt → renamectxt → trie (Σi exprd ⟦_⟧) → T → T
{-# TERMINATING #-}
subst... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Groups.Definition
open import Setoids.Setoids
open import LogicalFormulae
open import Sets.EquivalenceRelations
open import Groups.Homomorphisms.Definition
open import Groups.Homomorphisms.Lemmas
open import Groups.Isomorphisms.Definition
open import Group... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Construction.Presheaves where
-- The Category of Presheaves over a Category C, i.e.
-- the Functor Category [ C.op , Setoids ]
-- Again, the levels are made explicit to show the generality and constraints.
open import Level
open import Categories.Category
... |
{-# OPTIONS --without-K #-}
module FinEquivEquivPlusTimes where
open import Data.Product using (_×_; proj₁; proj₂)
open import Equiv using (refl∼; sym∼; sym≃; _⊎≃_; id≃; _≃_; _●_; _×≃_; qinv)
open import FinEquivPlusTimes using (F0≃⊥; module Plus; module Times)
open Plus using (⊎≃+; +≃⊎)
open Times using (×≃*; *≃×)... |
open import MJ.Types as Types
import MJ.Classtable.Core as Core
module MJ.Semantics.Values {c}(Ct : Core.Classtable c) where
open import Prelude
open import Level renaming (suc to lsuc; zero to lzero)
open import Data.List hiding (null)
open import Data.List.Membership.Propositional
open import Data.List.Prefix
ope... |
module _ where
data D .(A : Set) : Set
-- The dot should not be repeated here
data D .A where
mkD : D A
|
{-# OPTIONS --warning=error #-}
module UselessPrivateImport where
private
open import Common.Prelude
|
{- 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.ImplShared.Consensus.Types
open import Util.Encode
open ... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.AbGroup.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Algebra.AbGroup.Base
private variable
ℓ : Level
module AbGroupTheory (A'@(A , Ar) : AbGroup ℓ) where
open AbGroupStr Ar
comm-4 : (a b c d : A) → ((a + b) + (c + d) ≡ (a + c) + ... |
module BBHeap.Complete.Base {A : Set}(_≤_ : A → A → Set) where
open import BBHeap _≤_
open import BBHeap.Complete.Alternative _≤_ renaming (lemma-bbheap-complete to lemma-bbheap-complete')
open import BTree.Complete.Alternative.Correctness {A}
open import BTree.Complete.Base {A}
open import Bound.Lower A
open import... |
------------------------------------------------------------------------------
-- Bisimulation on unbounded lists
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #... |
open import Issue3188.Issue3188a
B : Set
B = Set
|
module Oscar.Class.Functor where
open import Oscar.Class.Monoid
open import Oscar.Data.Equality
open import Oscar.Data.Product
open import Oscar.Level
open import Oscar.Relation
open import Oscar.Function
record Functor {a} {A : Set a} {b} (_↠_ : A → A → Set b) ⦃ _ : Monoid _↠_ ⦄ {c} (C : A → Set c) : Set (a ⊔ b ⊔ c... |
-- There was a bug when scope checking with clauses.
module WithScopeError where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
f : Nat -> Nat
f n with y
where y = suc n
f n | x = y x
|
{-# OPTIONS --without-K #-}
module Deltaplus where
{- Chapter 9.2: Semi-Simplicial Types
This file contains the definition of the index category
for semi-simplicial with judgmental categorical laws: Δ₊
In other words, we check Proposition 9.2.1.
We want to keep it independent of the other files,
so ... |
-----------------------------------------------------------------------
-- This file defines Dial₂(Sets) and its SMC structure. --
-----------------------------------------------------------------------
module Dial2Sets where
open import prelude
-- The objects:
Obj : Set₁
Obj = Σ[ U ∈ Set ] (Σ[ X ∈ Set ]... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.