text stringlengths 4 690k |
|---|
-- Andreas, 2018-06-14, issue #2513, surviving shape-irrelevance annotations.
record Foo (A : Set) : Set where
field
@shape-irrelevant foo : A
test : ∀ A → Foo A → A
test A = Foo.foo
|
module context-properties where
open import utility
open import Esterel.Lang
open import Esterel.Lang.Binding
open import Esterel.Lang.Properties
open import Esterel.Lang.CanFunction
open import Esterel.Lang.CanFunction.Properties
using (canₛ-⊆-FV ; canₛₕ-⊆-FV ; canθₛ-E₁⟦p⟧⊆canθₛ-p ; canθₛₕ-E₁⟦p⟧⊆canθₛₕ-p)
open impo... |
{-# OPTIONS --subtyping #-}
open import Agda.Builtin.Equality
postulate
A : Set
mutual
I : (A -> A) → .A → A
I f = _
testQ : {f : .A -> A} → I f ≡ f
testQ = refl
|
module stateDependentIO where
open import Level using (_⊔_ ) renaming (suc to lsuc; zero to lzero)
open import Size renaming (Size to AgdaSize)
open import NativeIO
open import Function
module _ {γ ρ μ} where
record IOInterfaceˢ : Set (lsuc (γ ⊔ ρ ⊔ μ )) where
field
StateIOˢ : Set γ
Commandˢ ... |
module New.FunctionLemmas where
open import New.Changes
module BinaryValid
{A : Set} {{CA : ChAlg A}}
{B : Set} {{CB : ChAlg B}}
{C : Set} {{CC : ChAlg C}}
(f : A → B → C) (df : A → Ch A → B → Ch B → Ch C)
where
binary-valid-preserve-hp =
∀ a da (ada : valid a da)
b db (bdb : valid b db)
→ ... |
{-# OPTIONS --cubical --safe --postfix-projections #-}
module Relation.Nullary.Omniscience where
open import Prelude
open import Relation.Nullary.Decidable
open import Relation.Nullary.Decidable.Properties
open import Relation.Nullary.Decidable.Logic
open import Relation.Nullary
open import Data.Bool using (bool)
pr... |
-- Andreas, 2017-06-20, issue #2613, reported by Jonathan Prieto.
-- Regression introduced by fix of #2458 (which is obsolete since #2403)
module _ where
open import Agda.Builtin.Nat
module Prop' (n : Nat) where
data Prop' : Set where
_∧_ _∨_ : Prop' → Prop' → Prop'
open Prop' zero
data DView : Prop' → Set ... |
module #11 where
{-
Show that for any type A, we have ¬¬¬A → ¬A.
-}
open import Data.Empty
open import Relation.Nullary
tripleNeg : ∀{x}{A : Set x} → ¬ (¬ (¬ A)) → ¬ A
tripleNeg = λ z z₁ → z (λ z₂ → z₂ z₁)
|
{-# OPTIONS --safe #-}
module Cubical.Data.Vec where
open import Cubical.Data.Vec.Base public
open import Cubical.Data.Vec.Properties public
open import Cubical.Data.Vec.NAry public
open import Cubical.Data.Vec.OperationsNat public
|
------------------------------------------------------------------------------
-- Properties related with lists of natural numbers
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-univer... |
-- a hodge-podge of tests
module Test where
import Test.Class
import Test.EquivalenceExtensionṖroperty
import Test.EquivalenceṖroperty
import Test.EquivalentCandidates
import Test.EquivalentCandidates-2
import Test.Factsurj3
import Test.Functor -- FIXME doesn't work with open import Everything
import Test.ProblemWi... |
{-# OPTIONS --cubical #-}
open import Agda.Builtin.Cubical.Path using (_≡_)
open import Agda.Builtin.Sigma using (Σ; fst; _,_)
postulate
Is-proposition : Set → Set
subst : ∀ {A : Set} (P : A → Set) {x y} → x ≡ y → P x → P y
Proposition : Set₁
Proposition = Σ _ Is-proposition
data _/_ (A : Set) (R : A ... |
module _ where
module A where
infix 0 c
syntax c x = + x
data D₁ : Set where
b : D₁
c : D₁ → D₁
module B where
infix 1 c
syntax c x = + x
data D₂ : Set where
c : A.D₁ → D₂
open A
open B
test₁ : D₂
test₁ = + + + b
test₂ : D₂ → D₁
test₂ (+ + x) = x
test₂ (+ b) = + + + b
|
{-# OPTIONS --prop --rewriting #-}
module Examples.TreeSum where
open import Calf.CostMonoid
open import Calf.CostMonoids using (ℕ²-ParCostMonoid)
parCostMonoid = ℕ²-ParCostMonoid
open ParCostMonoid parCostMonoid
open import Calf costMonoid
open import Calf.ParMetalanguage parCostMonoid
open import Calf.Types.Nat
o... |
{-# OPTIONS --without-K --safe #-}
module Categories.NaturalTransformation.Core where
open import Level
open import Categories.Category
open import Categories.Functor renaming (id to idF)
open import Categories.Functor.Properties
import Categories.Morphism as Morphism
import Categories.Morphism.Reasoning as MR
priv... |
------------------------------------------------------------------------
-- An alternative characterisation of the information ordering, along
-- with related results
------------------------------------------------------------------------
{-# OPTIONS --cubical --safe #-}
open import Prelude hiding (⊥)
module Partia... |
------------------------------------------------------------------------------
-- Testing the translation of the universal quantified propositional symbols
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-... |
-- 2014-06-02 Andrea & Andreas
module _ where
open import Common.Equality
open import Common.Product
postulate
A : Set
F : Set → Set
test : let M : Set
M = _
N : Set × Set → Set
N = _
in ∀ {X : Set}
→ M ≡ F (N (X , X))
× N (A , A) ≡ A
test = refl , ... |
-- Semantics of syntactic kits and explicit substitutions
module Semantics.Substitution.Kits where
open import Syntax.Types
open import Syntax.Context renaming (_,_ to _,,_)
open import Syntax.Terms
open import Syntax.Substitution.Kits
open import Semantics.Types
open import Semantics.Context
open import Semantics.T... |
------------------------------------------------------------------------
-- Some alternative definitions of the concept of being an equivalence
------------------------------------------------------------------------
-- Partly based on the blog post "Universal properties without
-- function extensionality" by Mike Shu... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Rational Literals
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Rational.Literals where
open import Agda.Builtin.FromNat
open import Ag... |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Functor.Algebra where
open import Level hiding (lift)
open import Categories.Category
open import Categories.Functor
record F-Algebra {o ℓ e} {C : Category o ℓ e} (F : Endofunctor C) : Set (o ⊔ ℓ) where
constructor _,_
open Category C
open Functor F
f... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
{-
Note: this module is for cohomology theories,
so the commuting squares below do not
care about the proof of pointedness,
because any cohomology theory is independent
of the possibly different proofs of pointedness.
-}
modul... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category using () renaming (Category to Setoid-Category)
open import Categories.Category.Monoidal
module Categories.Enriched.NaturalTransformation.NaturalIsomorphism
{o ℓ e} {V : Setoid-Category o ℓ e} (M : Monoidal V) where
open import Level
open import C... |
open import Agda.Builtin.Equality
postulate
A : Set
a : A
b : A
mutual
Meta : A → A → A → A
Meta = ?
_ : Meta a ≡ Meta b
_ = refl
|
{-# OPTIONS --cubical --no-import-sorts --no-exact-split --safe #-}
module Cubical.Structures.LeftAction where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.SIP
open import Cubical.Structures.Auto
module _ {ℓ ℓ' : Level} (A : Type ℓ') where
LeftActionStructure : Type ℓ → Type (ℓ-max ℓ ℓ'... |
{-# OPTIONS --cubical #-}
module Cubical.Categories.Functor where
open import Cubical.Foundations.Prelude
open import Cubical.HITs.PropositionalTruncation
open import Cubical.Categories.Category
private
variable
ℓ𝒞 ℓ𝒞' ℓ𝒟 ℓ𝒟' : Level
record Functor (𝒞 : Precategory ℓ𝒞 ℓ𝒞') (𝒟 : Precategory ℓ𝒟 ℓ𝒟') :... |
------------------------------------------------------------------------
-- A relational semantics which uses closures and environments
------------------------------------------------------------------------
module Lambda.Closure.Relational where
open import Codata.Musical.Notation
open import Data.Empty
open import... |
module Prelude where
data _==_ {A : Set}(x : A) : A → Set where
refl : x == x
J : {A : Set} {x y : A} (P : (x y : A) → x == y -> Set) →
(∀ z → P z z refl) → (p : x == y) → P x y p
J P h refl = h _
|
{-# OPTIONS --universe-polymorphism #-}
module CompareLevel where
open import Common.Level
postulate
X : Set
Foo : (a b : Level) → Set (a ⊔ b) → Set
Bar : Foo _ _ X -- solve _1 ⊔ _2 = 0
postulate
id : ∀ {a}{A : Set a} → A → A
apply : ∀ {a b} {A : Set a} {B : Set b} (f : A → B) → A → B
a b : Level
... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Construction.Properties.Functors where
open import Categories.Category.Complete.Properties
using ( Functors-Complete
; evalF-Continuous)
public
open import Categories.Category.Cocomplete.Properties
using (Functors-Cocomplete)
public
|
-- Andreas, 2012-01-10
-- {-# OPTIONS -v tc.constr.findInScope:50 #-}
module InstanceGuessesMeta2 where
open import Common.Level
data ℕ : Set where
zero : ℕ
suc : (n : ℕ) → ℕ
record takeClass {a}
(F : Set a → Set a)
(G : Set a → ℕ → Set a) : Set (lsuc a) where
field
take : {A : Set a} → (n : ℕ) → F A ... |
{-# OPTIONS --allow-unsolved-metas #-}
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module FOT.Agsy.AddTotality where
open import Relation.Binary.PropositionalEquality
infixl 9 _+_
----... |
module Relation.Unary.Monotone.Prefix {ℓ}{T : Set ℓ} where
open import Data.List.Prefix
open import Data.List as List
open import Data.List.Membership.Propositional
open import Data.List.All as All
open import Relation.Unary.Monotone (⊑-preorder {A = T})
instance
open Monotone
any-monotone : ∀ {x : T} → Monoton... |
module Terms where
import Level
open import Data.Unit as Unit
open import Data.List as List
open import Data.Product as Product
open import Categories.Category using (Category)
open import Types
open import Common.Context GType
using (Ctx; Var; zero; ctx-cat; ctx-bin-coproducts)
renaming (succ to succ′)
open Cat... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Matrix where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
open import Cubical.Functions.FunExtEquiv
import Cubical.Data.Empt... |
module OldBasicILP.UntypedSyntax.Common where
open import Common.UntypedContext public
-- Types parametrised by closed, untyped representations.
module ClosedSyntax
(Proof : Set)
where
infixr 10 _⦂_
infixl 9 _∧_
infixr 7 _▻_
data Ty : Set where
α_ : Atom → Ty
_▻_ : Ty → Ty → Ty
_⦂_ : Pro... |
open import Nat
open import Prelude
open import core
open import disjointness
module elaboration-generality where
mutual
elaboration-generality-synth : {Γ : tctx} {e : hexp} {τ : htyp} {d : ihexp} {Δ : hctx} →
Γ ⊢ e ⇒ τ ~> d ⊣ Δ →
Γ ⊢ e => τ
elaboration... |
open import Functional using (id)
import Structure.Logic.Constructive.NaturalDeduction
module Structure.Logic.Constructive.Functions.Properties {ℓₗ} {Formula} {ℓₘₗ} {Proof} {ℓₒ} {Domain} ⦃ constructiveLogicSign : _ ⦄ where
open Structure.Logic.Constructive.NaturalDeduction.ConstructiveLogicSignature {ℓₗ} {Formula... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Finite maps with indexed keys and values, based on AVL trees
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Data.Product as Prod
open imp... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Showing booleans
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Bool.Show where
open import Data.Bool.Base using (Bool; false; true)
ope... |
{-# OPTIONS --cubical --safe #-}
open import Algebra
module Algebra.SemiringLiterals {r} (rng : Semiring r) where
open Semiring rng
open import Literals.Number
open import Data.Nat.Literals
open import Data.Unit
import Data.Unit.UniversePolymorphic as Poly
open import Data.Nat.DivMod
open import Data.Nat using (ℕ; ... |
{-# OPTIONS --without-K --safe #-}
module Util.Relation.Binary.PropositionalEquality where
open import Relation.Binary.PropositionalEquality public
open import Data.Product using (uncurry)
open import Util.Prelude
private
variable
α β γ γ′ δ : Level
A B C A′ B′ C′ : Set α
trans-unassoc : {a b c d : A} ... |
{-# OPTIONS --without-K #-}
module MidiEvent where
open import Data.Fin using (Fin; #_)
open import Data.List using (List; _∷_; []; concat; map)
open import Data.Nat using (ℕ; _+_; _⊔_)
open import Data.Product using (_×_; _,_; proj₁)
open import Data.String using (String)
open import Data.Vec using (... |
{-# OPTIONS --without-K --safe #-}
module TypeTheory.HoTT.Data.Empty.Properties where
-- agda-stdlib
open import Data.Empty
-- agda-misc
open import TypeTheory.HoTT.Base
isProp-⊥ : isProp ⊥
isProp-⊥ x = ⊥-elim x
|
{-# OPTIONS --without-K --safe #-}
module Math.Combinatorics.Function.Properties.Lemma where
open import Data.Unit using (tt)
open import Data.Product
open import Data.Sum
open import Data.Nat
open import Data.Nat.Properties
open import Data.Nat.DivMod
open import Data.Nat.Solver using (module +-*-Solver)
open import... |
module Semantics where
open import Syntax public
-- Kripke models.
record Model : Set₁ where
infix 3 _⊩ᵅ_
field
World : Set
_≤_ : World → World → Set
refl≤ : ∀ {w} → w ≤ w
trans≤ : ∀ {w w′ w″} → w ≤ w′ → w′ ≤ w″ → w ≤ w″
idtrans≤ : ∀ {w w′} → (p : w ≤ w′) → trans≤ refl≤ p ≡... |
{- 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 #-}
-- This module proves the two "V... |
-- Andreas, 2017-01-26
-- A hopefully exhaustive list of reasons why a function cannot
-- be projection-like. The correctness is ensured by triggering
-- a crash if any of the functions in this file is projection-like.
{-# OPTIONS -v tc.proj.like.crash:1000 #-}
data ⊥ : Set where
record ⊤ : Set where
data Bool : S... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Experiments.CohomologyGroups where
open import Cubical.ZCohomology.Base
open import Cubical.ZCohomology.Properties
open import Cubical.ZCohomology.MayerVietorisUnreduced
open import Cubical.ZCohomology.Groups.Unit
open import Cubical.ZCohomology.KcompPr... |
module Sec2 where
open import Sec4
data Bool : Set where
T : Bool
F : Bool
_∣∣_ : Bool → Bool → Bool
_ ∣∣ F = F
_ ∣∣ T = T
_&_ : Bool → Bool → Bool
_ & F = F
F & T = F
T & T = T
_==>_ : Bool → Bool → Bool
F ==> _ = T
T ==> F = F
T ==> T = T
not : Bool -> Bool
not T = F
not F = T
data ℕ : Set where
Z : ... |
{-# OPTIONS --without-K #-}
module algebra.monoid where
open import algebra.monoid.core public
open import algebra.monoid.morphism public
open import algebra.monoid.mset public
|
{-# OPTIONS --type-in-type --no-termination-check
#-}
module Containers where
record Sigma (A : Set) (B : A -> Set) : Set where
field fst : A
snd : B fst
open Sigma
_*_ : (A B : Set) -> Set
A * B = Sigma A \_ -> B
data Zero : Set where
record One : Set where
data PROP : Set where
... |
module Everything where
-- basic utilities
open import Library
open import Isomorphism
-- basic category theory
open import Categories
open import Categories.Sets
open import Categories.Families
open import Categories.Initial
open import Categories.Terminal
open import Categories.CoProducts
open import Categories.Pu... |
open import Auto
open import Algebra
open import Data.List using (_∷_; [];_++_;List)
open import Data.Nat using (ℕ; suc; zero; _+_)
open import Data.Product using (_×_; ∃₂; proj₁; proj₂)
open import Relation.Binary.PropositionalEquality as PropEq using (_≡_; refl; cong; sym)
open import Reflection
module Auto.Example.... |
{-# OPTIONS --rewriting #-}
--{-# OPTIONS --exact-split #-}
--{-# OPTIONS --show-implicit #-}
module NaturalDeduction
where
module CustomPrelude where
open import Prelude public
renaming (_==_ to _≟_) -- TODO ask Agda to rename Eq._==_ to Eq._≟_
hiding (force) -- needed by ∞Delay
{-# BUILTIN REWRITE _≡_... |
open import Nat
open import Prelude
open import contexts
open import core
open import type-assignment-unicity
module canonical-indeterminate-forms where
-- this type gives somewhat nicer syntax for the output of the canonical
-- forms lemma for indeterminates at base type
data cif-base : (Δ : hctx) (d : iexp) →... |
{-# OPTIONS --cubical --safe #-}
module Cubical.ZCohomology.Properties where
open import Cubical.ZCohomology.Base
open import Cubical.HITs.Sn
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Everything
open import Cubical.Foundations.Prelude
open import Cubi... |
------------------------------------------------------------------------
-- Examples
------------------------------------------------------------------------
module StructurallyRecursiveDescentParsing.Examples where
open import Data.List
open import Data.Vec using ([]; _∷_)
open import Data.Nat
open import Data.Bool
... |
module Issue261 where
postulate
List : Set → Set
nil : ∀ A → List A
Nat : Set
works-now : List Nat
works-now with nil _
... | xs = xs
|
module _ where
module A where
data D : Set where
!_ : D
module B where
data D : Set where
!_ : D
open A
test : B.D
test = !_
|
------------------------------------------------------------------------
-- An alternative definition of the partiality monad: a variant of the
-- delay monad quotiented by a notion of weak bisimilarity
------------------------------------------------------------------------
{-# OPTIONS --erased-cubical --sized-types ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Indexed binary relations
------------------------------------------------------------------------
-- The contents of this module should be accessed via
-- `Relation.Binary.Indexed.Heterogeneous`.
{-# OPTIONS --... |
{-# OPTIONS --cubical --safe --postfix-projections #-}
module Data.Dyck.Empty where
open import Prelude
open import Data.Nat using (_+_)
open import Data.Vec.Iterated using (Vec; _∷_; []; foldlN; head)
private
variable
n : ℕ
--------------------------------------------------------------------------------
-- B... |
{-
Holey congruence where there is a 'general' `cong` function available, as in one
that works for any given function.
-}
open import Holes.Prelude
-- NOTE: Why can't we accept the actual functions as arguments instead of quoted
-- versions? Because macros don't play nicely with modules.
module Holes.Cong.General
... |
open import FRP.JS.Nat using ( ℕ ) renaming ( _<_ to _<N_ ; _≤_ to _≤N_ )
open import FRP.JS.Bool using ( Bool ; true ; false ; not )
module FRP.JS.Char where
infix 4 _≟_ _≠_ _<_ _≤_
open import FRP.JS.Primitive public using ( Char )
private
primitive
primCharToNat : Char → ℕ
primCharEquality : Char → Char ... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Groupoid where
open import Level using (Level; suc; _⊔_)
open import Categories.Category using (Category)
import Categories.Morphism
record IsGroupoid {o ℓ e} (C : Category o ℓ e) : Set (o ⊔ ℓ ⊔ e) where
open Category C public
open Categories.Morphis... |
module plfa.part1.Midterm where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong; sym)
-- you can add any import definitions that you need
open import Data.Nat using (ℕ; zero; suc; _+_; _*_; _≤_; _>_; z≤n; s≤s; _≤?_)
open import Data.Nat.Properties using (+-assoc; +-suc; *-suc; +-comm... |
{-# OPTIONS --erased-cubical --safe #-}
open import Data.Nat using (ℕ; zero; suc; _+_; _*_; _≤_ ; _>_; _<_; _≥_; z≤n; s≤s)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong)
module Nat where
-- Useful functions for natural numbers
_-... |
{-# OPTIONS --sized-types --show-implicit #-}
module SizedTypesScopeViolationInMeta where
open import Size
data Nat : {size : Size} -> Set where
zero : {size : Size} -> Nat {↑ size}
suc : {size : Size} -> Nat {size} -> Nat {↑ size}
-- exposing a bug in size constraint solving
-- *** Exception: Inconsistent m... |
module sv20.assign1.First where
{- Code partially taken from the book "Programming Language Foundations in
- Agda" by Philip Wadler, Wen Kokke, Jeremy Siek and many others. The book
- can be found at https://plfa.github.io/
-
- Based on chapter 1 - Natural numbers - https://plfa.github.io/Naturals/
-
- The solut... |
{-# OPTIONS --without-K --safe #-}
-- Identity-on-Objects Functor for (Object-)Unbundled Categories
module Categories.Functor.IdentityOnObjects where
open import Data.Product using (_,_)
open import Function using () renaming (id to id→)
open import Level
open import Categories.Category.Unbundled using (Category)
... |
{-# OPTIONS --no-termination-check #-}
module Data.Nat where
import Prelude
import Data.Bool as Bool
open Prelude
open Bool
data Nat : Set where
zero : Nat
suc : Nat -> Nat
{-# BUILTIN NATURAL Nat #-}
{-# BUILTIN SUC suc #-}
{-# BUILTIN ZERO zero #-}
infix 40 _==_ _<_ _≤_ _>_ _≥_
infixl 60 _+_ _-_
infixl 70 ... |
module Categories.Functor.Monoidal where
|
-- Andreas, 2016-09-20 issue #2197
-- We are now only turning eta-equality on after positivity check.
-- This is at the end of the mutual block.
module _ where
open import Common.Equality
module Works where
mutual
record ⊤ : Set where
eta-equality
test : ∀ {x y : ⊤} → x ≡ y
test = refl
mutual... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.DStructures.Structures.XModule where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Structure
open import... |
module Vector where
open import OscarPrelude
open import Arity
record Vector (A : Set) (𝑎 : Arity) : Set
where
constructor ⟨_⟩
field
vector : Vec A (arity 𝑎)
open Vector public
instance EqVector : {A : Set} ⦃ _ : Eq A ⦄ {𝑎 : Arity} → Eq (Vector A 𝑎)
Eq._==_ EqVector _ = decEq₁ (cong vector) ∘ (_≟_ on ... |
{-
Type-level differentiation in Agda; or differentiation of functors!
Most things below are just restatements of elementary category theory.
The new things are Diff, which defines the derivative of an arbitrary
functor from Set to Set, and _+++_ _***_ _∘∘∘_ which show how to
differentiate sums, products and composi... |
module Long where
data Nat : Set where
z : Nat
s : (n : Nat) → Nat
data Exp : Set where
val : (n : Nat) → Exp
throw : Exp
data Maybe (A : Set) : Set where
Just : A → Maybe A
Nothing : Maybe A
abstract
s′ : Nat → Nat
s′ = s
eval : Exp → Maybe Nat
eval (val n) = ?
eval throw = ?
data D : Nat →... |
open import Prelude
module Implicits.Syntax.Type.Unification where
open import Data.Maybe as Maybe
open import Data.Unit
open import Implicits.Syntax
open import Implicits.Syntax.Type.Unification.McBride as McBride using (
substitute; asub; AList; _//_) public
open import Data.Vec.Properties
open import Data.Nat as... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Pointwise lifting of relations to lists
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Relation.Binary.Pointwise where
open import ... |
------------------------------------------------------------------------
-- Identifiers
------------------------------------------------------------------------
{-# OPTIONS --guardedness #-}
module Examples.Identifier where
open import Codata.Musical.Notation
open import Data.Bool
open import Data.Char
open import D... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Sets.EquivalenceRelations
open import Numbers.Naturals.Semiring
open import Numbers.Integers.Definition
open import Numbers.Naturals.Order
open import LogicalFormulae
open import Groups.Definition
open import Rings.Orders.Partial.Definition
open import Rin... |
-- ------------------------------------------------------------------------------------------------------
-- | ███████╗ ██████╗ ██╗ ██╗ ██╗██╗███╗ ██╗ ██████╗ ██████╗ ██╗███╗ ██╗ ██████╗ ███████╗ |
-- | ██╔════╝██╔═══██╗██║ ██║ ██║██║████╗ ██║██╔════╝ ██╔══██╗██║████╗ ██║██╔════╝ ██╔════╝ |
-... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties satisfied by posets
------------------------------------------------------------------------
open import Relation.Binary
module Relation.Binary.Properties.Poset
{p₁ p₂ p₃} (P : Poset p₁ p₂ p... |
postulate
f : {A B : Set₁} (C : Set) → A → B → C
module _ (A B C : Set) where
test : (X : Set) → Set → Set → X
test = f { A₁ = Set } { B₁ = Set }
|
--
-- Created by Dependently-Typed Lambda Calculus on 2020-09-23
-- Commerce
-- Author: dplaindoux
--
{-# OPTIONS --without-K --safe #-}
module Commerce where
open import Relation.Nullary using (Reflects; Dec; yes; no)
open import Data.Bool using (Bool; true; false)
open import Data.Nat using (ℕ; _+_; _≥?_; _≥_)
ope... |
{-
This second-order signature was created from the following second-order syntax description:
syntax PropLog | PR
type
* : 0-ary
term
false : * | ⊥
or : * * -> * | _∨_ l20
true : * | ⊤
and : * * -> * | _∧_ l30
not : * -> * | ¬_ r50
theory
(⊥U∨ᴸ) a |> or (false, a) = a
(⊥U∨ᴿ) a |> ... |
------------------------------------------------------------------------------
-- The gcd program is correct
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-... |
open import Agda.Primitive.Cubical
record Bad : IUniv where
|
{-# OPTIONS --without-K --exact-split --safe #-}
open import Fragment.Algebra.Signature
module Fragment.Algebra.Homomorphism.Equivalence (Σ : Signature) where
open import Fragment.Algebra.Algebra Σ
open import Fragment.Algebra.Homomorphism.Base Σ
open import Fragment.Algebra.Homomorphism.Properties Σ
open import Fra... |
module Cat where
open import Agda.Primitive
open import CS410-Prelude
open import CS410-Nat
open import CS410-Monoid
open import CS410-Vec
record Cat {k}{l}(O : Set k)(_>>_ : O -> O -> Set l) : Set (lsuc (k ⊔ l)) where
field
-- OPERATIONS ---------------------------------------------------------
iden : {X ... |
module Relation.Equality where
open import Data.Product
-- Identity Types
--
{-
The type of identifications of two (x y : A).
While this can be read as propositional equality, in HoTT identity
can be (and is) elevated to a data type.
-}
data _≡_ {a}{A : Set a}(x : A) : A → Set a where
refl : x ≡ x
cong : ∀... |
{-
Basic theory about h-levels/n-types:
- Basic properties of isContr, isProp and isSet (definitions are in Prelude)
- Hedberg's theorem can be found in Cubical/Relation/Nullary/DecidableEq
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Foundations.HLevels where
open import Cubical.Foundation... |
-- {-# OPTIONS -v interaction.case:10 -v tc.cover:40 #-}
module Issue635 where
record Pointed : Set₁ where
field
Carrier : Set
empty : Carrier
equal : Carrier → Carrier → Set
record PointedMorphism (M₁ M₂ : Pointed) : Set where
constructor morph
module M₁ = Pointed M₁
module M₂ = Pointed M₂
fiel... |
module Termination.Sized.DeBruijnBase where
open import Data.Maybe
open import Data.Maybe.Effectful
open import Function -- composition, identity
open import Relation.Binary.PropositionalEquality hiding ( subst )
open ≡-Reasoning
open import Effect.Functor
fmap : {A B : Set} -> (A -> B) -> Maybe A -> Maybe B
fmap = ... |
{-# OPTIONS --without-K #-}
module sum where
open import level using (Level; _⊔_)
open import function.core
infixr 4 _,_
infixr 2 _×_
infixr 1 _⊎_
record Σ {a b} (A : Set a) (B : A → Set b) : Set (a ⊔ b) where
constructor _,_
field
proj₁ : A
proj₂ : B proj₁
open Σ public
_×_ : {l k : Level} (A : Set l... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Abstractions used in the reflection machinery
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Reflection.Abstraction where
open import Data.Li... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Setoids.Setoids
open import Functions.Definition
open import Groups.Definition
open import Sets.EquivalenceRelations
open import Groups.Homomorphisms.Definition
open import Groups.Lemmas
module Groups.Homomorphisms.Lemmas {a b c d : _} {A : Set a} {S : Se... |
-- Some proposition constructors.
{-# OPTIONS --without-K --safe #-}
module Tools.Nullary where
open import Relation.Nullary using (¬_; Dec; yes; no) public
open import Relation.Nullary.Decidable using (isYes) public
-- If A and B are logically equivalent, then so are Dec A and Dec B.
map : ∀ {ℓ₁ ℓ₂} {A : Set ℓ₁} ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.