text stringlengths 4 690k |
|---|
{-# OPTIONS --without-K --safe #-}
module Cats.Category.Fun.Facts.Iso where
open import Cats.Category
open import Cats.Category.Cat using (_≈_)
open import Cats.Category.Fun using (Fun ; Trans ; ≈-intro ; ≈-elim)
open import Cats.Functor using (Functor)
open import Cats.Trans.Iso using (NatIso)
import Cats.Category.C... |
module PiFrac.NoRepeat where
open import Data.Empty
open import Data.Unit hiding (_≟_)
open import Data.Sum
open import Data.Product
open import Relation.Binary.Core
open import Relation.Binary
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
open import Function using (_∘_)
open import Pi... |
{-# OPTIONS --type-in-type #-}
module ArgsWrongOrder where
open import AgdaPrelude
myFun : (a : Set) -> a -> Nat -> Nat
myFun _ x y = y
myApp = myFun _ Zero (Nil Nat)
|
{-# OPTIONS --prop #-}
data _≡_ {X : Set} (a : X) : X → Prop where
refl : a ≡ a
postulate
A : Set
P : Prop
p : P
u : P → A
f : {x : A} (q : u p ≡ x) → P
f refl = p -- works in 2.6.0.1
|
{-# OPTIONS --without-K --rewriting #-}
{-
favonia:
On 2017/03/23, after I added back Mayer-Vietoris, it seems
difficult to type check everything in one round on travis,
so parts of index.agda are moved here.
favonia:
On 2017/05/08, I further partition the results into multiple
independent index[n].agda... |
{-# OPTIONS --cubical --no-exact-split --safe #-}
module Multidimensional.Data.Extra.Nat.Base where
open import Cubical.Data.Nat
sucn : (n : ℕ) → (ℕ → ℕ)
sucn n = iter n suc
|
------------------------------------------------------------------------------
-- Testing the translation of definitions
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymor... |
{-# OPTIONS --safe --warning=error --without-K --guardedness #-}
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Numbers.ClassicalReals.RealField
open import LogicalFormulae
open import Setoids.Subset
open import Setoids.Setoids
open import Setoids.Orders
open import Sets.EquivalenceRelations
o... |
------------------------------------------------------------------------
-- Code related to the paper "Up-to Techniques using Sized Types"
--
-- Nils Anders Danielsson
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
module README where
--------------------------... |
-- Length-indexed lists as a recursive family
-- From "Dependent Types at Work", section 3.1
module xx where
open import Level renaming (suc to lsuc)
open import Data.Nat hiding (_^_)
open import Data.Empty.Polymorphic
open import Data.Unit.Polymorphic
open import Data.Maybe hiding (map ; zip)
open import Data.Produc... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Structures for homogeneous binary relations
------------------------------------------------------------------------
-- The contents of this module should be accessed via `Relation.Binary`.
{-# OPTIONS --withou... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Maybes where all the elements satisfy a given property
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Maybe.Relation.Unary.All where
ope... |
-- Andreas, 2017-03-30, issue #2524
-- compile abstract definitions to arbitrary Haskell code
module Issue2524 where
open import Agda.Builtin.Nat
open import Agda.Builtin.Unit
open import Agda.Builtin.String
{-# FOREIGN GHC import qualified Data.Text #-}
postulate
NativeIO : Set → Set
nativeReturn : {A : Se... |
module Data.Lens.Proofs.LensLaws where
open import Haskell.Prelude renaming (zero to Z; suc to S)
open import Data.Lens.Lens
open import Data.Logic
open import Agda.Primitive
-- First, define the lens laws
ViewSet : {a b : Set} -> (l : Lens a b) -> Set
ViewSet {a} {b} l = (v : b) (s : a) -> view l (set l v s) ≡ v
... |
record R {a} (A : Set a) : Set a where
field
some : A
module Works0 where
works : ∀ {a}{A : Set a} {{r : R A}} -> A
works = x
where
open R {{...}}
x = some
-- If we add a dummy argument of type Set to "works" we fail, see module Fails
-- below.
-- But there is a chance it still works:
mo... |
module _ where
module A where
infix 2 _↑
infix 1 _↓_
data D : Set where
● : D
_↑ : D → D
_↓_ : D → D → D
module B where
data D : Set where
_↓_ : D → D → D
open A
open B
rejected : A.D
rejected = ● ↑ ↓ ●
|
-- Andreas, 2014-05-20, issue reported by Fabien Renaud
module Issue1125 where
f : {A- : Set} -> Set
f {A-} = A-
-- Should give a parse error now
-- since a comment is closed -} but none opened.
|
-- Andreas, 2021-01-28 documenting #4702, reported by gallais
open import Agda.Builtin.Nat
case_of_ : {A B : Set} → A → (A → B) → B
case x of f = f x
-- Needed for making `plus` pass the termination checker.
-- Used to be automatic via `--auto-inline`, since 2.6.2 this flag
-- is off by default.
{-# INLINE case_of_... |
module Numeral.Ordinal where
import Lvl
open import Numeral.Natural
open import Syntax.Function
open import Type
private variable ℓ : Lvl.Level
private variable T : Type{ℓ}
-- Ordinal numbers up to a certain level as a type.
-- 𝟎 is the zero ordinal, the smallest ordinal number.
-- 𝐒 is the successor ordinal ... |
record ∃ {A : Set} (B : A → Set) : Set where
field
fst : A
snd : B fst
data ⊥ : Set where
infix 3 ¬_
¬_ : Set → Set
¬ P = P → ⊥
infixr 1 _⊎_
data _⊎_ (A B : Set) : Set where
inj₁ : A → A ⊎ B
inj₂ : B → A ⊎ B
⊎-map : ∀ {A₁ A₂ B₁ B₂ : Set} →
(A₁ → A₂) → (B₁ → B₂) → A₁ ⊎ B₁ → A₂ ⊎ B₂
⊎-map f g... |
{-# OPTIONS --cubical --no-import-sorts #-}
module Summary where
import Cubical.Data.Nat using (ℕ)
open import Cubical.Foundations.Prelude using (Lift; refl)
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Unit.Base using (Unit)
open import Cubical.Data.Sigma.Base
infix 1 _≅_
_≅_ = Iso
open imp... |
open import Agda.Builtin.Equality
postulate
A : Set
F G H I J : (A : Set₁) → (A → A → Set) → Set
K : ⦃ Set → Set → Set ⦄ → { Set → Set → Set } → Set
syntax F A (λ x y → B) = y ⟨ A ∼ B ⟩₁ x
syntax G A (λ _ y → B) = y ⟨ A ∼ B ⟩₂
syntax H A (λ x _ → B) = ... |
module Generic.Lib.Data.Sets where
open import Generic.Lib.Intro
open import Generic.Lib.Data.Nat
open import Generic.Lib.Data.Product
open import Generic.Lib.Data.Pow
infixl 6 _⊔ⁿ_
_⊔ⁿ_ : ∀ {n} -> Level ^ n -> Level -> Level
_⊔ⁿ_ = flip $ foldPow _ _⊔_
Sets : ∀ {n} -> (αs : Level ^ n) -> Set (mapPow lsuc αs ⊔ⁿ lze... |
module Prelude.List.Relations.Properties where
open import Agda.Primitive
open import Prelude.Equality
open import Prelude.Nat
open import Prelude.Empty
open import Prelude.Unit
open import Prelude.Product
open import Prelude.Number
open import Prelude.Decidable
open import Prelude.List.Base
open import Prelude.List... |
{-# OPTIONS --without-K --safe #-}
module Algebra.Linear.Structures where
open import Algebra.Structures.Field public
open import Algebra.Linear.Structures.VectorSpace public
|
module _ (A : Set) where
{-# POLARITY A #-}
|
module Lvl.MultiFunctions where
open import Data
open import Data.Tuple
open import Data.Tuple.Raise
import Data.Tuple.Raiseᵣ.Functions as Raise
open import Lvl
-- The maximum level of a tuple list of levels.
⨆ : ∀{n} → (Level ^ n) → Level
⨆ = Raise.foldᵣ(_⊔_) 𝟎
|
open import FRP.JS.Nat using ( ℕ ; suc ; _+_ )
open import FRP.JS.DOM
open import FRP.JS.RSet
open import FRP.JS.Time using ( Time ; epoch )
open import FRP.JS.Delay using ( _ms )
open import FRP.JS.Behaviour
open import FRP.JS.Bool using ( Bool ; not ; true )
open import FRP.JS.QUnit using ( TestSuite ; ok◇ ; test ; _... |
-- Given two abelian groups A, B
-- the set of all group homomorphisms from A to B
-- is itself an abelian group.
-- In other words, Ab is cartesian closed.
-- This is needed to show Ab is an abelian category.
{-# OPTIONS --safe #-}
module Cubical.Algebra.AbGroup.Instances.Hom where
open import Cubical.Algebra.AbG... |
module _ where
open import Agda.Builtin.Nat
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
data Nat+Bool : Set where
nat : Nat → Nat+Bool
bool : Bool → Nat+Bool
data P : Nat+Bool → Set where
p : {x : Nat+Bool} → P x
mkBool : ∀ {n b} → P (nat n) → P (bool b)
mkBool {zero} _ = p {bool _}
mk... |
{-# OPTIONS --without-K --safe #-}
module Definition.Typed.EqRelInstance where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Weakening
open import Definition.Typed.Reduction
open import Definition.Typed.EqualityRelation
open import Tools.Function
-- Judgmental instance of... |
module NamedWhere where
data _==_ {A : Set}(x : A) : A -> Set where
refl : x == x
data List (A : Set) : Set where
[] : List A
_::_ : A -> List A -> List A
_++_ : {A : Set} -> List A -> List A -> List A
[] ++ ys = ys
(x :: xs) ++ ys = x :: (xs ++ ys)
reverse : {A : Set} -> List A -> List A
reverse {A... |
module Metalogic.Classical.Propositional.TruthSemanticsModel {ℓ} (Proposition : Set(ℓ)) where
import Lvl
open import Data.Boolean
open import Data
open import Data.Tuple as Tuple using (_⨯_ ; _,_)
open import Functional
open import Metalogic.Classical.Propositional.Syntax{ℓ} (Proposition)
renaming (
⊤ to ... |
module Structure.Operator.Monoid.Homomorphism where
import Lvl
open import Logic
open import Logic.Predicate
open import Structure.Function
open import Structure.Function.Multi
open import Structure.Operator.Monoid
open import Structure.Setoid
open import Type
record Homomorphism
{ℓ₁ ℓ₂ ℓₑ₁ ℓₑ₂}
{X : Type{ℓ₁... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Base
open import lib.PathGroupoid
open import lib.types.Empty
open import lib.types.Nat
module lib.types.TLevel where
⟨_⟩₋₁ : ℕ → ℕ₋₂
⟨ n ⟩₋₁ = S ⟨ n ⟩₋₂
⟨_⟩ : ℕ → ℕ₋₂
⟨ n ⟩ = S (S ⟨ n ⟩₋₂)
infixl 80 _+2+_
_+2+_ : ℕ₋₂ → ℕ₋₂ → ℕ₋₂
⟨-2⟩ +2+ n = n
S m +2+ n = S ... |
------------------------------------------------------------------------
-- Propierties of abstract typing contexts
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module Data.Context.Properties where
open import Data.Fin using (Fin; zero; suc; lift; raise)... |
module Haskell.Prim.Monad where
open import Haskell.Prim
open import Haskell.Prim.Applicative
open import Haskell.Prim.Either
open import Haskell.Prim.Foldable
open import Haskell.Prim.Functor
open import Haskell.Prim.List
open import Haskell.Prim.Maybe
open import Haskell.Prim.Monoid
open import Haskell.Prim.String
... |
{- 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
-}
-- This module provides functionality for proving properties about
-- p... |
open import Agda.Builtin.Reflection
open import Agda.Builtin.Bool
open import Agda.Builtin.String
open import Agda.Builtin.Equality
open import Agda.Builtin.Unit
open import Agda.Builtin.List
_>>=_ = bindTC
`false `true : Term
`false = con (quote false) []
`true = con (quote true) []
macro
macro? : Name → Term ... |
{-# OPTIONS --without-K --exact-split --safe #-}
open import Fragment.Algebra.Signature
module Fragment.Equational.Model.Satisfaction {Σ : Signature} where
open import Fragment.Equational.Theory.Base hiding (Σ)
open import Fragment.Algebra.Algebra Σ
open import Fragment.Algebra.Free Σ
open import Fragment.Algebra.Ho... |
module Lemmachine.Response where
open import Lemmachine.Response.Status public
open import Data.Product
open import Data.List hiding (_++_)
open import Data.Nat
open import Data.String
data ResponseHeader : Set where
_,_ : String → String → ResponseHeader
{-# COMPILED_DATA ResponseHeader
Lemmachine.FFI.Response... |
-- Andreas, 2019-10-21, issue #4148, reported by omelkonian
{-# OPTIONS -v impossible:100 #-}
postulate
A : Set
module M (I : Set) where
postulate
P : I → Set
record R (i : I) : Set where
constructor mk
field
f : P i
open module N = M A
data D : ∀ {i} → R i → Set where
c : ∀ {i} {t : P ... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.types.Group
open import lib.groups.Homomorphism
open import lib.groups.TensorProduct
module lib.types.CRing where
-- 1-approximation of commutative rings without higher coherence conditions.
record CRingStructure {i} (El : Type i)
: Typ... |
------------------------------------------------------------------------------
-- Proving properties without using pattern matching on refl
------------------------------------------------------------------------------
{-# OPTIONS --no-pattern-matching #-}
{-# OPTIONS --exact-split #-}
{-# OPTIONS --... |
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
data Three : Set -- (AAA) To fix things, move this line...
data One : Set where
one : Nat → One
data Two : Set where
two : One → Two
lemma′ : ∀ (m n : Nat) → (one m) ≡ (one n) → m ≡ n
lemma′ m .m refl = refl
lemma : ∀ (m n : Nat) → (two (one m)) ≡... |
open import Categories.Category
open import Categories.Category.CartesianClosed
{-
The internal language of a given cartesian closed category.
-}
module Internal {o ℓ e} (𝒞 : Category o ℓ e)
(cartesianClosed : CartesianClosed 𝒞) where
open import Relation.Binary using (Rel)
open import Data.Product using (Σ-syn... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Examples showing how the notion of Interleaving can be used
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module README.Data.Interleaving where
ope... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.ZCohomology.RingStructure.RingLaws where
open import Cubical.ZCohomology.Base
open import Cubical.ZCohomology.GroupStructure
open import Cubical.ZCohomology.Properties
open import Cubical.ZCohomology.RingStructure.CupProduct
open import Cubical.Hom... |
data Nat : Set where
zero : Nat
suc : Nat → Nat
interleaved mutual
data Even : Nat → Set
data Odd : Nat → Set
-- base cases: 0 is Even, 1 is Odd
constructor
even-zero : Even zero
odd-one : Odd (suc zero)
-- step case: suc switches the even/odd-ness
constructor
even-suc : ∀ {n} → Odd n... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.Bouquet
open import homotopy.PushoutSplit
open import homotopy.DisjointlyPointedSet
open import cw.CW
module cw.WedgeOfCells {i} {n} (skel : Skeleton {i} (S n)) where
Xₙ/Xₙ₋₁ : Type i
Xₙ/Xₙ₋₁ = Cofiber (cw-incl-last skel)
⊙Xₙ/Xₙ₋₁ : Ptd i... |
{-# OPTIONS --without-K #-}
module hott.level.closure where
open import hott.level.closure.core public
open import hott.level.closure.lift public
open import hott.level.closure.extra public
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Refinement type: a value together with an erased proof.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Refinement where
open import Leve... |
{- 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 LibraBFT.Prelude
open import LibraBFT.Impl.Consensus.Types
... |
{-# OPTIONS --cubical --cumulativity #-}
module leibniz-equality where
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Function
open import Cubical.Data.Equality
open import equalities
open import leibniz
open Leibniz
liftIso : ∀ {a b} {A : Type a} {B : Type b} → Iso {a} {b} A B → Iso {ℓ... |
{-# OPTIONS --no-positivity-check #-}
module IIDr where
open import LF
open import IID
OPr : (I : Set) -> Set1
OPr I = I -> OP I One
rArgs : {I : Set}(γ : OPr I)(U : I -> Set)(i : I) -> Set
rArgs γ U i = Args (γ i) U
-- The type of IIDrs
data Ur {I : Set}(γ : OPr I)(i : I) : Set where
intror : rArgs γ (Ur γ) i ->... |
-- Andreas, 2019-01-20, re #2597.
-- Undocumented language change introduced by patch 31a5982f38 (released in 2.5.3):
-- Hiding of argument now treated as part of name when inserting implicits.
-- Patch introduced in src/full/Agda/TypeChecking/Implicit.hs
--
-- ... | x == y && sameHiding hidingx a = impInsert $ revers... |
{-# OPTIONS --without-K #-}
module NTypes.Coproduct where
open import NTypes
open import PathOperations
open import PathStructure.Coproduct
open import Types
⊎-isSet : ∀ {A : Set} {B : Set} →
isSet A → isSet B → isSet (A ⊎ B)
⊎-isSet {A = A} {B = B} A-set B-set x y p q =
case (λ x → (y : A ⊎ B) (p q : x ≡ y) → p ... |
------------------------------------------------------------------------
-- Some results that could not be placed in Function-universe because
-- they make use of --sized-types
------------------------------------------------------------------------
{-# OPTIONS --without-K --sized-types #-}
open import Equality
modu... |
{- 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.Impl.OBM.Crypto hiding (verify)
open import... |
module Mystuff where
-- open import Axiom.Extensionality.Propositional as AEP
open import Categories.Category.Cartesian.Bundle
open import Categories.Category.CartesianClosed.Canonical
open import Categories.Category.Core
open import Categories.Category.Slice
-- open import Categories.Functor
open import Categories.C... |
{-
Definition of the integers as a HIT inspired by slide 10 of (original
idea due to Paolo Capriotti):
http://www.cs.nott.ac.uk/~psztxa/talks/bonn18.pdf
Disclaimer: this definition is very hard to work with and I have not
been able to prove that it is equivalent to nat + nat or that it is a
set.
For a variation tha... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.types.Sigma
open import lib.types.Bool
open import lib.types.Nat
open import lib.types.Fin
module lib.types.Vec where
infixr 5 _∷_
data Vec {i} (A : Type i) : ℕ → Type i where
[] : Vec A 0
_∷_ : ∀ {n} (x : A) (xs : Vec A n) → Vec A ... |
module Data.Iterator where
import Lvl
open import Data hiding (empty)
open import Data.Boolean
open import Functional
open import Numeral.Natural
open import Type
private variable ℓ : Lvl.Level
private variable T A B : Type{ℓ}
private variable a x init : T
private variable f : A → B
private variable n : ℕ
-- TO... |
-- Andreas, 2016-05-04, issue 1960 reported by Nisse
-- {-# OPTIONS -v tc.proj.amb:100 #-}
postulate
A : Set
module M (_ : Set₁) where
record R₁ : Set where
field
f : A
open R₁ public
open M Set
record R₂ : Set where
field
f : A
open R₂ public
postulate
P : A → Set
x : R₁
wo... |
------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Delta-observational equivalence
------------------------------------------------------------------------
module Base.Change.Equivalence where
open import Relation.Binary.PropositionalEquality
open import Base.Chang... |
------------------------------------------------------------------------
-- A class of algebraic structures, based on non-recursive simple
-- types, satisfies the property that isomorphic instances of a
-- structure are equal (assuming univalence)
------------------------------------------------------------------------... |
module Structure.Topology where
open import Logic
import Lvl
open import Sets.ExtensionalPredicateSet renaming (_≡_ to _≡ₛ_) hiding (map)
open import Structure.Setoid
open import Type
-- Definition of topological spaces via open sets.
-- The interpretation is that X is the collection of points and 𝓣 is the coll... |
module Issue14 where
open import Haskell.Prelude
-- Wrong name for shadowed lambda
constid : a → b → b
constid x = λ x → x
{-# COMPILE AGDA2HS constid #-}
sectionTest₁ : Nat → Nat → Nat
sectionTest₁ n = _+ n
sectionTest₂ : Nat → Nat → Nat
sectionTest₂ section = _+ section
{-# COMPILE AGDA2HS sectionTest₁ #-}
{-#... |
module Data.Vec.Any.Membership.Propositional where
open import Relation.Binary.PropositionalEquality
open import Data.Vec
open import Data.Vec.Any hiding (map)
open import Function.Inverse using (_↔_)
open import Function using (_∘_)
open import Data.Nat
open import Data.Product hiding (map)
impo... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.List.Relation.Binary.Lex.NonStrict directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Indexed monads
------------------------------------------------------------------------
-- Note that currently the monad laws are not included here.
{-# OPTIONS --without-K --safe #-}
module Category.Monad.Ind... |
module Logic.Operations where
import Logic.Relations as Rel
import Logic.Equivalence as Eq
open Eq using (Equivalence; module Equivalence)
BinOp : Set -> Set
BinOp A = A -> A -> A
module MonoEq {A : Set}(Eq : Equivalence A) where
module EqEq = Equivalence Eq
open EqEq
Commutative : BinOp A -> Set
Commutat... |
module _ (A : Set) (Sing : A → Set) (F : (a : A) → Sing a → Set) where
test : {a : A} → Sing a → Set
test s = F {!!} s
-- WAS: C-c C-s inserts a, which produces a scope error
-- Instead, it should insert _
|
{-# OPTIONS --cubical --no-import-sorts #-}
open import Cubical.Foundations.Everything renaming (_⁻¹ to _⁻¹ᵖ; assoc to ∙-assoc)
open import Function.Base using (_∋_)
open import MorePropAlgebra.Bundles
import Cubical.Algebra.AbGroup as Std
module MorePropAlgebra.Properties.AbGroup {ℓ} (assumptions : AbGroup {ℓ}) wh... |
{-# OPTIONS --allow-unsolved-metas #-}
open import Level
open import Ordinals
module ODC {n : Level } (O : Ordinals {n} ) where
open import zf
open import Data.Nat renaming ( zero to Zero ; suc to Suc ; ℕ to Nat ; _⊔_ to _n⊔_ )
open import Relation.Binary.PropositionalEquality
open import Data.Nat.Properties
open ... |
-- Raw terms, weakening (renaming) and substitution.
{-# OPTIONS --without-K --safe #-}
module Definition.Untyped where
open import Tools.Nat
open import Tools.Product
open import Tools.List
import Tools.PropositionalEquality as PE
infixl 30 _∙_
infix 30 Π_▹_
infixr 22 _▹▹_
infixl 30 _ₛ•ₛ_ _•ₛ_ _ₛ•_
infix 25 _[_]
... |
module Productive where
open import Stream
open import Size
open import Data.Maybe
open import Data.Product
open import Relation.Binary.PropositionalEquality as P
PStream : Set → Set
PStream A = Stream (Maybe A)
mutual
record Productive {A : Set} (s : PStream A) : Set where
coinductive
field
step : E... |
{-# OPTIONS --without-K --safe #-}
module Relation.Ternary.Separation.Construct.Product where
open import Level
open import Data.Product
open import Relation.Unary
open import Relation.Binary
open import Relation.Binary.PropositionalEquality
open import Relation.Ternary.Separation
open import Data.Product.Relation.B... |
module syntax-util where
open import cedille-types
open import general-util
open import constants
open import json
posinfo-gen : posinfo
posinfo-gen = "generated"
pi-gen = posinfo-gen
first-position : posinfo
first-position = "1"
dummy-var : var
dummy-var = "_dummy"
id-term : term
id-term = Lam ff "x" nothing (Va... |
module Data.Interval where
data Interval (A : Set) : Set where
[_▻_] : A -> A -> Interval A
lowerBound : {A : Set} -> Interval A -> A
lowerBound [ l ▻ u ] = l
upperBound : {A : Set} -> Interval A -> A
upperBound [ l ▻ u ] = u
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Foundations.Pointed.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Structure
open import Cubical.Foundations.Structure using (typ) public
open import Cubical.Foundations.Groupoid... |
-- Andreas, 2020-01-28, issue #4399, reported by G. Brunerie
postulate
A : Set
data T : Set where
tt : T
f : {x : A} {{_ : T}} → A
f {{ p }} = {!p!}
-- Problem was:
-- Splitting on p produced pattern {{_ = tt}}
-- which was interpreted as cubical partial split.
-- Expected:
-- Splitting on p should produce an ... |
{-# OPTIONS --without-K #-}
module container.m.from-nat.cone where
open import level
open import sum
open import equality
open import function
open import sets.nat.core
open import sets.nat.struct
open import sets.unit
open import container.core
open import container.m.from-nat.core
open import hott.level
module _ {l... |
module LineEndings.Dos where
postulate ThisWorks : Set
|
-- Classical propositional logic, de Bruijn approach, final encoding
module Bf.Cp where
open import Lib using (List; _,_; LMem; lzero; lsuc)
-- Types
infixl 2 _&&_
infixl 1 _||_
infixr 0 _=>_
data Ty : Set where
UNIT : Ty
_=>_ : Ty -> Ty -> Ty
_&&_ : Ty -> Ty -> Ty
_||_ : Ty -> Ty -> Ty
F... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- An explanation about how data types are laid out in the standard
-- library.
------------------------------------------------------------------------
module README.Data where
-- The top-level folder `Data` cont... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Finite sets defined in terms of Data.Star
------------------------------------------------------------------------
module Data.Star.Fin where
open import Data.Star
open import Data.Star.Nat as ℕ using (ℕ)
open ... |
------------------------------------------------------------------------
-- Closure properties for Compatible and Size-preserving
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
module Up-to.Closure where
open import Equality.Propositional
open import Logical-eq... |
module CTL.Modalities.AG where
open import FStream.Core
open import Library
-- Certainly forever : s₀ ⊧ φ ⇔ ∀ s₀ R s₁ R ... ∀ i . sᵢ ⊧ φ
{-# NO_POSITIVITY_CHECK #-} -- Not necessary from Agda 2.6 upwards
record AG' {i : Size} {ℓ₁ ℓ₂} {C : Container ℓ₁}
(props : FStream' C (Set ℓ₂)) : Set (ℓ₁ ⊔ ℓ₂) where
coinducti... |
module Symmetric where
open import Level hiding ( suc ; zero )
open import Algebra
open import Algebra.Structures
open import Data.Fin hiding ( _<_ ; _≤_ ; _-_ ; _+_ )
open import Data.Fin.Properties hiding ( <-trans ; ≤-trans ) renaming ( <-cmp to <-fcmp )
open import Data.Product
open import Data.Fin.Permutation
op... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Setoids.Setoids
open import Rings.Definition
open import Rings.IntegralDomains.Definition
open import Vectors
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Order
open import Numbers.Naturals.Definition
open ... |
module Numeral.Matrix.Proofs where
import Lvl
open import Syntax.Number
open import Data
open import Data.Boolean
open import Data.Boolean.Stmt
open import Data.Boolean.Stmt.Proofs
open import Data.Tuple as Tuple using (_⨯_ ; _,_)
import Functional as Fn
open import Function.Equals
open import Lang.Inspect
o... |
module Logic.Linear.Properties where
open import Logic.Linear using
(LinearProp; _⊢_; Proof
; _^⊥; _⊗_; _⊕_; _&_; _⅋_; _⊸_; _≡_; e!_; e?_
; ^⊥-i; ⊗-i; ⊕-i₁; ⊕-i₂; &-i; ⅋-i; e?-i₁; e?-i₂; e!-i; e?-e; swap
)
open import Data.Nat using (ℕ; zero; suc)
open import Data.Fin using (Fin; zero; suc)
open import Data.V... |
------------------------------------------------------------------------------
-- In the Agda standard library, gcd 0 0 = 0.
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-pol... |
module SystemF where
open import Data.Nat using (ℕ; zero; suc; _+_)
open import Data.Fin as Fin using (Fin; zero; suc)
open import Function as Fun using (_∘_)
open import Relation.Binary.PropositionalEquality as Eq
using (_≡_; refl; cong; cong₂; cong-app; sym)
open Eq.≡-Reasoning
-- -----------------------------... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NType2
open import lib.types.Empty
open import lib.types.Group
open import lib.types.LoopSpace
open import lib.types.Nat
open import lib.types.Pi
open import lib.types.Pointed
open import lib.types.Sigma
open import lib.types.TLevel
open im... |
module _ where
module A where
infixl 0 _+_
data D : Set where
• : D
_+_ : D → D → D
module B where
infixr 0 _+_
data D : Set where
• : D
_+_ : D → D → D
open A
open B
Foo : A.D
Foo = • + • + •
|
module Oscar.Class.Substitute where
open import Oscar.Class.Substitution
open import Oscar.Data.Equality
open import Oscar.Function
open import Oscar.Relation
open import Oscar.Level
record Substitute {a} {A : Set a} {b} (B : A → Set b) {c} (C : A → Set c) {d} (D : A → Set d) : Set (a ⊔ b ⊔ c ⊔ d) where
field
... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Lists where all elements satisfy a given property
------------------------------------------------------------------------
module Data.List.All where
open import Data.List as List hiding (map; all)
open import ... |
{-# OPTIONS --universe-polymorphism #-}
module Literals where
open import Common.Nat
open import Common.Float
open import Common.Char
open import Common.String
open import Common.Unit
open import Common.IO
afloat : Float
afloat = 1.23
astring : String
astring = "abc"
achar : Char
achar = 'd'
anat : Nat
anat = 123
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.