text stringlengths 4 690k |
|---|
------------------------------------------------------------------------
-- A variant of Induction for Set₁
------------------------------------------------------------------------
-- I want universe polymorphism.
module Induction1 where
open import Relation.Unary1
-- A RecStruct describes the allowed structure of ... |
-- Andreas, 2012-03-09 do not solve relevant meta variable by irr. constraint
module Issue351a where
open import Common.Irrelevance
open import Common.Equality
data Bool : Set where
true false : Bool
-- the Boolean b is not(!) constrained by the equation
f : (b : Bool) -> squash b ≡ squash true -> Bool
f b _ = b
... |
-- Andreas, 2018-06-10, issue #2797
-- Analysis and test case by Ulf
-- Relevance check was missing for overloaded projections.
{-# OPTIONS --irrelevant-projections #-}
-- {-# OPTIONS -v tc.proj.amb:30 #-}
open import Agda.Builtin.Nat
record Dummy : Set₁ where
field nat : Set
open Dummy
record S : Set where
f... |
module binding-preserve where
open import utility
renaming (_U̬_ to _∪_ ; _|̌_ to _-_)
open import sn-calculus
open import Function using (_∋_ ; _$_ ; _∘_)
open import Esterel.Lang
open import Esterel.Lang.Binding
open import Esterel.Lang.Properties
using (done; halted ; paused ; value-max)
open import Esterel.Co... |
module sn-calculus-confluence.rec where
open import Data.Nat using (_+_)
open import Function using (_∋_ ; _∘_)
open import Data.Nat.Properties.Simple using ( +-comm ; +-assoc )
open import utility
open import Esterel.Lang
open import Esterel.Lang.Properties
open import Esterel.Environment as Env
open import Esterel.C... |
{-# OPTIONS --without-K #-}
module hott.level where
open import hott.level.core public
open import hott.level.sets public
open import hott.level.closure public
|
{-# OPTIONS --safe #-}
module Cubical.Algebra.DirectSum.Equiv-DSHIT-DSFun where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Transport
open import Cubical.Relation.Nulla... |
-- The empty type; also used as absurd proposition (``Falsity'').
{-# OPTIONS --without-K --safe #-}
module Tools.Empty where
open import Data.Empty public
|
module STT where
-- simple type theory
{-
open import Data.Bool
open import Relation.Binary.PropositionalEquality
open import Data.Nat hiding (_>_)
-}
open import StdLibStuff
open import Syntax
-- inference system
data ⊢_ : ∀ {n} → {Γ : Ctx n} → Form Γ $o → Set where
ax-1 : ∀ {n} → {Γ : Ctx n} {x : Var Γ} →
(... |
{-# OPTIONS --without-K --safe #-}
open import Algebra
module Loop.Properties
{a ℓ} (L : Loop a ℓ) where
open Loop L
|
-- Load me
module QuotationMark where
open import Agda.Builtin.Char
open import Agda.Builtin.List
open import Agda.Builtin.String
s : List Char
s = ")"
|
-- Andreas, 2017-05-26
-- Expand ellipsis with C-c C-c . RET
open import Agda.Builtin.Nat
test0 : Nat → Nat
test0 x with zero
... | q = {!.!} -- C-c C-c
-- Expected result:
-- test0 x | q = ?
data Fin : Nat → Set where
zero : ∀ n → Fin (suc n)
suc : ∀{n} → Fin n → Fin (suc n)
test1 : ∀{n} → Fin n → Nat
tes... |
module Lib.Monad where
open import Lib.Nat
open import Lib.List
open import Lib.IO hiding (IO; mapM)
open import Lib.Maybe
open import Lib.Prelude
infixr 40 _>>=_ _>>_
infixl 90 _<*>_ _<$>_
-- Wrapper type, used to ensure that ElM is constructor-headed.
record IO (A : Set) : Set where
constructor io
field unIO... |
{-# OPTIONS --sized-types #-}
module SizedTypesMergeSort where
postulate
Size : Set
_^ : Size -> Size
∞ : Size
{-# BUILTIN SIZE Size #-}
{-# BUILTIN SIZESUC _^ #-}
{-# BUILTIN SIZEINF ∞ #-}
-- sized lists
data List (A : Set) : {_ : Size} -> Set where
[] : {size : Size} -> List A {size ^}
_::_ : ... |
open import Formalization.PredicateLogic.Signature
module Formalization.PredicateLogic.Minimal.NaturalDeduction.Tree (𝔏 : Signature) where
open Signature(𝔏)
open import Data.DependentWidthTree as Tree hiding (height)
import Lvl
open import Formalization.PredicateLogic.Minimal.NaturalDeduction (𝔏)
open import ... |
{-# OPTIONS --without-K --safe #-}
module Categories.Diagram.Limit.Ran where
open import Level
open import Data.Product using (Σ)
open import Categories.Category
open import Categories.Category.Complete
open import Categories.Category.Construction.Cones
open import Categories.Category.Construction.Comma
open import ... |
module regular-language where
open import Level renaming ( suc to Suc ; zero to Zero )
open import Data.List
open import Data.Nat hiding ( _≟_ )
open import Data.Fin hiding ( _+_ )
open import Data.Empty
open import Data.Unit
open import Data.Product
-- open import Data.Maybe
open import Relation.Nullary
open impo... |
{-# OPTIONS --safe #-}
module Cubical.HITs.Truncation.FromNegTwo where
open import Cubical.HITs.Truncation.FromNegTwo.Base public
open import Cubical.HITs.Truncation.FromNegTwo.Properties public
|
open import Empty
module Boolean where
data Bool : Set where
true : Bool
false : Bool
{-# BUILTIN BOOL Bool #-}
{-# BUILTIN TRUE true #-}
{-# BUILTIN FALSE false #-}
T : Bool → Set
T true = ⊤
T false = ⊥
not : Bool → Bool
not true = false
not false = true
and : Bool → Bool → Bool
a... |
-- Andreas, 2016-12-30, issues #555 and #1886, reported by nad
-- Hidden parameters can be omitted in the repetition
-- of the parameter list.
record R {a} (A : Set a) : Set a
record R A where
constructor c
field f : A
testR : ∀{a}{A : Set a}(x : A) → R A
testR x = c x
data D {a} (A : Set a) : Set a
data D A ... |
{-# OPTIONS --no-print-pattern-synonyms #-}
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
data Fin : Nat → Set where
fzero : ∀ {n} → Fin (suc n)
fsuc : ∀ {n} → Fin n → Fin (suc n)
pattern #1 = fsuc fzero
prf : (i : Fin 2) → i ≡ #1
prf i = refl -- should say i != fsuc fzero
|
module Numeral.Sign where
import Lvl
open import Type
-- The set of plus or minus sign
data +|− : Type{Lvl.𝟎} where
➕ : (+|−)
➖ : (+|−)
−|+ = +|−
elim₂ : ∀{ℓ}{P : (+|−) → Type{ℓ}} → P(➖) → P(➕) → ((s : (+|−)) → P(s))
elim₂ neg pos ➖ = neg
elim₂ neg pos ➕ = pos
-- The set of signs: plus, minus and neutral... |
{- 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.SafetyRul... |
-- Andreas, 2011-10-04, transcription of Dan Doel's post on the Agda list
{-# OPTIONS --experimental-irrelevance #-}
module IrrelevantMatchRefl where
import Common.Level
open import Common.Equality hiding (subst)
-- irrelevant subst should be rejected, because it suggests
-- that the equality proof is irrelevant also... |
{-# OPTIONS --without-K #-}
open import HoTT
open import homotopy.JoinFunc
-- Associativity of the join (work in progress)
module homotopy.JoinAssoc3 where
import homotopy.JoinAssoc as Assoc
module JoinAssoc3 {i} (A : Type i) (B : Type i) (C : Type i) where
module A31 = Assoc A B C
postulate
-- from : ... |
{- Formal verification of authenticated append-only skiplists in Agda, version 1.0.
Copyright (c) 2020 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 Data.Unit.NonEta
open import Data.Empty
open import Data... |
module Algebra.Module.Morphism.Module where
open import Assume using (assume)
open import Algebra.Core using (Op₁; Op₂)
open import Algebra.Bundles using (CommutativeRing)
open import Algebra.Module.Bundles using (Module)
open import Algebra.Module.Structures using (IsModule)
open import Algebra.Module.Normed using (I... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category where
open import Level
-- The main definitions are in:
open import Categories.Category.Core public
private
variable
o ℓ e : Level
-- Convenience functions for working over mupliple categories at once:
-- C [ x , y ] (for x y objects of C) - Hom_C(... |
{-# OPTIONS -v treeless.opt:20 #-}
open import Agda.Builtin.Nat
open import Common.IO using (return)
open import Agda.Builtin.Unit
data List {a} (A : Set a) : Set a where
[] : List A
_∷_ : A → List A → List A
data Vec {a} (A : Set a) : ..(_ : Nat) → Set a where
[] : Vec A 0
_∷_ : ∀ ..{n} → A → Vec A n → Vec... |
module Pr where
data FF : Set where
magic : {X : Set} -> FF -> X
magic ()
record TT : Set where
data Id {S : Set}(s : S) : S -> Set where
refl : Id s s
data Pr : Set1 where
tt : Pr
ff : Pr
_/\_ : Pr -> Pr -> Pr
all : (S : Set) -> (S -> Pr) -> Pr
_eq_ : {S : Set} -> S -> S -> Pr
record Sig (S : Set)(T ... |
{-# OPTIONS --cubical --no-import-sorts --no-exact-split --safe #-}
module Cubical.Data.InfNat where
open import Cubical.Data.InfNat.Base public
open import Cubical.Data.InfNat.Properties public
|
{-# OPTIONS --sized-types #-}
module Lang.Size where
-- Some stuff about sizes that seems to :
-- • Types:
-- • SizeU : TYPE
-- • Size : TYPE
-- • <ˢⁱᶻᵉ_ : Size → TYPE
-- • 𝐒ˢⁱᶻᵉ : Size → Size
-- • ∞ˢⁱᶻᵉ : Size
-- • _⊔ˢⁱᶻᵉ_ : Size → Size → Size
-- • Subtyping : ∀s₁∀s₂. (s₁: <ˢⁱᶻᵉ s₂) ... |
------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Variables and contexts
--
-- This module defines the syntax of contexts and subcontexts,
-- together with variables and properties of these notions.
--
-- This module is parametric in the syntax of types, so it
-- c... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.List.Relation.Binary.Sublist.Propositional directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
mod... |
-- Andreas, 2012-01-10
-- {-# OPTIONS -v tc.constr.findInScope:50 #-}
module InstanceGuessesMeta where
data Bool : Set where
true false : Bool
postulate
D : Bool -> Set
E : Bool -> Set
d : {x : Bool} -> D x
f : {x : Bool}{{ dx : D x }} -> E x
b : E true
b = f -- should succeed
-- Agda is now allowed to so... |
-- Andreas, 2011-04-14
-- {-# OPTIONS -v tc.cover:20 -v tc.lhs.unify:20 #-}
module Issue291a where
open import Common.Coinduction
open import Common.Equality
data RUnit : Set where
runit : ∞ RUnit -> RUnit
j : (u : ∞ RUnit) -> ♭ u ≡ runit u -> Set
j u ()
-- needs to fail (reports a Bad split!)
|
module SystemF.Syntax where
open import SystemF.Syntax.Type public
open import SystemF.Syntax.Term public
open import SystemF.Syntax.Context public
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Foundations.Filler where
open import Cubical.Foundations.Prelude
private
variable
ℓ ℓ' : Level
A : Type ℓ
cube-cong : {a b : A}
{p p' q q' : a ≡ b}
(P : p ≡ p') (Q : q ≡ q')
→ (p ≡ q) ≡ (p' ≡ q')
cube-con... |
{-# OPTIONS --syntactic-equality=2 --allow-unsolved-metas #-}
-- Limited testing suggests that --syntactic-equality=2 is a little
-- faster than --syntactic-equality=0 and --syntactic-equality=1 for
-- this file.
-- The option --allow-unsolved-metas and the open goal at the end of
-- the file ensure that time is not ... |
open import Nat
open import Prelude
open import List
open import statics-core
-- erasure of cursor in the types and expressions is defined in the paper,
-- and in the core file, as a function on zexpressions. because of the
-- particular encoding of all the judgments as datatypes and the agda
-- semantics for pattern ... |
{-# OPTIONS --rewriting #-}
module Issue2792 where
open import Issue2792.Safe
|
------------------------------------------------------------------------
-- Equivalences with erased "proofs"
------------------------------------------------------------------------
-- This module contains some basic definitions with few dependencies.
-- See Equivalence.Erased for more definitions. The definitions be... |
-- 2012-03-08 Andreas
module NoTerminationCheck4 where
data Bool : Set where
true false : Bool
{-# NON_TERMINATING #-}
private
f : Bool -> Bool
f true = f true
f false = f false
-- error: must place pragma before f
|
------------------------------------------------------------------------------
-- First-order logic (without equality)
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorph... |
-- Andreas, 2014-06-12 This feature has been addressed by issue 907
{-# OPTIONS --copatterns #-}
module CopatternsToRHS where
import Common.Level
open import Common.Equality
open import Common.Prelude using (Bool; true; false)
record R (A : Set) : Set where
constructor mkR
field
fst : A → A
snd : Bool
... |
------------------------------------------------------------------------
-- A tactic aimed at making equational reasoning proofs more readable
-- in modules that are parametrised by an implementation of equality
------------------------------------------------------------------------
-- The tactic uses the first insta... |
-- Andreas, 2016-12-28, issue #2360 reported by m0davis
-- Ambigous projection in with-clause triggered internal error
postulate
A : Set
a : A
module M (X : Set) where
record R : Set where
field f : X
-- Opening two instantiations of M creates and ambiguous projection
open M A using (module R)
open M A
t... |
{-# OPTIONS --safe #-}
module Ferros.Prelude where
open import Relation.Binary.PropositionalEquality
open import Data.Nat
open import Data.Nat.Properties
open import Data.Bool hiding (_≤_)
ℕ-sub : (x y : ℕ) → (y ≤ x) → ℕ
ℕ-sub x .zero z≤n = x
ℕ-sub ._ ._ (s≤s p) = ℕ-sub _ _ p
invert-ℕ-sub : ∀ x y → (p : y ≤ x) → (ℕ... |
{-# OPTIONS --without-K --safe #-}
module TypeTheory.Nat.Instance where
-- agda-stdlib
open import Level renaming (zero to lzero; suc to lsuc)
open import Data.Nat using (ℕ; zero; suc)
open import Relation.Binary.PropositionalEquality using (refl)
-- agda-misc
import TypeTheory.Nat.Operations as NatOperations
ℕ-ind... |
{-# OPTIONS --warning=error #-}
module UselessPrivateImport2 where
private
open import Common.Issue481ParametrizedModule Set
|
module Numeral.Integer.Relation where
|
module OpenPublicPlusTypeError where
module X where
postulate D : Set
open X public
postulate x : D
typeIncorrect : Set
typeIncorrect = Set1
|
{-# OPTIONS --cubical --safe #-}
module Cubical.Structures.TypeEqvTo where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.HITs.PropositionalTruncation
open import Cubical.Data.Prod hiding (_×_) renaming (_×Σ_ to _×_)
open import Cubical.Foundations.SIP renaming (SNS... |
module trie-core where
open import bool
open import char
open import list
open import maybe
open import product
open import string
open import unit
open import eq
open import nat
cal : Set → Set
cal A = 𝕃 (char × A)
empty-cal : ∀{A : Set} → cal A
empty-cal = []
cal-lookup : ∀ {A : Set} → cal A → char → maybe A
cal... |
postulate
F : Set → Set → Set
syntax F X Y = X ! Y
test : Set → Set → Set
test X = _! X
|
open import Everything
module Test.Test4
{𝔵} {𝔛 : Ø 𝔵}
{𝔞} {𝔒₁ : 𝔛 → Ø 𝔞}
{𝔟} {𝔒₂ : 𝔛 → Ø 𝔟}
{ℓ : Ł}
⦃ _ : Transitivity.class (Arrow 𝔒₁ 𝔒₂) ⦄
-- ⦃ _ : [𝓢urjectivity] (Arrow 𝔒₁ 𝔒₂) (Extension $ ArrowṖroperty ℓ 𝔒₁ 𝔒₂) ⦄
where
test[∙] : ∀ {x y} → ArrowṖroperty ℓ 𝔒₁ 𝔒₂ x → Arrow 𝔒₁ ... |
module parser where
open import lib
open import cedille-types
{-# FOREIGN GHC import qualified CedilleParser #-}
data Either (A : Set)(B : Set) : Set where
Left : A → Either A B
Right : B → Either A B
{-# COMPILE GHC Either = data Either (Left | Right) #-}
postulate
parseStart : string → Either (Either string... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.types.Pi
open import lib.types.Pointed
open import lib.types.Sigma
open import lib.types.Span
open import lib.types.Paths
import lib.types.Generic1HIT as Generic1HIT
module lib.types.Pushout where
module _ {i j k} where
postulate -- H... |
-- New NO_POSITIVITY_CHECK pragma for data definitions and mutual
-- blocks
-- Skipping an old-style mutual block: Somewhere within a `mutual`
-- block before a data definition.
mutual
data Cheat : Set where
cheat : Oops → Cheat
{-# NO_POSITIVITY_CHECK #-}
data Oops : Set where
oops : (Cheat → Cheat) → ... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.RingSolver.CommRingEvalHom where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat using (ℕ)
open import Cubical.Data.FinData
open import Cubical.Data.Vec
open import Cubical.Data.Bool.Base
open import Cubical.Algebra.RingSo... |
module Structure.Operator.Algebra where
open import Lang.Instance
open import Logic.Predicate
import Lvl
open import Structure.Function.Domain
open import Structure.Operator.Field
open import Structure.Operator.Monoid
open import Structure.Operator.Properties
open import Structure.Operator.Ring
open import Struct... |
module STLC.Kovacs.Normalisation where
open import STLC.Kovacs.NormalForm public
--------------------------------------------------------------------------------
-- (Tyᴺ)
infix 3 _⊩_
_⊩_ : 𝒞 → 𝒯 → Set
Γ ⊩ ⎵ = Γ ⊢ⁿᶠ ⎵
Γ ⊩ A ⇒ B = ∀ {Γ′} → (η : Γ′ ⊇ Γ) (a : Γ′ ⊩ A)
→ Γ′ ⊩ B
-- (Conᴺ ;... |
open import Oscar.Prelude
open import Oscar.Data.Decidable
open import Oscar.Data.Proposequality
module Oscar.Class.IsDecidable where
record IsDecidable {𝔬} (𝔒 : Ø 𝔬) : Ø 𝔬 where
infix 4 _≟_
field
_≟_ : (x y : 𝔒) → Decidable (x ≡ y)
open IsDecidable ⦃ … ⦄ public
|
module Syntax where
{-
open import Data.Nat hiding (_>_)
open import Data.Fin
open import Data.Product
open import Data.Bool
open import Relation.Binary.PropositionalEquality
-}
open import StdLibStuff
erase-subst :
(X : Set) → (Y : X → Set) →
(F : {x : X} → Y x) →
(x₁ x₂ : X) →
(eq : x₁ ≡ x₂) →
(P : Y x₂ → Set... |
-- Andreas, 2018-06-03, issue #3102
-- Regression: slow reduce with lots of module parameters and an import.
-- {-# OPTIONS -v tc.cc:30 -v tc.cover.top:30 --profile=internal #-}
open import Agda.Builtin.Bool
module _ (A B C D E F G H I J K L M O P Q R S T U V W X Y Z
A₁ B₁ C₁ D₁ E₁ F₁ G₁ H₁ I₁ J₁ K₁ L₁ M₁ ... |
module AmbiguousTopLevelModuleName where
import Imports.Ambiguous
|
{- 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... |
-- Andreas, 2012-07-26, reported by Nisse
module Issue678 where
module Unit where
data Unit : Set where
unit : Unit
El : Unit → Set
El unit = Unit
data IsUnit : Unit → Set where
isUnit : IsUnit unit
test : (u : Unit)(x : El u)(p : IsUnit u) → Set
test .unit unit isUnit = Unit
-- this requires... |
{-# OPTIONS --safe --warning=error --without-K #-}
module Naturals where
data ℕ : Set where
zero : ℕ
succ : ℕ → ℕ
{-# BUILTIN NATURAL ℕ #-}
_+N_ : ℕ → ℕ → ℕ
zero +N b = b
succ a +N b = succ (a +N b)
|
module Cats.Category.Base where
open import Level
open import Relation.Binary using
(Rel ; IsEquivalence ; _Preserves_⟶_ ; _Preserves₂_⟶_⟶_ ; Setoid)
open import Relation.Binary.EqReasoning as EqReasoning
import Cats.Util.SetoidReasoning as SetoidR
record Category lo la l≈ : Set (suc (lo ⊔ la ⊔ l≈)) where
infix... |
{-# OPTIONS --rewriting --confluence-check #-}
open import Agda.Builtin.Equality
open import Agda.Builtin.Equality.Rewrite
postulate
A : Set
a b : A
f : (A → A) → A
g : A → A
rewf₁ : f (λ x → g x) ≡ a
rewf₂ : f (λ x → a) ≡ b
rewg : (x : A) → g x ≡ a
{-# REWRITE rewf₁ rewf₂ rewg #-}
|
-- 2011-04-12 AIM XIII fixed this issue by freezing metas after declaration (Andreas & Ulf)
module Issue399 where
open import Common.Prelude
data Maybe (A : Set) : Set where
nothing : Maybe A
just : A → Maybe A
-- now in Common.Prelude
-- _++_ : {A : Set} → List A → List A → List A
-- [] ++ ys = ys
-- ... |
{-# OPTIONS --show-implicit #-}
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
open import Agda.Builtin.Unit
postulate
A B C D : Set
F : (A → A) → (A → A → A) → A
a : A
data Tree : Set where
leaf : Tree
node : (f : (x : A) → Tree) → Tree
tree1 : Nat → Tree
tree1 zero = leaf
tree1 (suc n) =... |
module FlatDomInequality where
postulate
A : Set
g : A → A
g x = x
-- this is fine
h : (@♭ x : A) → A
h = g
-- this should fail, although the error message should be improved.
q : A → A
q = h
|
{-# OPTIONS --prop --rewriting #-}
module Examples.Sorting where
import Examples.Sorting.Sequential
import Examples.Sorting.Parallel
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Automatic solvers for equations over integers
------------------------------------------------------------------------
-- See README.Integer for examples of how to use this solver
{-# OPTIONS --without-K --safe... |
open import Relation.Binary
open import Level
module GGT.Setoid
{a ℓ}
(S : Setoid a ℓ)
(l : Level)
where
open import Level
open Setoid S
open import Data.Product
open import Relation.Unary
open import Relation.Binary.Construct.On renaming (isEquivalence to isEq)
open import Function
subSetoid : (Pred Carrier... |
open import SOAS.Metatheory.Syntax
-- Metatheory of a second-order syntax
module SOAS.Metatheory {T : Set} (Syn : Syntax {T}) where
open import SOAS.Families.Core {T}
open import SOAS.Abstract.ExpStrength
open Syntax Syn
open CompatStrengths ⅀:CS public renaming (CoalgStr to ⅀:Str ; ExpStr to ⅀:ExpStr)
open impo... |
{-# OPTIONS --universe-polymorphism #-}
open import Level
module Categories.Terminal {o ℓ e : Level} where
open import Categories.Category
open import Categories.Functor
open import Categories.Categories
import Categories.Object.Terminal as Terminal
open Terminal (Categories o ℓ e)
record Unit {x : _} : Set x wher... |
-- Andreas, 2013-11-23
-- Make sure sized types work with extended lambda
{-# OPTIONS --copatterns --sized-types #-}
-- {-# OPTIONS -v tc.def:100 -v tc.size:100 -v tc.meta.assign:20 #-}
module SizedTypesExtendedLambda where
open import Common.Size
data Maybe (A : Set) : Set where
nothing : Maybe A
just : A ... |
module Numeral.Natural.Oper.FlooredDivision where
import Lvl
open import Data
open import Data.Boolean.Stmt
open import Logic.Propositional.Theorems
open import Numeral.Natural
open import Numeral.Natural.Oper.Comparisons
open import Numeral.Natural.Oper.Comparisons.Proofs
open import Numeral.Natural.Relation.Order
op... |
module Typed.LTLC where
open import Prelude
open import Function
open import Level
open import Category.Monad
open import Relation.Unary.PredicateTransformer using (PT; Pt)
open import Relation.Ternary.Separation.Construct.Unit
open import Relation.Ternary.Separation.Allstar
open import Relation.Ternary.Separation.Mo... |
-- Andreas, 2022-06-10, issue #5922, reported by j-towns.
-- Lack of normalization of data projections against data constructors
-- breaks termination checker applied to extended lambda gone through
-- forcing translation and reflection.
-- The workaround was to turn off the forcing translation:
-- {-# OPTIONS --no-fo... |
module _ where
module M where
private
module _ (A : Set) where
Id : Set
Id = A
foo : Set → Set
foo A = Id A
open M
bar : Set → Set
bar A = Id A -- Id should not be in scope
|
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020 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.Prelude
open import LibraBFT.Lemmas
open import LibraBFT.B... |
{-# OPTIONS --cubical --no-import-sorts --guardedness --safe #-}
module Cubical.Codata.M.AsLimit.stream where
open import Cubical.Data.Unit
open import Cubical.Foundations.Prelude
open import Cubical.Codata.M.AsLimit.M
open import Cubical.Codata.M.AsLimit.helper
open import Cubical.Codata.M.AsLimit.Container
-----... |
module Sized.SimpleCell where
open import Data.Product
open import Data.String.Base
open import SizedIO.Object
open import SizedIO.IOObject
open import SizedIO.ConsoleObject
open import SizedIO.Base
open import SizedIO.Console hiding (main)
open import NativeIO
open import Size
data CellMethod A : Set where
g... |
module functions where
open import level
open import eq
{- Note that the Agda standard library has an interesting generalization
of the following basic composition operator, with more dependent typing. -}
_∘_ : ∀{ℓ ℓ' ℓ''}{A : Set ℓ}{B : Set ℓ'}{C : Set ℓ''} →
(B → C) → (A → B) → (A → C)
f ∘ g = λ x → f (g ... |
module Issue4835.ModB where
data B : Set where
b : B -> B
|
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Setoids.Setoids
open import Functions.Definition
open import Groups.Definition
open import Sets.EquivalenceRelations
open import Groups.Isomorphisms.Definition
open import Groups.Homomorphisms.Definition
open import Groups.Homom... |
{-# OPTIONS --sized-types #-}
module SNat.Log where
open import Size
open import SNat
open import SNat.Order
open import SNat.Order.Properties
open import SNat.Properties
open import SNat.Sum
lemma-≅-log : {ι ι' : Size}{m : SNat {ι}}{n : SNat {ι'}} → m ≅ n → log₂ m ≅ log₂ n
lemma-≅-log z≅z = z≅z
lemma-≅-log (s≅s z≅z)... |
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Span
open import lib.types.Pushout
open import lib.types.PushoutFlattening
open import lib.types.Unit
open import lib.types.Pointed
-- Cofiber is defined as a particular case of pushout
module lib.types.Cofiber where
module _ {i j} {A : Type i... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.QuotientRing where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Logic using (_∈_)
open import Cubical.HITs.SetQuotients.Base
open import Cub... |
module Issue168b where
data Nat : Set where
zero : Nat
suc : Nat → Nat
module Membership (A : Set) where
id : Nat → Nat
id zero = zero
id (suc xs) = suc (id xs)
|
{- 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 Optics.All
open impo... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Core where
open import Level
open import Function using (flip)
open import Relation.Binary hiding (_⇒_)
import Relation.Binary.PropositionalEquality as ≡
import Relation.Binary.Reasoning.Setoid as SetoidR
-- Basic definition of a |Category| with a Hom set... |
-- Andreas, 2018-04-10, issue #3662.
-- Regression in the termination checker introduced together
-- with collecting function calls also in the type signatures
-- (fix of #1556).
record T : Set₂ where
field
Carr : Set₁
op : Carr → Carr
test : T
T.Carr test = Set
T.op test c = Aux
where
postulate ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Propositional (intensional) equality
------------------------------------------------------------------------
module Relation.Binary.PropositionalEquality where
open import Function
open import Function.Equalit... |
{-# OPTIONS --without-K #-}
open import Type
open import Type.Identities
open import Level.NP
open import Explore.Core
open import Explore.Properties
open import Explore.Explorable
open import Data.One
open import Data.Fin
open import Function.NP
open import Data.Product
open import HoTT
open import Relation.Binary.Pro... |
module MissingDefinition where
open import Agda.Builtin.Equality
Q : Set
data U : Set
S : Set
S = U
T : S → Set
T _ = U
V : Set
W : V → Set
private
X : Set
module AB where
data A : Set
B : (a b : A) → a ≡ b
mutual
U₂ : Set
data T₂ : U₂ → Set
V₂ : (u₂ : U₂) → T₂ u₂ → Set
data W₂ (u₂ : U₂) (t₂ : T... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.