text stringlengths 4 690k |
|---|
{-# OPTIONS --sized-types #-}
open import Relation.Binary.Core
module BubbleSort.Correctness.Order {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_)
(trans≤ : Transitive _≤_) where
open import BubbleSort _≤_ tot≤
open import Data.Product
open import Data.List
ope... |
module nix-emacs-agda where
|
{-# OPTIONS --without-K #-}
open import lib.Base
open import lib.PathGroupoid
open import lib.PathFunctor
open import lib.Equivalences
module lib.Univalence where
{-
The map [coe-equiv] is the map which is supposed to be an equivalence according
to the univalence axiom. We do not define it directly by path induction... |
module Data.List.Relation.Binary.Subset.Propositional.Instances where
open import Data.List using (List; _∷_; [])
open import Data.List.Relation.Unary.Any using (here; there)
open import Data.List.Membership.Propositional using (_∈_; _∉_)
open import Data.List.Membership.Setoid.Properties using (∈-resp-≈)
open import ... |
module Pin where
-- N-dimensional version of Pi
-- open import Data.Fin
open import Data.Nat
open import Data.Empty
open import Data.Unit
open import Data.Sum
open import Data.Product
open import Function renaming (_∘_ to _○_)
open import Relation.Binary.PropositionalEquality using (module ≡-Reasoning)
open ≡-Reas... |
{-# OPTIONS --allow-unsolved-metas #-}
module Issue442 where
postulate
A : Set
f : (P : A → A → Set) → (∀ {x} → P x x) →
(∀ {x y z} → P y z → P x y → A) → A
P : A → A → Set
reflP : ∀ {x} → P x x
g : ∀ {x y z} → P y z → P x y → A
a : A
a = f _ reflP g
|
------------------------------------------------------------------------------
-- First-order logic theorems
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-... |
open import Mockingbird.Forest using (Forest)
-- Birds Galore
module Mockingbird.Problems.Chapter11 {b ℓ} (forest : Forest {b} {ℓ}) where
open import Data.Product using (_×_; _,_; proj₁; proj₂; ∃-syntax)
open import Data.Unit using (⊤; tt)
open import Function using (_$_)
import Mockingbird.Problems.Chapter09 forest... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.ZCohomology.Properties where
{-
This module contains:
1. direct proofs of connectedness of Kn and ΩKn
2. Induction principles for cohomology groups of pointed types
3. Equivalence between cohomology of A and reduced cohomology of (A + 1)
4. Equival... |
module PatternSynonymImports where
open import PatternSynonyms renaming (z to zzz)
pattern myzero = zzz
two = ss zzz
list : List ℕ
list = 1 ∷ [] |
{-# OPTIONS --cubical #-}
module Issue2799 where
open import Agda.Primitive.Cubical
postulate
PathP : ∀ {ℓ} (A : I → Set ℓ) → A i0 → A i1 → Set ℓ
{-# BUILTIN PATHP PathP #-}
_≡_ : ∀ {ℓ} {A : Set ℓ} → A → A → Set ℓ
_≡_ {A = A} = PathP (λ _ → A)
record Stream (A : Set) : Set where
coinductive
const... |
postulate A : Set
record Overlap : Set where
constructor mk
field overlap {{a}} : A
record NoOverlap : Set where
constructor mk
field {{a}} : A
ok : A → NoOverlap
ok a = mk {{a}}
bad : A → Overlap
bad a = mk {{a}}
-- Function does not accept argument {{a}}
-- when checking that {{a}} is a valid argument to... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Morphism.IsoEquiv {o ℓ e} (𝒞 : Category o ℓ e) where
open import Level
open import Function using (flip; _on_)
open import Relation.Binary hiding (_⇒_)
import Relation.Binary.Construct.On as On
open import Categories.Morphism 𝒞
... |
open import OutsideIn.Prelude
open import OutsideIn.X
module OutsideIn.Expressions(x : X) where
import OutsideIn.TypeSchema as TS
open TS(x)
open X(x)
{- SYNTAX -}
data Name (n : Set) : NameType → Set where
N : n → Name n Regular
DC : ∀ {x} → dc x → Name n (Datacon x)
mutual
data Alternativ... |
{-# OPTIONS --cubical #-}
module Type.Cubical.Path.Equality where
open import Functional
open import Function.Axioms
import Lvl
open import Type
open import Type.Cubical
open import Type.Cubical.Path
open import Type.Cubical.Path.Proofs as Path
open import Structure.Function
open import Structure.Operator
open i... |
module PureLambda where
data D : Set where
lam : (D -> D) -> D
_·_ : D -> D -> D
lam f · x = f x
δ : D
δ = lam (\x -> x · x)
loop : D
loop = δ · δ
|
-- 2010-09-07 Andreas
module IrrelevantRecordMatching where
record Prod (A B : Set) : Set where
constructor _,_
field
fst : A
snd : B
wrongElim : {A : Set} -> .(Prod A A) -> A
wrongElim (a , a') = a
-- needs to fail because a is irrelevant |
module _ where
open import Common.Prelude hiding (_>>=_)
open import Common.Reflection
pattern `Nat = def (quote Nat) []
unquoteDecl f =
declareDef (vArg f) `Nat >>= λ _ →
freshName "aux" >>= λ aux →
declareDef (vArg aux) `Nat >>= λ _ →
defineFun f (clause [] (def aux []) ∷ [])
|
module Structure.LinearAlgebra where
import Lvl
open import Data
open import Data.Tuple
open import Functional hiding (id)
open import Function.Equals
open import Function.Proofs
open import Logic
open import Logic.Propositional
open import Logic.Propositional.Theorems
open import Logic.Predicate
open import Nume... |
{-# OPTIONS --universe-polymorphism #-}
open import Categories.Category
module Categories.Pullback {o ℓ e} (C : Category o ℓ e) where
open Category C
open import Level
record Pullback {X Y Z}(f : X ⇒ Z)(g : Y ⇒ Z) : Set (o ⊔ ℓ ⊔ e) where
field
P : Obj
p₁ : P ⇒ X
p₂ : P ⇒ Y
field
.commutes : f ... |
module Issue2641.Import where
open import Agda.Builtin.Nat
five : Nat
five = 5
|
{-# OPTIONS --safe --warning=error #-}
open import Sets.EquivalenceRelations
open import Functions.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_; Setω)
open import Setoids.Setoids
open import Groups.Definition
open import LogicalFormulae
open import Orders.WellFounded.Definition
open import Numb... |
{-# OPTIONS --safe -WnoSafeFlagNoCoverageCheck #-}
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
data ⊥ : Set where
{-# NON_COVERING #-}
f : ∀ b → b ≡ true → ⊥
f false ()
bad : ⊥
bad = f true refl
|
{-# OPTIONS --without-K --safe #-}
module Categories.Yoneda where
-- Yoneda Lemma. In total, provides:
-- * the Yoneda Embedding (called embed here) from any Category C into Presheaves C
-- Worth noticing that there is no 'locally small' condition here; however, if one looks at
-- the levels involved, there is in... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.ZCohomology.MayerVietorisUnreduced where
open import Cubical.ZCohomology.Base
open import Cubical.ZCohomology.Properties
open import Cubical.ZCohomology.KcompPrelims
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Function
open ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- The basic code for equational reasoning with three relations:
-- equality, strict ordering and non-strict ordering.
------------------------------------------------------------------------
--
-- See `Data.Nat.Pro... |
open import Everything
module Test.Test0 where
test-functor-surjidentity : ∀
{𝔬₁ 𝔯₁ ℓ₁ 𝔬₂ 𝔯₂ ℓ₂}
⦃ functor : Functor 𝔬₁ 𝔯₁ ℓ₁ 𝔬₂ 𝔯₂ ℓ₂ ⦄
(open Functor functor)
→ Surjidentity.type _∼₁_ _∼₂_ _∼̇₂_ functor-smap ε₁ ε₂
test-functor-surjidentity = surjidentity
-- test-functor-transextension... |
module tree where
open import bool
open import eq
open import level
open import list
open import list-to-string
open import nat
open import nat-thms
open import string
----------------------------------------------------------------------
-- datatype
-----------------------------------------------------------------... |
{-# OPTIONS --safe #-}
module Cubical.Categories.Monad.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Categories.Category
open import Cubical.Categories.Functor renaming (𝟙⟨_⟩ to funcId)
open import Cubical.Categories.NaturalTransformation.Base
open import Cubical.Categories.NaturalTransformat... |
-- Non-deterministic insert and permutation with choose oracle
-- The oracle is passed through the individual functions.
open import bool
module even-double-eo
(Choice : Set)
(choose : Choice → 𝔹)
(lchoice : Choice → Choice)
(rchoice : Choice → Choice)
where
open import eq
open import bool-thms
open import... |
module _ where
module G where
module H where
module A where
module B where
module C where
open G public
module I = A.B.C.H
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
-- This file contains a helper module for FinSet,
-- proving the finite pigeonhole principle
module homotopy.Pigeonhole where
{-
loosely based on code by copumpkin and xplat via byorgey
-}
incl : ∀ {m n} (m<n : m < n) → Fin m → Fin n
incl m<n (k , k<m) = k ... |
open import Data.Unit using ( ⊤ )
open import FRP.LTL.RSet.Core using ( RSet )
module FRP.LTL.RSet.Unit where
T : RSet
T t = ⊤
|
-- Andreas, 2017-07-13, issue #2642
record R : Set₁ where
field
F : Set
F : Set -- duplicate field, should be rejected
-- Otherwise, this gives an internal error:
test : Set → R
test A = record{ F = A }
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Vectors defined in terms of the reflexive-transitive closure, Star
------------------------------------------------------------------------
{-# OPTIONS --with-K --safe #-}
module Data.Star.Vec where
open impor... |
-- Andreas, 2017-04-11, Issue 2543
-- Printing of second non-trivial with-pattern
-- {-# OPTIONS -v interaction.case:100 #-}
data D : Set where
c : D → D
f : D → D
f y with c y
... | c z with c y
... | q = {!q!} -- C-c C-c q
-- Was:
-- f y | c z | (c q) = ?
-- Expected:
-- f y | c z | c q = ?
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Showing natural numbers
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Nat.Show where
open import Data.Char as Char using (Char)
open im... |
module Issue892b where
record R : Set₁ where
field A : Set
B : A → Set
-- The type of R.B should print as (r : R) → R.A r → Set
-- rather than ( : R) → R.A → Set.
bad : R.B
bad = ?
|
------------------------------------------------------------------------
-- Programs used to define and specify breadth-first manipulations of
-- trees
------------------------------------------------------------------------
module BreadthFirst.Programs where
open import Codata.Musical.Notation
open import Codata.Mus... |
{-# OPTIONS --allow-unsolved-metas #-}
module Real-Backup where
open import Data.Float hiding (_-_; _≈_)
open import Level using (0ℓ)
open import Algebra.Bundles using (CommutativeRing)
open import Algebra.Module.Bundles using (Module)
open import Relation.Binary.Structures using (IsStrictTotalOrder)
open import Rela... |
-- Andreas, 2012-05-04
-- Occurs check when unifying indices in patterns
{-# OPTIONS --allow-unsolved-metas #-}
-- The option is supplied to force a real error to pass the regression test.
module OccursCheck1 where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
data _==_ {A : Set}(x : A) : A -> Set where
ref... |
{-# OPTIONS --safe --warning=error --without-K --guardedness #-}
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Setoids.Setoids
open import Rings.Definition
open import Rings.Lemmas
open import Rings.Orders.Partial.Definition
open import Rings.Orders.Total.Definition
open import Groups.Definiti... |
module Day4 where
open import Prelude.String as String
open import Data.Maybe
open import Foreign.Haskell using (Unit)
open import Prelude.List as List
open import Data.Nat
open import Data.Nat.DivMod
open import Data.Nat.Properties
import Data.Nat.Show as ℕs
open import Prelude.Char
open import Data.Vec as Vec rena... |
module Basics where
id : {A : Set} -> A -> A
id a = a
_o_ : {A : Set}{B : A -> Set}{C : (a : A)(b : B a) -> Set} ->
({a : A}(b : B a) -> C a b) -> (g : (a : A) -> B a) ->
(a : A) -> C a (g a)
_o_ f g a = f (g a)
|
{-# OPTIONS --without-K --safe #-}
module Definition.Conversion.Whnf where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Conversion
open import Tools.Product
mutual
-- Extraction of neutrality from algorithmic equality of neutrals.
ne~↑ : ∀ {t u A Γ}
→ Γ ⊢ t ~ u ↑ A
... |
postulate
A : Set
B : A → Set
@0 T : _
T = (@0 x : A) → B x
|
------------------------------------------------------------------------
-- Types used to make recursive arguments coinductive
------------------------------------------------------------------------
-- See Data.Colist for examples of how this type is used, or
-- http://article.gmane.org/gmane.comp.lang.agda/633 for a... |
open import Prelude
open import Data.List.Properties
open import Data.List.Any hiding (map)
open import Extensions.Vec
open import Data.Vec
open import Data.List.All as All hiding (map; lookup)
module Implicits.Resolution.Infinite.Semantics where
open import Implicits.Syntax
open import Implicits.Resolution.Infinite.... |
module Issue846.DivModUtils where
open import Data.Nat
open import Data.Bool
open import Issue846.OldDivMod
open import Relation.Nullary
open import Data.Nat.Properties hiding (≤-antisym)
open import Data.Nat.Solver
open import Data.Fin using (Fin; toℕ; zero; suc; fromℕ≤)
open import Data.Fin.Properties using ( bound... |
module Oscar.Property.IsReflexive where
open import Oscar.Level
record IsReflexive {𝔬} (⋆ : Set 𝔬) {ℓ} (_≣_ : ⋆ → ⋆ → Set ℓ) : Set (𝔬 ⊔ ℓ) where
field
reflexivity : ∀ x → x ≣ x
|
module Impure.LFRef.Welltyped where
open import Prelude
open import Data.List hiding ([_])
open import Data.List.All hiding (map)
open import Data.Vec as Vec hiding ([_]; map)
open import Data.Star hiding (_▻▻_; map)
open import Data.Sum hiding (map)
open import Extensions.List as L using ()
open import Impure.LFRef... |
------------------------------------------------------------------------
-- Lemmas related to application of substitutions
------------------------------------------------------------------------
open import Data.Universe.Indexed
module deBruijn.Substitution.Data.Application.Application221
{i u e} {Uni : IndexedUni... |
module OverloadedConInParamModule where
data A : Set where
module M (X : Set) where
data B : Set where
c : B
data C : Set where
c : C
open M A
f : B
f = c
|
-- Copyright: (c) 2016 Ertugrul Söylemez
-- License: BSD3
-- Maintainer: Ertugrul Söylemez <esz@posteo.de>
module Data.Mod where
open import Core
open import Data.Int.Core hiding (module Props)
import Data.Int.Core as ℤ
open import Data.Nat.Core using (ℕ)
import Data.Nat.Core as ℕ
private module ℤP = ℤ.Props
... |
module L.Base.Sigma where
-- Reexport definitions
open import L.Base.Sigma.Core public
|
open import Prelude renaming (_++_ to _++-List_)
open import Data.Maybe using (Maybe; just; nothing; maybe; From-just)
open import Data.Fin using (Fin; toℕ) renaming (inject+ to finject; raise to fraise; zero to fzero; suc to fsuc)
open import Data.List.All as A
open import Data.Vec using (Vec; _∷_; [])
open import Da... |
{-
ℚ is a Field
-}
{-# OPTIONS --safe #-}
module Cubical.Algebra.Field.Instances.QuoQ where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Data.Sigma
open import Cubical.Data.Empty as Empty
open import Cubical.Data.Nat using (ℕ ; zero ; suc)
open import Cubical.D... |
module Absurd where
open import Prelude
absurd : {A : Set} -> Empty -> A
absurd x = {!!}
|
module Ethambda.Common where
open import Eth.Prelude
infixr 3 _<<_
infixr 3 _<d>_
export
_<d>_ : String -> String -> String
v <d> w =
if isNullStr v
then v
else v ++ " " ++ " " ++ w
export
ShowS : Type
ShowS = String -> String
export
_<d_ : String -> ShowS -> ShowS
s <d c = (s <.>) . c
|
{-
The James Construction,
also known as James Reduced Product
A very fundamental and useful construction in classical homotopy theory.
It can be seen as the free A∞-monoid constructed out of a given type,
namely the "correct higher version" of free monoid that is meaningful for all types,
instead of only h-Sets.
... |
{-# OPTIONS --type-in-type #-}
module Compilation.Data where
open import Context
open import Type.Core
open import Function
open import Data.Product
open import Data.List.Base
infixr 6 _⇒ᶜ_
{- Note [Type denotations]
The denotation of a System Fωμ type is an Agda type that somehow corresponds to the original type.... |
-- Issue reported by Christian Sattler on 2019-12-02
postulate
M : Set
m₀ : M
D : Set
d : D
Y : (m : M) (a : D) → Set
y : Y m₀ d
R' : M → Set
data X : M → Set where
conX : X m₀
R : M → Set
R = R'
postulate
felt :
(m : M)
(f : X m → D)
(g : (x : X m) → Y m (f x))
→ R m -- No e... |
-- Functions used in googology
{-# OPTIONS --without-K --safe --exact-split #-}
module Math.Googology.Function where
-- agda-stdlib
open import Data.Nat
open import Data.Nat.GeneralisedArithmetic
open import Function
-- Ackermann function.
-- ack m n = Ack(m, n)
ack : ℕ → ℕ → ℕ
ack 0 n = 1 + n
ack (suc ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Pointwise equality for containers
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Container.Relation.Binary.Pointwise where
open import D... |
{-# OPTIONS --cubical #-}
F : Set → Set
F A = A
record R : Set₁ where
field
A : Set
r : Set → R
r A = λ where
.R.A → A
|
module CF.Examples.Ex1 where
open import Function
open import Data.Bool
open import Data.Product
open import Data.List
open import Data.List.Relation.Unary.All
open import Data.Nat
open import Data.String
open import Relation.Binary.PropositionalEquality using (refl)
open import Relation.Ternary.Core
open import Rela... |
{-# OPTIONS --prop --allow-unsolved-metas #-}
data _≡_ {α}{A : Set α}(a : A) : A → Prop where
refl : a ≡ a
data _≃_ {α}{A : Set α}(a : A) : ∀ {B} → B → Prop where
refl̃ : a ≃ a
data ⊥ : Set where
data Con : Set
data Con~ : Con → Con → Prop
data Ty : Con → Set
data Ty~ : ∀ {Γ₀ Γ₁} → Con~ Γ₀ Γ₁ → Ty Γ₀ → Ty Γ... |
module PushArgument where
open import ScopeState
open import Data.List.NonEmpty
open import Data.List
open import ParseTree
open import Data.Nat
open import AgdaHelperFunctions
open import Data.Unit
open import Data.String hiding (toVec)
open import Data.Bool
open import Data.Product
open import Data.Maybe
open import ... |
-- {-# OPTIONS -v tc.cover.splittree:10 -v tc.cc.splittree:10 #-}
module Issue106 where
data ℕ : Set where
zero : ℕ
suc : ℕ -> ℕ
{-# BUILTIN NATURAL ℕ #-}
{-# BUILTIN ZERO zero #-}
{-# BUILTIN SUC suc #-}
_+_ : ℕ -> ℕ -> ℕ
zero + m = m
suc n + m = suc (n + m)
record ⊤ : Set where
data C : ℕ -> Set where
c ... |
module Data where
data D
(A : Set)
: Set
data D A
where
c
: D A
data E
(B : Set)
: Set
where
|
{-# OPTIONS --without-K --show-implicit #-}
module WithoutK10 where
data Unit : Set where
unit : Unit
data D {A : Set} (f : Unit → A) : A → Set where
d : ∀ {x} → D f x
Foo : ∀ {A} {x : A} → D (let f = λ { unit → x } in f) x → Set₁
Foo d = Set
|
{-
Index a structure S by the type variable: X ↦ X → S X
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Structures.Relational.UnaryOp where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.F... |
module Bound.Total.Order {A : Set}(_≤_ : A → A → Set) where
open import Bound.Total A
data LeB : Bound → Bound → Set where
lebx : {b : Bound}
→ LeB bot b
lexy : {x y : A}
→ x ≤ y
→ LeB (val x) (val y)
lext : {b : Bound}
→ LeB b top... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Groups.Homomorphisms.Definition
open import Groups.Definition
open import Rings.Definition
open import Rings.Homomorphisms.Definition
open import Rings.IntegralDomains.Definition
open import Setoids.Setoids
open import Sets.Equi... |
{-
This file contains:
- Properties of 2-groupoid truncations
-}
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.2GroupoidTruncation.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.HITs.2GroupoidTruncation.Base
rec2GroupoidTrunc : ∀ {ℓ ℓ'} {A : Type ℓ} {B : Type ℓ'} (gB : is2Group... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
module Decidable.Sets {a : _} (A : Set a) where
DecidableSet : Set a
DecidableSet = (a b : A) → ((a ≡ b) || ((a ≡ b) → False))
|
{-# OPTIONS --without-K #-}
open import Axiom.Extensionality.Propositional
module FLA.Axiom.Extensionality.Propositional where
-- Since (dependent) extensionality is not allowed in standard Agda, we
-- postulate it here. In the standard library, the Extensionality term is
-- given in the type, which is then often na... |
------------------------------------------------------------------------
-- Some derivable properties
------------------------------------------------------------------------
open import Algebra
module Algebra.Props.DistributiveLattice
(dl : DistributiveLattice)
where
open DistributiveLattice dl
im... |
even : ℕ → Bool
odd : ℕ → Bool
even zero = true
even (suc n) = odd n
odd zero = false
odd (suc n) = even n
|
{-
Please do not move this file. Changes should only be made if necessary.
This file contains pointers to the code examples and main results from the paper:
Internalizing Representation Independence with Univalence
Carlo Angiuli, Evan Cavallo, Anders Mörtberg, Max Zeuner
Preprint: https://arxiv.org/abs/2009.05547
... |
open import Nat
open import Prelude
open import Hazelnut-core
module Hazelnut-sensible where
-- theorem 1: action sensibility
synthmovelem : {Γ : ·ctx} {e e' : ê} {t : τ̇} {δ : direction} →
(e + move δ +>e e') →
(Γ ⊢ e ◆e => t) →
(Γ ⊢ e' ◆e => t)
synthmovelem E... |
--{-# OPTIONS --allow-unsolved-metas #-}
module StateSizedIO.GUI.Prelude where
open import Size public renaming (Size to AgdaSize)
open import Data.Nat.Base public
open import Data.Bool.Base hiding (_≟_) public
open import Data.List.Base public
open import Function public
open import Data.Integer.Base public hiding... |
-- Andreas, 2019-08-20, issue #4012
-- unquoteDef and unquoteDecl should respect `private`
open import Agda.Builtin.Reflection renaming (bindTC to _>>=_)
open import Agda.Builtin.List
data D : Set where
c : D
module M where
private
unquoteDecl g = do
ty ← quoteTC D
_ ← declareDef (arg (arg-inf... |
{-# OPTIONS --without-K #-}
{-
Imports everything that is not imported by something else.
This is not supposed to be used anywhere, this is just a simple way to
do `make all'
This file is intentionally named index.agda so that
Agda will generate index.html.
-}
module index where
-- import Spaces.IntervalProps
-- im... |
open import Data.List using (List; _∷_; [])
open import Data.Product using (_×_; _,_; Σ)
open import Data.Unit using (⊤; tt)
open import Relation.Binary.PropositionalEquality using (_≡_)
module SystemT where
data _∈_ {A : Set} : (x : A) (l : List A) → Set where -- type \in
i0 : {x : A} {xs : List A} → x ∈... |
{-# OPTIONS --universe-polymorphism #-}
-- {-# OPTIONS --verbose tc.records.ifs:15 #-}
-- {-# OPTIONS --verbose tc.constr.findInScope:15 #-}
-- {-# OPTIONS --verbose tc.term.args.ifs:15 #-}
module 05-equality-std1 where
open import Relation.Binary using (IsDecEquivalence; module IsDecEquivalence; Reflexive; module De... |
module Thesis.SIRelBigStep.DenSem where
open import Data.Nat
open import Data.Product
open import Thesis.SIRelBigStep.Syntax
open import Data.Nat
⟦_⟧Type : Type → Set
⟦ σ ⇒ τ ⟧Type = ⟦ σ ⟧Type → ⟦ τ ⟧Type
⟦ nat ⟧Type = ℕ
⟦ pair τ1 τ2 ⟧Type = ⟦ τ1 ⟧Type × ⟦ τ2 ⟧Type
import Base.Denotation.Environment
module Den = Ba... |
-- Subtyping is no longer supported for irrelevance.
f : {A B : Set} → (.A → B) → A → B
f g = λ .x → g x
|
open import Agda.Builtin.Equality
open import Agda.Builtin.Sigma
postulate X : Set
variable x : X
data C : Σ X (λ x → x ≡ x) → Set where
mkC :
let
eq : x ≡ x -- don't generalize over x at eq
eq = refl {x = x}
in
C (x , eq)
|
module Sets.IterativeUSet where
open import Data renaming (Empty to EmptyType)
open import Functional
import Lvl
import Lvl.Decidable as Lvl
open import Structure.Setoid renaming (_≡_ to _≡ₛ_)
open import Syntax.Function
open import Type
open import Type.Dependent
private variable ℓ ℓₒ ℓₑ ℓ₁ ℓ₂ : Lvl.Level
... |
module treeThms where
open import lib
-- simple Tree type storing natural numbers
data Tree : Set where
Node : ℕ → Tree → Tree → Tree
Leaf : Tree
mirror : Tree → Tree
mirror (Node x t1 t2) = Node x (mirror t2) (mirror t1)
mirror Leaf = Leaf
mirror-mirror : ∀ (t : Tree) → mirror (mirror t) ≡ t
mirr... |
open import Agda.Builtin.Unit
open import Agda.Builtin.Bool
open import Agda.Builtin.Sigma
open import Agda.Builtin.List
open import Agda.Builtin.Equality
open import Agda.Builtin.Reflection renaming (returnTC to return; bindTC to _>>=_)
_>>_ : ∀ {a} {b} {A : Set a} {B : Set b}
→ TC A → TC B → TC B
x >> y = x >>... |
{-# OPTIONS --without-K --rewriting --termination-depth=2 #-}
open import HoTT
open import cohomology.ChainComplex
open import cohomology.Theory
open import groups.KernelImage
open import cw.CW
module cw.cohomology.ReconstructedHigherCohomologyGroups {i : ULevel} (OT : OrdinaryTheory i) where
open OrdinaryTheory O... |
module Verifier
(down : Set₁ -> Set)
(up : Set → Set₁)
(iso : ∀ {A} → down (up A) -> A)
(osi : ∀ {A} → up (down A) -> A) where
import UniverseCollapse as UC
open UC down up iso osi using (anything)
check : (A : Set) -> A
check = anything
|
module Data.Bin.DivMod where
import Data.Fin
import Data.Product
import Data.Bin
import Data.Nat
import Relation.Binary.PropositionalEquality
import Data.Digit hiding (0b; 1b)
import Data.List
import Algebra
import Algebra.Structures
import Data.Bin.NatHelpers
open Data.Bin using (Bin; toℕ; toBits; fromB... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.ZariskiLattice.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
open im... |
------------------------------------------------------------------------------
-- Agda-Prop Library.
-- Theorems with different connectives.
------------------------------------------------------------------------------
open import Data.Nat using ( ℕ )
module Data.PropFormula.Theorems.Mixies ( n : ℕ ) where
--------... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of non-empty lists
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.NonEmpty.Properties where
open import Category.Monad
o... |
{-# OPTIONS --without-K --safe #-}
module Categories.Bicategory where
open import Level
open import Data.Product using (_,_)
open import Relation.Binary using (Rel)
open import Categories.Category using (Category; module Commutation)
open import Categories.Category.Monoidal.Instance.Cats using (module Product)
open ... |
{-
Pointed structure: X ↦ X
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Structures.Pointed where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.SIP
open import Cubical.Foundations.Point... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.