text stringlengths 4 690k |
|---|
module TLP01 where
open import Data.Bool
open import Data.Nat
open import Data.String
open import Relation.Binary.PropositionalEquality
as PropEq using (_≡_; refl; sym; cong; cong₂; trans)
_==ℕ_ : ℕ → ℕ → Bool
zero ==ℕ zero = true
suc n ==ℕ suc m = n ==ℕ m
_ ==ℕ _ = false
_<ℕ_ : ℕ → ℕ → Bool... |
-- Andreas, 2012-05-09
module DontPrune where
open import Common.Equality
open import Common.Product
data Bool : Set where
true false : Bool
test : (A : Set) →
let IF : Bool → A → A → A
IF = _
in (a b : A) →
(IF true a b ≡ a) × (IF false a b ≡ b)
test A a b = refl , refl
-- Expected result: unsol... |
------------------------------------------------------------------------------
-- Testing various arguments in the ATP pragmas
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-p... |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Colimit where
open import Level
open import Categories.Category
open import Categories.Functor
open import Categories.NaturalTransformation
open import Categories.Functor.Constant
open import Categories.Cocones
open import Categories.Cocone
open import Categor... |
module Esterel.Variable.Sequential where
open import Data.Nat
using (ℕ) renaming (_≟_ to _≟ℕ_)
open import Function
using (_∘_)
open import Relation.Nullary
using (Dec ; yes ; no ; ¬_)
open import Relation.Binary
using (Decidable)
open import Relation.Binary.PropositionalEquality
using (_≡_ ; refl ; cong ; t... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Functions
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Function where
open import Function.Core public
open import Function.Base public
ope... |
{-# OPTIONS --without-K #-}
open import Base
open import Homotopy.Pushout
open import Homotopy.VanKampen.Guide
module Homotopy.VanKampen.Code.LemmaPackA {i} (d : pushout-diag i)
(l : legend i (pushout-diag.C d)) where
open import Homotopy.Truncation
open import Homotopy.PathTruncation
private
module Pac... |
module Cats.Functor.Yoneda where
open import Data.Product using (_,_)
open import Relation.Binary using (Rel ; Setoid ; IsEquivalence)
open import Relation.Binary.PropositionalEquality using (_≡_ ; refl)
open import Cats.Bifunctor using (transposeBifunctor₂)
open import Cats.Category
open import Cats.Category.Cat.Fac... |
module Automata.Composition.Union (Σ : Set) where
-- Standard libraries imports ----------------------------------------
open import Data.Empty using (⊥ ; ⊥-elim)
open import Data.Nat using (ℕ)
open import Data.Sum using (_⊎_ ; inj₁ ; inj₂)
open import Data.Product using (_,_)
open import Data.Vec using (Vec ; [] ; _∷... |
{-
This file contains the classic isomorphism theorems for groups (so far
only the first theorem)
-}
{-# OPTIONS --safe #-}
module Cubical.Algebra.Group.IsomorphismTheorems where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cu... |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Bicategory where
open import Level
-- open import Data.Product using (curry; _,_)
-- open import Function using () renaming (_∘_ to _·_)
open import Categories.Support.PropositionalEquality
open import Categories.Category
open import Categories.Categories
ope... |
{-# OPTIONS --safe #-}
module Definition.Typed.Consequences.PiNorm where
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.Weakening
open import Definition.Typed.EqRelInstance
open import Definitio... |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Grothendieck where
open import Relation.Binary using (Rel)
open import Data.Product using (Σ; _,_; proj₁; proj₂; _×_)
open import Categories.Support.Experimental
open import Categories.Support.PropositionalEquality
open import Categories.Support.IProduct
impor... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- A bunch of properties
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Bool.Properties where
open import Algebra
open import Data.Bool.Bas... |
module STLCSF.Examples where
open import Data.Fin hiding (_+_)
open import Data.Product
open import Data.List
open import Data.List.Membership.Propositional
open import Data.List.Relation.Unary.Any
open import Data.List.Relation.Unary.All
open import Data.Maybe
open import Data.Integer hiding (suc)
-- This file conta... |
{- 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.Rust.RustTypes
module LibraBFT.Impl.OBM.Rust.D... |
module Category.Diagram where
open import Level renaming (suc to lsuc)
open import Equality.Eq
open import Setoid.Total
open import Category.Category
open import Category.Funct
open import Category.Preorder
-- Diagrams are functors from an index category J to a category ℂ. We
-- think of J as the scheme of the diag... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Ring where
open import Cubical.Algebra.Ring.Base public
open import Cubical.Algebra.Ring.Properties public
open import Cubical.Algebra.Ring.Ideal public
open import Cubical.Algebra.Ring.Kernel public
|
{-# OPTIONS --cubical-compatible #-}
module Common.Product where
open import Common.Level
infixr 4 _,_ _,′_
infixr 2 _×_
------------------------------------------------------------------------
-- Definition
record Σ {a b} (A : Set a) (B : A → Set b) : Set (a ⊔ b) where
constructor _,_
field
proj₁ : A
p... |
-- Andreas, 2011-10-02
module NotApplyingInDontCareTriggersInternalError where
import Common.Irrelevance
postulate
Val : Set
App : Val -> Val -> Val -> Set
Rel = Val -> Val -> Set
Transitive : Rel → Set
Transitive R = ∀ {t1 t2 t3} → R t1 t2 → R t2 t3 → R t1 t3
postulate
LeftReflexive : Rel → Set
RightReflex... |
{- Proof of the Universal Property of Our Fold -}
module FoldUniv where
open import Function using (id)
open import Data.Unit using (⊤ ; tt) public
open import Data.Empty using (⊥) public
open import Data.Sum using (_⊎_; [_,_]; inj₁ ; inj₂) public
open import Data.Product
open import Data.Nat using (ℕ)
open import Da... |
module Structures where
open import Category.Functor using (RawFunctor ; module RawFunctor)
open import Category.Monad using (module RawMonad)
open import Data.Maybe using (Maybe) renaming (monad to MaybeMonad)
open import Data.Nat using (ℕ)
open import Data.Vec as V using (Vec)
import Data.Vec.Properties as VP
open i... |
{-# OPTIONS --cubical --safe #-}
module Control.Monad.Levels where
open import Control.Monad.Levels.Definition public
|
open import Agda.Builtin.Nat
open import Agda.Builtin.FromNat
open import Agda.Builtin.Unit
instance
NumberNat : Number Nat
Number.Constraint NumberNat _ = ⊤
fromNat {{NumberNat}} n = n
open import Issue2641.Import
|
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Setoids.Setoids
open import Sets.EquivalenceRelations
open import Rings.Definition
module Rings.Units.Lemmas {a b : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ _*_ : A → A → A} (R : Ring S _+_ _*_) where
open import Rings.Unit... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Functions.FunExtEquiv where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
open import Cubical.Data.Vec
open import Cubical.Data.Nat
... |
{-# OPTIONS --without-K #-}
module Examples.New where
open import Data.Empty using (⊥)
open import Data.Unit using (⊤; tt)
open import Data.Sum using (_⊎_; inj₁; inj₂; [_,_]′)
open import Data.Product using (_×_; _,_; proj₁; proj₂)
open import Relation.Binary.PropositionalEquality
using (_≡_; refl; sym; trans; cong... |
------------------------------------------------------------------------
-- Terminating parser "combinator" interface
------------------------------------------------------------------------
-- Use RecursiveDescent.Hybrid.Simple to actually run the parsers.
module RecursiveDescent.Hybrid where
open import RecursiveD... |
------------------------------------------------------------------------------
-- Testing Agda internal term: @Lam@
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Lexicographic products of binary relations
------------------------------------------------------------------------
-- The definition of lexicographic product used here is suitable if
-- the left-hand relation i... |
record R : Set₁ where
field
A : Set
{B} : Set
{{C}} : Set
open R
r : R
r = {!!}
-- C-c C-c produced
-- A r = {!!}
-- B {r} = {!!}
-- C {{r}} = {!!}
|
module Example where
open import Bool
open import Nat hiding (_==_; _+_)
open import AC
open Provable
infix 40 _+_
infix 30 _==_
postulate
X : Set
_==_ : X -> X -> Set
|0| : X
_+_ : X -> X -> X
refl : forall {x} -> x == x
sym : forall {x y} -> x == y -> y == x
trans : forall {x y z} -> x =... |
open import Level
open import Ordinals
module filter {n : Level } (O : Ordinals {n}) where
open import zf
open import logic
import OD
open import Relation.Nullary
open import Data.Empty
open import Relation.Binary.Core
open import Relation.Binary.PropositionalEquality
import BAlgbra
open BAlgbra O
open inOrdi... |
module Solution where
open import Data.Empty
open import Data.List
open import Data.Nat
open import Data.Bool hiding (_≟_)
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
data Subseq : List ℕ → List ℕ → Set where
subseq-nil : Subseq [] []
subseq-take : ∀ ... |
{-# OPTIONS --cubical --safe #-}
open import Relation.Binary
module Relation.Binary.Equivalence.Reasoning {a} {𝑆 : Set a} {b} (equivalence : Equivalence 𝑆 b) where
open Equivalence equivalence
open import Function
import Path
infixr 2 ≋˘⟨⟩-syntax _≋⟨⟩_ ≋⟨∙⟩-syntax ≡⟨∙⟩-syntax
≋˘⟨⟩-syntax : ∀ (x : 𝑆) {y z} → y ... |
{-# OPTIONS --allow-unsolved-metas #-}
open import Oscar.Prelude
-- meta-class
open import Oscar.Class
-- classes
open import Oscar.Class.Smap
open import Oscar.Class.Symmetry
-- individual instances
open import Oscar.Class.Hmap.Transleftidentity
open import Oscar.Class.Reflexivity.Function
open import Oscar.Class.... |
-- Records are allowed in mutual blocks.
module RecordInMutual where
mutual
record A : Set where
field x : B
record B : Set where
field x : A
|
module Ag09 where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong; cong-app)
open Eq.≡-Reasoning
open import Data.Nat using (ℕ; zero; suc; _+_)
open import Data.Nat.Properties using (+-comm)
_∘_ : ∀ {A B C : Set} → (B → C) → (A → B) → (A → C)
(g ∘ f) x = g (f x)
infix 0 _≃_
record... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Semiring
open import Numbers.Integers.Definition
open import Semirings.Definition
open import Groups.Abelian.Definition
open import Groups.Definition
open import Setoids.Setoids
module Numbers.Integers.Addition... |
module Cats.Util.Monad where
open import Category.Monad public
open import Data.List using (List ; [] ; _∷_ ; map)
open import Data.Unit using (⊤)
open import Function using (_∘_)
open import Level using (Lift ; lift)
open RawMonad {{...}} public
private
_<*>_ = _⊛_
module _ {f} {M : Set f → Set f} {{_ : RawMo... |
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.Localization.Properties 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.PathSplitEquiv
open isPathSplitEquiv
ope... |
------------------------------------------------------------------------------
-- The alternating bit protocol (ABP) is correct
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-... |
{-# 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... |
open import SOAS.Common
open import SOAS.Families.Core
import SOAS.Metatheory.MetaAlgebra
-- Shorthands for de Bruijn indices
module SOAS.Syntax.Shorthands {T : Set}
{⅀F : Functor 𝔽amiliesₛ 𝔽amiliesₛ}
(open SOAS.Metatheory.MetaAlgebra ⅀F)
{𝒜 : Familyₛ → Familyₛ}(𝒜ᵃ : (𝔛 : Familyₛ) → MetaAlg 𝔛 (𝒜 𝔛))
... |
import MJ.Classtable
import MJ.Syntax as Syntax
import MJ.Semantics.Values as Values
import MJ.Classtable.Core as Core
import MJ.Classtable.Code as Code
--
-- Substitution-free interpretation of welltyped MJ
--
module MJ.Semantics.Monadic {c} (Ct : Core.Classtable c)(ℂ : Code.Code Ct) where
open import Prelude hidi... |
{-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Implementation.Data.Natural where
open import Light.Library.Data.Natural using (Library ; Dependencies)
import Light.Implementation.Relation.Decidable
import Light.Implementation.Relation.Binary.Equality.Propositional
import ... |
module silly0 where
record SingleSortedAlgebra : Set₁ where
field
Carrier : Set
_⊕_ : Carrier → Carrier → Carrier
{-
One of my aims to introduce construct “fields-of”:
record SingleSortedAlgebraWithConstant : Set₁ where
fields-of SingleSortedAlgebra renaming (_⊕_ to _⟨$⟩_)
field
... |
{-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Library.Data.Boolean where
open import Light.Level using (Level ; Setω ; Lifted)
open import Light.Variable.Sets
open import Light.Library.Data.Unit as Unit using (Unit)
open import Light.Library.Data.Empty as Empty using (Em... |
module Issue794 where
open import Common.Prelude
open import Common.MAlonzo
postulate A : Set
record R : Set where
id : A → A
id x = x
|
{-# OPTIONS --without-K #-}
module LeqLemmas where
open import Data.Nat
using (ℕ; suc; _+_; _*_; _<_; _≤_; _≤?_; z≤n; s≤s; module ≤-Reasoning)
open import Data.Nat.Properties.Simple using (+-comm)
open import Data.Nat.Properties using (n≤m+n)
open import Relation.Binary using (Decidable)
--------------------------... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use `Data.Vec.Functional` instead.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Table.Base where
{-#... |
{-# OPTIONS --cubical-compatible #-}
-- Large indices are not allowed --cubical-compatible
data Singleton {a} {A : Set a} : A → Set where
[_] : ∀ x → Singleton x
|
------------------------------------------------------------------------
-- Bounded vectors (inefficient, concrete implementation)
------------------------------------------------------------------------
-- Vectors of a specified maximum length.
module Data.BoundedVec.Inefficient where
open import Data.Nat
open impo... |
{-# OPTIONS --cubical --safe #-}
module Control.Monad.Levels.Mult where
open import Prelude
open import Control.Monad.Levels.Definition
open import Control.Monad.Levels.Eliminators
open import Control.Monad.Levels.Zipping
open import Data.Bag hiding (bind)
open import Path.Reasoning
open import Cubical.Foundations.H... |
open import Level using () renaming (_⊔_ to _⊔ˡ_)
open import Function using (_$_; flip)
open import Function.Equivalence as FE using ()
open import Relation.Nullary using (yes; no)
open import Relation.Nullary.Decidable using (map)
open import Relation.Nullary.Negation using (contradiction)
open import Relation.Binar... |
open import Relation.Binary.PropositionalEquality using (sym)
open import Data.Fin using (zero; suc)
open import Data.Nat using (suc)
open import Substitution using (rename-subst-commute; subst-commute)
open import DeBruijn
open import Beta
infix 3 _—↠ˢ_
_—↠ˢ_ : ∀ {n m} → Subst n m → Subst n m → Set
σ —... |
open import Formalization.PredicateLogic.Signature
module Formalization.PredicateLogic.Constructive.NaturalDeduction (𝔏 : Signature) where
open Signature(𝔏)
open import Data.ListSized
import Lvl
open import Formalization.PredicateLogic.Syntax(𝔏)
open import Formalization.PredicateLogic.Syntax.Substitution(𝔏)... |
open import Function
open import Relation.Binary
open import Relation.Binary.PropositionalEquality as P
open ≡-Reasoning
open import Data.Empty
open import Data.Unit
open import Data.Sum as Sum
open import Data.Product as Prod
record ℕ∞ : Set where
coinductive
field pred : ⊤ ⊎ ℕ∞
open ℕ∞ public
data-~ℕ∞~ : ⊤ ⊎ ℕ... |
module Structure.Operator.Vector.LinearMap.Category where
import Data.Tuple as Tuple
open import Functional
open import Function.Proofs
open import Function.Equals
open import Function.Equals.Proofs
open import Logic.Predicate
open import Logic.Predicate.Equiv
open import Logic.Propositional
import Lvl
open ... |
{-# OPTIONS --without-K #-}
{-
Now it only has specialized constructs and lemmas for π₀ (x ≡ y)
Should be rewritten with something like Algebra.Groupoids
-}
open import Base
module Homotopy.PathTruncation where
open import HLevel
open import HLevelBis
open import Homotopy.Truncation
_≡₀_ : ∀ {i} {A : Set i} →... |
{-
A morphism of UARels is a function between the structures with an action on the relations that
commutes with the equivalence to PathP.
We can reindex a DUARel or SubstRel along one of these.
-}
{-# OPTIONS --safe #-}
module Cubical.Displayed.Morphism where
open import Cubical.Foundations.Prelude
open import ... |
{-# OPTIONS --copatterns #-}
-- One-place functors (decorations) on Set
module Control.Auto-Bug-in-Goal-2 where
open import Function using (id)
open import Relation.Binary.PropositionalEquality
open ≡-Reasoning
open import Control.Functor
record IsDecoration (D : Set → Set) : Set₁ where
field
traverse : ∀ {... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import cohomology.Theory
open import cw.CW
module cw.cohomology.CohomologyGroupsTooHigh {i} (OT : OrdinaryTheory i)
m {n} (n<m : n < m) (G : Group i) (⊙skel : ⊙Skeleton {i} n)
(ac : ⊙has-cells-with-choice 0 ⊙skel i) where
open OrdinaryTheory OT
open ... |
{-# OPTIONS --without-K #-}
module Lecture5 where
open import Lecture4 public
-- Section 5.1 Homotopies
_~_ : {i j : Level} {A : UU i} {B : A → UU j} (f g : (x : A) → B x) → UU (i ⊔ j)
f ~ g = (x : _) → Id (f x) (g x)
htpy-refl : {i j : Level} {A : UU i} {B : A → UU j} (f : (x : A) → B x) → f ~ f
htpy-refl f x = re... |
module Inductive.Examples.Sum where
open import Inductive
open import Tuple
open import Data.Fin
open import Data.Product
open import Data.List
open import Data.Vec
_⊎_ : Set → Set → Set
A ⊎ B = Inductive (((A ∷ []) , []) ∷ (((B ∷ []) , []) ∷ []))
inl : {A B : Set} → A → A ⊎ B
inl a = construct zero (a ∷ []) []
in... |
module Basic.BigStep where
import Data.Bool as Bool using (not)
open import Data.Bool hiding (not; if_then_else_)
open import Data.Empty
open import Data.Fin using (Fin; suc; zero; #_)
open import Data.Nat
open import Data.Nat.Properties.Simple
open import Data.Vec
open import Function
open import Relation.Nullary... |
postulate
A : Set
open import Agda.Builtin.Equality
-- here the solution g := (\ (@0 x) (@0 y) → f y x) is not well-typed
-- in a non-erased context, which is how `g` is declared.
bar : (f : A → A → A) (g : @0 A → @0 A → A)
→ @0 _≡_ {A = @0 A → @0 A → A} g (\ (@0 x) (@0 y) → f y x)
→ @0 A → @0 A → A
bar f ... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Category.Monoidal
module Categories.Category.Monoidal.Traced {o ℓ e} {C : Category o ℓ e} (M : Monoidal C) where
open Category C
open import Level
open import Data.Product using (_,_)
open import Categories.Category.Monoidal... |
open import Structure.Category
open import Type
module Structure.Category.Monad.Category
{ℓₒ ℓₘ ℓₑ}
{cat : CategoryObject{ℓₒ}{ℓₘ}{ℓₑ}}
where
import Data.Tuple as Tuple
import Function.Equals
open Function.Equals.Dependent
import Lvl
open import Structure.Category.Functor
open import Struct... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Lexicographic ordering of lists
------------------------------------------------------------------------
-- The definitions of lexicographic orderings used here is suitable if
-- the argument order is a (non-str... |
{-# OPTIONS --exact-split #-}
module ExactSplitMin where
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
min : ℕ → ℕ → ℕ
min zero y = zero
min x zero = zero
min (suc x) (suc y) = suc (min x y)
|
------------------------------------------------------------------------------
-- Division program
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.Vec.Relation.Binary.Equality.DecPropositional directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
... |
-- Andreas, 2016-05-19, issue 1986, after report from Nisse
-- Andreas, 2016-06-02 fixed
-- This has been reported before as issue 842
-- {-# OPTIONS -v tc.cover:20 #-}
-- {-# OPTIONS -v tc.cc:20 -v reduce.compiled:100 #-}
open import Common.Equality
data Bool : Set where
true false : Bool
not : Bool → Bool
not t... |
module Cats.Category.Constructions.Unique where
open import Data.Unit using (⊤)
open import Level
open import Cats.Category.Base
open import Cats.Util.Conv
module Build {lo la l≈} (Cat : Category lo la l≈) where
open Category Cat
IsUniqueSuchThat : ∀ {lp A B} → (A ⇒ B → Set lp) → A ⇒ B → Set (la ⊔ l≈ ⊔ lp)
... |
module Oscar.Category.Functor where
open import Oscar.Category.Setoid
open import Oscar.Category.Category
open import Oscar.Category.Semifunctor
open import Oscar.Level
record Categories 𝔬₁ 𝔪₁ 𝔮₁ 𝔬₂ 𝔪₂ 𝔮₂ : Set (lsuc (𝔬₁ ⊔ 𝔪₁ ⊔ 𝔮₁ ⊔ 𝔬₂ ⊔ 𝔪₂ ⊔ 𝔮₂)) where
constructor _,_
field
category₁ : Category ... |
module Impossible where
{-# IMPOSSIBLE #-}
|
module _ where
open import Agda.Builtin.Equality
open import Agda.Builtin.Bool
open import Agda.Builtin.Unit
open import Agda.Builtin.List
open import Agda.Builtin.Nat
open import Agda.Builtin.Reflection renaming (returnTC to return; bindTC to _>>=_)
_>>_ : {A B : Set} → TC A → TC B → TC B
m >> m' = m >>= λ _ → m'
... |
open import Agda.Builtin.Nat
data Sing : Nat → Set where
i : (k : Nat) → Sing k
toSing : (n : Nat) → Sing n
toSing n = i n
fun : (n : Nat) → Nat
fun n with toSing n
fun .n | i n with toSing n
fun .(n + n) | i .n | i n = {!!}
|
module PrintNat where
import PreludeShow
open PreludeShow
mainS = showNat 42
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- The sublist relation over propositional equality.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Relation.Binary.Subset.Propositiona... |
open import Common.Prelude renaming (Nat to ℕ; _+_ to _+ℕ_)
open import Common.Product
open import Common.Equality
postulate
_≤ℕ_ : (n m : ℕ) → Set
maxℕ : (n m : ℕ) → ℕ
When : (b : Bool) (P : Set) → Set
When true P = P
When false P = ⊤
infix 30 _⊕_
infix 20 _+_
infix 10 _≤_
infix 10 _<_
infixr 4 _,_
mutual
... |
open import Categories
open import Functors
open import RMonads
module RMonads.RKleisli.Functors {a b c d}{C : Cat {a}{b}}{D : Cat {c}{d}}
{J : Fun C D}(M : RMonad J) where
open import Library
open import RMonads.RKleisli M
open import RAdjunctions
open Cat
open Fun
open RMonad M
RK... |
postulate B : Set
module M where
record ⊤ : Set where
module P (A : Set) where
open M public
module PB = P B
|
{-# OPTIONS --experimental-irrelevance #-}
{-# OPTIONS --sized-types #-}
open import Agda.Primitive
public using (lzero; lsuc)
open import Agda.Builtin.Size
public using (Size; ↑_) renaming (∞ to oo)
open import Agda.Builtin.Nat
public using (suc) renaming (Nat to ℕ)
_+_ : Size → ℕ → Size
s + 0 = s
s + suc n ... |
import Oscar.Class.Reflexivity.Function
import Oscar.Class.Transextensionality.Proposequality -- FIXME why not use the instance here?
open import Oscar.Class
open import Oscar.Class.Category
open import Oscar.Class.HasEquivalence
open import Oscar.Class.IsCategory
open import Oscar.Class.IsPrecategory
open import Osca... |
open import MLib.Algebra.PropertyCode
open import MLib.Algebra.PropertyCode.Structures
module MLib.Matrix.SemiTensor.Core {c ℓ} (struct : Struct bimonoidCode c ℓ) where
open import MLib.Prelude
open import MLib.Matrix.Core
open import MLib.Matrix.Equality struct
open import MLib.Matrix.Mul struct
open import MLib.Mat... |
{-# OPTIONS --safe #-}
module Cubical.Data.Int.MoreInts.BiInvInt where
open import Cubical.Data.Int.MoreInts.BiInvInt.Base public
open import Cubical.Data.Int.MoreInts.BiInvInt.Properties public
|
{-# OPTIONS --sized-types --show-implicit #-}
module WrongSizeAssignment2 where
open import Common.Size renaming (↑_ to _^)
data Empty : Set where
data N : {_ : Size} -> Set where
zero : N {∞}
suc : forall {i} -> N {i ^} -> N {i}
lift : forall {i} -> N {i} -> N {i ^}
lift zero = zero
lift (suc x) = suc (li... |
postulate
U V : Set
T : V → Set
H : ∀ v → T v → Set
f : U → V
data D : Set where d : D
foo : (u : U) (t : T (f u)) (h : H (f u) t) → H (f u) t
foo u t h with f u | d
... | fu | x = h
|
module RandomAccessList.Standard.Properties where
open import BuildingBlock
open import BuildingBlock.BinaryLeafTree using (BinaryLeafTree; Node; Leaf)
import BuildingBlock.BinaryLeafTree as BLT
open import RandomAccessList.Standard
open import RandomAccessList.Standard.Core
open import RandomAccessList.Standard... |
{-# OPTIONS --without-K #-}
open import lib.Base
module lib.types.List where
data List {i} (A : Type i) : Type i where
nil : List A
_::_ : A → List A → List A
data HList {i} : List (Type i) → Type (lsucc i) where
nil : HList nil
_::_ : {A : Type i} {L : List (Type i)} → A → HList L → HList (A :: L)
hlist-c... |
open import Oscar.Prelude
open import Oscar.Class
open import Oscar.Class.Leftunit
open import Oscar.Class.Reflexivity
open import Oscar.Class.Transitivity
module Oscar.Class.Transleftidentity where
module Transleftidentity
{𝔬} {𝔒 : Ø 𝔬}
{𝔯} (_∼_ : 𝔒 → 𝔒 → Ø 𝔯)
{ℓ} (_∼̇_ : ∀ {x y} → x ∼ y → x ∼ y → Ø ℓ)... |
{-# OPTIONS --without-K --safe #-}
module Categories.Bicategory.Construction.Spans.Properties where
open import Level
open import Data.Product using (_,_; _×_)
open import Relation.Binary.Bundles using (Setoid)
import Relation.Binary.Reasoning.Setoid as SR
open import Function.Equality as SΠ renaming (id to ⟶-id)
o... |
{-# OPTIONS --rewriting --without-K #-}
open import Agda.Primitive
open import Prelude
{- Syntax for the Type theory for globular sets -}
module GSeTT.Syntax where
data Pre-Ty : Set
data Pre-Tm : Set
data Pre-Ty where
∗ : Pre-Ty
⇒ : Pre-Ty → Pre-Tm → Pre-Tm → Pre-Ty
data Pre-Tm where
Var : ℕ → ... |
open import Data.Product using ( _×_ ; _,_ )
open import Data.Sum using ( inj₁ ; inj₂ )
open import Relation.Binary.PropositionalEquality using ( refl )
open import Relation.Unary using ( _∈_ ; _∉_ ; _⊆_ )
open import Web.Semantic.DL.Concept.Model using
( _⟦_⟧₁ ; ⟦⟧₁-resp-≈ ; ⟦⟧₁-resp-≃; ⟦⟧₁-refl-≃ )
open import Web.... |
-- Andreas, 2017-01-13, regression introduced by the fix of #1899
-- test case and report by Nisse
-- {-# OPTIONS -v term:40 #-}
open import Agda.Builtin.Size
mutual
D : Size → Set
D i = D′ i
record D′ (i : Size) : Set where
coinductive
field
force : {j : Size< i} → D j
test : D′ ω
D′.force te... |
{-# OPTIONS --without-K #-}
module PInj where
open import Codata.Delay renaming (length to dlength ; map to dmap )
open import Codata.Thunk
open import Relation.Binary.PropositionalEquality
open import Size
open import Level
open import Data.Product
-- A pair of partial functions that are supposed to form a partia... |
{-# OPTIONS --without-K --exact-split --allow-unsolved-metas #-}
module 10-number-theory where
import 09-truncation-levels
open 09-truncation-levels public
two-ℕ : ℕ
two-ℕ = succ-ℕ one-ℕ
three-ℕ : ℕ
three-ℕ = succ-ℕ two-ℕ
four-ℕ : ℕ
four-ℕ = succ-ℕ three-ℕ
five-ℕ : ℕ
five-ℕ = succ-ℕ four-ℕ
six-ℕ : ℕ
six-ℕ = succ... |
-- We apply the theory of quasi equivalence relations (QERs) to finite multisets and association lists.
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Relation.ZigZag.Applications.MultiSet where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundatio... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.