text stringlengths 4 690k |
|---|
open import Agda.Primitive using (_⊔_; lsuc; lzero)
import Categories.Category as Category
import Categories.Category.Cartesian as Cartesian
import MultiSorted.Model as Model
import MultiSorted.Interpretation as Interpretation
import MultiSorted.UniversalModel as UniversalModel
import MultiSorted.SyntacticCategory as... |
------------------------------------------------------------------------------
-- Totality properties respect to Bool
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphi... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Universes
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Universe where
open import Data.Product
open import Function
open import Level
-- U... |
{-# OPTIONS --cubical --safe #-}
module Relation.Nullary.Stable.Base where
open import Data.Empty
open import Level
Stable : Type a → Type a
Stable A = ¬ ¬ A → A
|
module Common.Reflection where
open import Agda.Builtin.Reflection public renaming
( arg-info to argInfo
; function to funDef
; data-type to dataDef
; record-type to recordDef
; agda-sort to sort
; name to qname
; absurd-clause to absurdClause
; pat-lam to extLam
;... |
module gugugu where
open import Relation.Binary.PropositionalEquality
open import Data.List
open import Data.List.Properties
open import Agda.Builtin.Sigma
-- you can import other functions from the stdlib here
++-injectiveʳ : ∀ {ℓ} {A : Set ℓ} (a b c : List A) → a ++ b ≡ a ++ c → b ≡ c
++-injectiveʳ [] b c p = p
++-... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NType2
open import lib.types.Bool
open import lib.types.Empty
open import lib.types.Paths
open import lib.types.Pi
open import lib.types.Sigma
{-
This file contains various lemmas that rely on lib.types.Paths or
functional extensionality f... |
------------------------------------------------------------------------
-- Some results/examples related to CCS, implemented using the
-- classical definition of bisimilarity
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
open import Prelude
module Bisimilarit... |
{-# OPTIONS --without-K --safe #-}
-- Bundled version of a Cocartesian Category
module Categories.Category.Cocartesian.Bundle where
open import Level
open import Categories.Category.Core using (Category)
open import Categories.Category.Cocartesian using (Cocartesian)
-- open import Categories.Category.Cartesian.Mono... |
module integer7 where
import Relation.Binary.PropositionalEquality as PropEq
open PropEq using (_≡_; refl; cong; sym)
open import Data.Nat
-- Int
data Int : Set where
O : Int
I : ℕ → ℕ → Int
postulate
zeroZ : (x : ℕ) → I x x ≡ O
-- plusInt
_++_ : Int → Int → Int
O ++ O = O
O ++ X = X
X ++ O = X
I x y ++ I z w =... |
{-# OPTIONS --rewriting --without-K #-}
open import Agda.Primitive
open import Prelude
import GSeTT.Syntax
import GSeTT.Rules
open import GSeTT.Typed-Syntax
import Globular-TT.Syntax
module Globular-TT.Rules {l} (index : Set l) (rule : index → GSeTT.Typed-Syntax.Ctx × (Globular-TT.Syntax.Pre-Ty index)) where
open i... |
import Lvl
open import Structure.Operator.Ring
open import Structure.Setoid
open import Type
module Structure.Operator.Ring.Characteristic {ℓ ℓₑ} {T : Type{ℓ}} ⦃ equiv : Equiv{ℓₑ}(T) ⦄ (_+_ _⋅_ : T → T → T) ⦃ ring : Ring(_+_)(_⋅_) ⦄ where
open Ring(ring)
open import Function.Iteration
open import Numeral.Natura... |
------------------------------------------------------------------------
-- The syntax of, and a type system for, the untyped λ-calculus with
-- constants
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
module Lambda.Syntax where
open import Equality.Proposition... |
module Plylet where
open import Data.String.Base
open import Data.Char.Base
open import Data.List.Base
data Type : Set where
-- The type of the unit value
TUnit : Type
-- The type constructor for functions →
TFunc : Type -> Type -> Type
-- A type loaded from the prelude
TBuiltin : String -> Ty... |
------------------------------------------------------------------------------
-- Properties related with lists (using induction on the FOTC lists type)
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
... |
module Implicits.Resolution.Infinite.NormalFormEquiv where
open import Prelude
open import Implicits.Syntax
open import Implicits.Resolution.Infinite.Resolution
open import Implicits.Resolution.Embedding
open import Implicits.Resolution.Embedding.Lemmas
open import SystemF.Everything as F using ()
open import System... |
-- Solver for cartesian category
-- Normalisation is based on https://arxiv.org/abs/math/9911059
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Category.Cartesian
module Experiment.Categories.Solver.Category.Cartesian
{o ℓ e} {𝒞 : Category o ℓ e} (cartesian : Cartesian �... |
open import Oscar.Prelude
module Oscar.Class.[ExtensibleType] where
record [ExtensibleType]
{𝔵} {𝔛 : Ø 𝔵}
{𝔟} {𝔒₂ : 𝔛 → Ø 𝔟}
{ℓ̇} (_↦_ : ∀ {x} → 𝔒₂ x → 𝔒₂ x → Ø ℓ̇)
: Ø₀ where
constructor ∁
no-eta-equality
|
open import Relation.Binary.Core
module TreeSort.Impl1.Correctness.Permutation {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_) where
open import BTree {A}
open import Data.List
open import Data.Sum
open import List.Permutation.Base A
open import List.Permutation.Base.Concatenati... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Basic lemmas showing that various types are related (isomorphic or
-- equivalent or…)
------------------------------------------------------------------------
module Function.Related.TypeIsomorphisms where
open... |
-- Andreas, 2013-10-24 Bug reported to me by Christoph-Simon Senjak
module Issue924 where
open import Level
open import Data.Empty
open import Data.Product
open import Data.Sum
open import Data.Bool
open import Data.Maybe.Base
import Data.Nat as ℕ
open import Data.Nat using (ℕ)
import Data.Nat.Divisibility as ℕ
im... |
module Cats.Category.Constructions.Exponential where
open import Level
open import Cats.Category.Base
open import Cats.Category.Constructions.Product as Product using
(HasBinaryProducts)
open import Cats.Util.Conv
import Cats.Category.Constructions.Unique as Unique
module Build {lo la l≈}
(Cat : Category lo la... |
open import Prelude
module Implicits.Resolution.Termination.SizeMeasures where
open import Induction.WellFounded
open import Induction.Nat
open import Data.Product hiding (map)
open import Data.Nat.Base using (_<′_)
open import Data.Fin hiding (_+_; _≤_; _<_; _≤?_)
open import Data.List hiding (map)
open import Data.... |
{-
This file contains:
- Properties of set truncations
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.SetTruncation.Properties where
open import Cubical.HITs.SetTruncation.Base
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundation... |
{-# OPTIONS --cubical --safe --no-import-sorts #-}
module Cubical.HITs.Delooping.Two.Properties where
open import Cubical.Functions.Involution
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Function
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.HLevels
open import... |
----------------------------------------------------------------------
-- A monad with partiality and failure
----------------------------------------------------------------------
module PartialityAndFailure where
open import Category.Monad
open import Codata.Musical.Notation
open import Category.Monad.Partiality as... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Reflexive closures
------------------------------------------------------------------------
module Data.ReflexiveClosure where
open import Data.Unit
open import Level
open import Relation.Binary
open import Rel... |
{-# OPTIONS --cubical --no-import-sorts --safe --experimental-lossy-unification #-}
{-
Kan extension of a functor C → D to a functor PreShv C ℓ → PreShv D ℓ left or right adjoint to
precomposition.
-}
module Cubical.Categories.Presheaf.KanExtension where
open import Cubical.Foundations.Prelude
open import Cubica... |
{-
Problem #758
same as problem 757 but rewritten with only expressions of first-order logic
Given premises:
(all A)(all B)((subset A B) <-> (all x)((mem x A) -> (mem x B))) justification = 1.0
(all A)(all B)(some intAB)(IsInt A B intAB) justification = 1.0
(all A)(all B)(all intAB)((IsInt A B intA... |
{-
Set quotients:
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.SetQuotients.Properties where
open import Cubical.HITs.SetQuotients.Base
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.... |
module bool-thms2 where
open import bool
open import eq
open import product
open import sum
ff-imp : ∀ (b : 𝔹) → (ff imp b) ≡ tt
ff-imp ff = refl
ff-imp tt = refl
imp-tt : ∀ (b : 𝔹) → (b imp tt) ≡ tt
imp-tt ff = refl
imp-tt tt = refl
imp-ff : ∀ (b : 𝔹) → (b imp ff) ≡ ~ b
imp-ff tt = refl
imp-ff ff = refl
tt-imp... |
open import Prelude
open import Data.Nat using (_≤?_)
open import Data.Maybe using (Maybe; just; nothing)
open import Data.Vec using (Vec; _∷_; [])
open import RW.Language.RTerm
open import RW.Language.FinTerm
open import RW.Language.RTermUtils
open import RW.Utils.Monads
module RW.Language.GoalGuesser (maxH : ℕ) whe... |
{-# OPTIONS --prop --rewriting #-}
module Examples.Sorting.Sequential where
open import Examples.Sorting.Sequential.Comparable
open import Calf costMonoid
open import Calf.Types.Nat
open import Calf.Types.List
open import Relation.Binary.PropositionalEquality as Eq using (_≡_)
open import Data.Product using (_,_)
... |
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
-- From: On the Bright Side of Type Classes: Instances Arguments in
-- Agda (ICFP'11).
module InstanceArguments where
open import Data.Bool.Base
... |
-- WARNING: This file was generated automatically by Vehicle
-- and should not be modified manually!
-- Metadata
-- - Agda version: 2.6.2
-- - AISEC version: 0.1.0.1
-- - Time generated: ???
open import AISEC.Utils
open import Data.Real as ℝ using (ℝ)
open import Data.List
module MyTestModule where
f : Tensor ℝ (... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Some specialised instances of the ring solver
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Tactic.RingSolver.Core.Polynomial.Parameters... |
{-
This module contains
- the type of vertical composition operations
that can be defined on a reflexive graph
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.DStructures.Structures.VertComp where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical... |
module FFI.Data.String where
import Agda.Builtin.String
String = Agda.Builtin.String.String
infixr 5 _++_
_++_ = Agda.Builtin.String.primStringAppend
|
-- Dummy file.
|
module Numeral.Natural.Prime.Proofs.Product where
import Lvl
open import Data.Either as Either using ()
open import Functional
open import Lang.Instance
open import Logic.Propositional
open import Numeral.Natural
open import Numeral.Natural.Relation.Divisibility.Proofs
open import Numeral.Natural.Oper
open import... |
open import Nat
open import Prelude
open import core
open import contexts
module typ-dec where
lemma-arr-l : ∀{t1 t2 t4} → t1 ==> t2 == t1 ==> t4 → t2 == t4
lemma-arr-l refl = refl
lemma-arr-r : ∀{t1 t2 t3} → t1 ==> t2 == t3 ==> t2 → t1 == t3
lemma-arr-r refl = refl
lemma-arr-b : ∀{t1 t2 t3 t4} → t1 ==> t2... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Functions.Fibration where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.GroupoidLaws
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.Properties
open import Cu... |
module Numeral.Natural.Relation.ModuloCongruence where
open import Data.Boolean.Stmt
open import Functional
open import Numeral.Natural
open import Numeral.Natural.Oper.Comparisons
open import Numeral.Natural.Oper.Modulo
open import Relator.Equals
open import Type
private variable m n x y : ℕ
_≡_[mod_] : ℕ → ℕ → (m ... |
{-# OPTIONS --cubical #-}
module Cubical.Codata.Conat where
open import Cubical.Codata.Conat.Base public
open import Cubical.Codata.Conat.Properties public
|
{-# OPTIONS --safe --without-K #-}
open import Relation.Binary.PropositionalEquality using (_≡_; _≢_; refl; sym; cong; cong₂; subst; trans)
open import Relation.Nullary.Decidable using (True; from-yes)
open import Relation.Nullary.Negation using (¬?; contradiction)
open Relation.Binary.PropositionalEquality.≡-Reasonin... |
{-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Definition
open import Numbers.Naturals.Naturals
open import Numbers.Naturals.Order
open import Numbers.Naturals.Order.Lemmas
open import Numbers.Naturals.Order.WellFounded
... |
{-# OPTIONS --cubical #-}
open import Agda.Builtin.Cubical.Path
data I : Set where
zero one : I
zero≡one : zero ≡ one
|
------------------------------------------------------------------------------
-- Theory T from the paper
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# O... |
{-# OPTIONS --rewriting #-}
module Properties.Subtyping where
open import Agda.Builtin.Equality using (_≡_; refl)
open import FFI.Data.Either using (Either; Left; Right; mapLR; swapLR; cond)
open import Luau.Subtyping using (_<:_; _≮:_; Tree; Language; ¬Language; witness; unknown; never; scalar; function; scalar-func... |
------------------------------------------------------------------------------
-- The first-order theory of combinators (FOTC) base
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-unive... |
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Escape {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Logica... |
{-# OPTIONS --safe #-}
module Cubical.HITs.SetQuotients.EqClass where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Univalence
open import Cubical.HITs.PropositionalTrun... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module constructs the unit of the monoidal structure on
-- R-modules, and similar for weaker module-like structures.
-- The intended universal property is that the maps out of the tensor
-- unit into M are i... |
-- Andreas, 2019-06-26, issue #3855
-- Mark erased hypotheses as such in a non-erased goal.
-- Same for irrelevance.
Goal :
( A : Set)
(@0 B : Set)
(@irr C : Set)
(@0 @irr D : Set)
( A : Set)
(@0 B : Set)
(@irr C : Set)
(@0 @irr D : Set)
→ Set
Goal A B C D = λ A B C D → ... |
{-# OPTIONS --without-K --cubical #-}
module combinatorial-objects where
import 14-univalence
open 14-univalence public
{- The type ℍ of hereditarily finite types is introduces as an inductive type.
Note that this is the type of 'planar' combinatorial objects, because Fin n
is a linearly ordered finite set wi... |
-- The default include path should contain Agda.Primitive
module TestDefaultIncludePath where
import Agda.Primitive
-- That's it.
|
record Pointed (A : Set) : Set where
field
point : A
point : {A : Set} ⦃ p : Pointed A ⦄ → A
point ⦃ p = p ⦄ = Pointed.point p
record R : Set₁ where
field
A : Set
instance
is-pointed : Pointed A
postulate
r : R
open R r
x : R.A r
x = point
|
module Generic.Test.Data.Product where
open import Generic.Main as Main hiding (Σ; proj₁; proj₂; _,′_) renaming (_,_ to _,′_)
infixr 4 _,_
Σ : ∀ {α β} -> (A : Set α) -> (A -> Set β) -> Set (α ⊔ β)
Σ = readData Main.Σ
pattern _,_ x y = !#₀ (relv x ,′ relv y ,′ lrefl)
proj₁ : ∀ {α β} {A : Set α} {B : A -> Set β} -> ... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NType2
open import lib.Equivalence2
open import lib.NConnected
open import lib.types.TLevel
open import lib.types.Truncation
open import lib.types.Group
open import lib.groups.LoopSpace
open import lib.groups.Homomorphism
module lib.types.... |
{-# OPTIONS --prop --show-irrelevant #-}
open import Agda.Builtin.Equality
postulate
A : Set
P : Prop
f : P → A
g : A → P
{-# TERMINATING #-}
loop : A → A
loop y = loop y
mutual
X : A
X = _
test : ∀ y → X ≡ f (g (loop y))
test y = refl
-- The occurs check should not try to normalize the argument `... |
open import Type
module Relator.Congruence {ℓ₁}{ℓ₂} {X : Type{ℓ₁}}{Y : Type{ℓ₂}} where
import Lvl
open import Functional
open import Logic
open import Logic.Propositional
open import Relator.Equals
-- The congruence relation with respect to a relation
infixl 15 _≅_of_
data _≅_of_ (x₁ : X) (x₂ : X) (f : X → Y) :... |
{-# OPTIONS --without-K #-}
module PointedPi where
open import Level using (_⊔_) renaming (zero to l0; suc to lsuc)
open import Universe using (Universe)
open import Categories.Category using (Category)
open import Categories.Groupoid using (Groupoid)
open import Categories.Functor using (Functor)
open import Data.... |
{-# OPTIONS --cubical --safe #-}
module AssocList where
open import Cubical.Core.Everything using (Type)
open import Data.Bool using (Bool; false; true; _∨_; _∧_)
open import Data.List using (List; []; _∷_; foldr)
open import Data.Product using (_×_; _,_; proj₂)
open import Function using (_∘_... |
-- Empty, unit and equality.
⊥ = (X : Set) → X
⊤ = (X : Set) → X → X
data _≡_ {l}{A : Set l}(x : A) : A → Set l where
<> : x ≡ x
-- The fixpoint of the identity functor as a data definition.
module Data where
data μId : Set where
In : μId → μId
-- μId can be proved empty. Here are both a direct proof and... |
------------------------------------------------------------------------
-- Vectors, defined using an inductive family
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
module Vec.Data
{reflexive} (eq : ∀ {a p} → Equality-with-J a p ref... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Object.Zero
-- Kernels of morphisms.
-- https://ncatlab.org/nlab/show/kernel
module Categories.Object.Kernel {o ℓ e} {𝒞 : Category o ℓ e} (zero : Zero 𝒞) where
open import Level using (_⊔_)
open import Categories.Morphism 𝒞... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Pointwise table equality
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Table.Relation.Binary.Equality where
open import Relation.Binary... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Instantiates the ring solver with two copies of the same ring with
-- decidable equality
------------------------------------------------------------------------
open import Algebra.RingSolver.AlmostCommutativeR... |
module Extensions.All where
open import Data.List.All
|
{-# OPTIONS --cubical #-}
open import Agda.Primitive.Cubical
postulate
A : Set
B : Set
b : B
postulate
PathP : ∀ {ℓ} (A : I → Set ℓ) → A i0 → A i1 → Set ℓ
{-# BUILTIN PATHP PathP #-}
infix 4 _≡_
_≡_ : ∀ {ℓ} {A : Set ℓ} → A → A → Set ℓ
_≡_ {A = A} = PathP (λ _ → A)
f : (\ {a : A} (x : B) → b) ≡ ... |
{-# OPTIONS --without-K #-}
open import lib.Base
module test.fail.Test2 where
module _ where
private
data #I : Type₀ where
#zero : #I
#one : #I
I : Type₀
I = #I
zero : I
zero = #zero
one : I
one = #one
postulate
seg : zero == one
I-elim : ∀ {i} {P : I → Type i} (zero* : P ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of operations on containers
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Container.Properties where
import Function as F
op... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommRingSolver.HornerForms where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat using (ℕ)
open import Cubical.Data.Int hiding (_+_ ; _·_ ; -_)
open import Cubical.Data.FinData
open import Cubical.Data.Vec
open import Cubical.Data.Bool
open import Cu... |
open import Data.Fin using (Fin)
open import Data.Nat using (ℕ; _+_)
open import Data.Vec using (Vec; []; _∷_; _++_)
open import Dipsy.Polarity
module Dipsy.Base
(FOp : {n : ℕ} (as : Vec Polarity n) (b : Polarity) → Set)
(SOp : {n : ℕ} (as : Vec Polarity n) (b : Polarity) → Set)
where
open import Dipsy.Form FOp... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Right-biased universe-sensitive functor and monad instances for the
-- Product type.
--
-- To minimize the universe level of the RawFunctor, we require that
-- elements of B are "lifted" to a copy of B at a highe... |
{-# OPTIONS --safe --warning=error --without-K #-}
module Rings.IntegralDomains.Examples where
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Algebra.FunctionProperties.Consequences.Propositional
{a} {A : Set... |
----------------------------------------------------------------------
-- Copyright: 2013, Jan Stolarek, Lodz University of Technology --
-- --
-- License: See LICENSE file in root of the repo --
-- Repo address: https://github.com/... |
module Syntax where
import Level
open import Data.Unit as Unit renaming (tt to ∗)
open import Data.List as List
open import Data.Product
open import Categories.Category using (Category)
open import Function
open import Relation.Binary.PropositionalEquality as PE hiding ([_]; subst)
open import Relation.Binary using (... |
------------------------------------------------------------------------
-- Functional semantics for an untyped λ-calculus with constants
------------------------------------------------------------------------
module Lambda.Closure.Functional where
open import Category.Monad
open import Category.Monad.Partiality as ... |
------------------------------------------------------------------------------
-- Example using distributive laws on a binary operation via Agsy
------------------------------------------------------------------------------
{-# OPTIONS --allow-unsolved-metas #-}
{-# OPTIONS --exact-split #-}
{-# OPTIO... |
module Syntax.Type where
open import Type
-- Assures that a value has a certain type
type-ascript : ∀{ℓ} → (T : Type{ℓ}) → T → T
type-ascript T x = x
{-# INLINE type-ascript #-}
_:-[_] = type-ascript
infixr 0.98 _:-[_]
{-# INLINE _:-[_] #-}
infixl 10 type-ascript
syntax type-ascript T x = x :of: T
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Inverses
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Function.Inverse where
open import Level
open import Function using (flip)
open impor... |
-- Non-indexed (plain) monads in form of Kleisli triple, presented in point-free style.
module Control.Comonad where
open import Function using (id) renaming (_∘′_ to _∘_)
open import Relation.Binary.PropositionalEquality
open ≡-Reasoning
open import Axiom.FunctionExtensionality
open import Control.Functor
record I... |
-- Andreas, 2016-01-21, issue 1791
-- With-clause stripping for copatterns with "polymorphic" field.
-- {-# OPTIONS -v tc.with.strip:60 #-}
postulate anything : ∀{A : Set} → A
record Wrap (A : Set) : Set where
field unwrap : A
record Pointed (M : Set → Set) : Set₁ where
field point : ∀{A} → M A -- field type s... |
module Generic.Property.Eq where
open import Generic.Core
SemEq : ∀ {i β} {I : Set i} -> Desc I β -> Set
SemEq (var i) = ⊤
SemEq (π i q C) = ⊥
SemEq (D ⊛ E) = SemEq D × SemEq E
mutual
ExtendEq : ∀ {i β} {I : Set i} -> Desc I β -> Set β
ExtendEq (var i) = ⊤
ExtendEq (π i q C) = ExtendEqᵇ i C q
ExtendEq ... |
module prelude where
Subset : Set → Set₁
Subset(X) = X → Set
_∈_ : ∀ {X} → X → Subset(X) → Set
(x ∈ A) = A(x)
_⊆_ : ∀ {X} → Subset(X) → Subset(X) → Set
(A ⊆ B) = ∀ x → (x ∈ A) → (x ∈ B)
record Inhabited {X} (S : Subset(X)) : Set where
constructor _,_
field witness : X
field witness-in : (witness ∈ S)
Rel :... |
{-# OPTIONS --cubical --safe #-}
module Codata.Stream where
open import Prelude
open import Data.List using (List; _∷_; [])
open import Data.List.Kleene
import Data.List.Kleene.Membership as Kleene
open import Data.Fin
Stream : Type a → Type a
Stream A = ℕ → A
infixr 5 _∈_
_∈_ : A → Stream A → Type _
x ∈ xs = fiber... |
module Issue472 where
postulate
I : Set
P : I → Set
record ∃ (P : I → Set) : Set where
constructor _,_
field
fst : I
snd : P fst
open ∃
data S : ∃ P → Set where
s : (i : I) (x : P i) → S (i , x)
Foo : (p : ∃ P) → S p → Set
Foo p (s .(fst p) .(snd p)) = I
-- An internal error has occurred. Please repor... |
import cedille-options
open import general-util
module classify (options : cedille-options.options)
{mF : Set → Set} ⦃ mFm : monad mF ⦄ (write-to-log : string → mF ⊤) where
open import cedille-types
open import constants
open import conversion
open import ctxt
open import datatype-util
open import elab... |
{-# OPTIONS --type-in-type #-}
module poly.core where
open import functors
open import prelude
_^ : Set → Set -- Presheaf
I ^ = I → Set
∫ : Set -- Arena
∫ = ∃ _^
_⦅_⦆ : ∫ → Set → Set -- Interpret as a polynomial functor
(A⁺ , A⁻) ⦅ y ⦆ = Σ[ a⁺ ∈ A⁺ ] (A⁻ a⁺ → y)
module _ (A@(A⁺ , A⁻) B@(B⁺ , B⁻) : ∫) where
∫[_,_]... |
------------------------------------------------------------------------------
-- Bisimilarity relation on unbounded lists
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polym... |
-- Modified: Andreas, 2011-04-11 freezing metas
module Issue151 where
record A : Set₁ where
field
El : Set
data B (a : A) : Set₁ where
b : ∀ a′ → B a′ → B a
data C a : B a → B a → Set₁ where
c : ∀ a′ (p : B a′) → C a (b record{ El = A.El a′ } p) (b a′ p)
c′ : ∀ a′ (p : B a′) → C a (b a′ p) (b a′ p)
-... |
id : forall {k}{X : Set k} -> X -> X
id x = x
_o_ : forall {i j k}
{A : Set i}{B : A -> Set j}{C : (a : A) -> B a -> Set k} ->
(f : {a : A}(b : B a) -> C a b) ->
(g : (a : A) -> B a) ->
(a : A) -> C a (g a)
f o g = \ a -> f (g a)
data List (X : Set) : Set where
[] : List X
_,_ : X → List X → List X
data... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Relations between properties of functions, such as associativity and
-- commutativity (specialised to propositional equality)
------------------------------------------------------------------------
{-# OPTIONS ... |
------------------------------------------------------------------------
-- Application of substitutions to normal and neutral terms
------------------------------------------------------------------------
open import Level using (zero)
open import Data.Universe
module README.DependentlyTyped.NormalForm.Substitution
... |
-- Andreas, 2015-02-07 Failed with-abstraction in rewrite-generated with.
-- {-# OPTIONS -v tc.rewrite.top:25 -v tc.with.top:25 -v tc.with.abstract:50 #-}
{-# OPTIONS --type-in-type #-}
module Issue1420 where
open import Common.Equality
postulate
▶ : Set → Set
▷ : ▶ Set → Set
next : ∀{A} → A → ▶ A
_... |
{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-}
module Agda.Builtin.String where
open import Agda.Builtin.Bool
open import Agda.Builtin.List
open import Agda.Builtin.Char
open import Agda.Builtin.Equality
postulate String : Set
{-# BUILTIN STRING String #-}
primitive
primStringToList : Stri... |
{-# OPTIONS --safe --warning=error --without-K --guardedness #-}
open import Setoids.Setoids
open import Rings.Definition
open import Rings.Orders.Partial.Definition
open import Rings.Orders.Total.Definition
open import Groups.Definition
open import Groups.Lemmas
open import Groups.Homomorphisms.Definition
open import... |
module vector-test where
open import bool
open import nat
open import list
open import vector
test-vector : 𝕍 𝔹 4
test-vector = ff :: tt :: ff :: ff :: []
test-vector2 : 𝕃 (𝕍 𝔹 2)
test-vector2 = (ff :: tt :: []) ::
(tt :: ff :: []) ::
(tt :: ff :: []) :: []
test-vector3 : 𝕍 (𝕍... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.