text stringlengths 4 690k |
|---|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties satisfied by bounded meet semilattices
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary.Lattice
module Relation... |
-- Andreas, 2018-04-16, issue #3033, reported by Christian Sattler
-- The DotPatternCtx was not used inside dot patterns in ConcreteToAbstract.
postulate
A : Set
B : Set
a : A
f : A ā B
data C : B ā Set where
c : C (f a)
foo : (b : B) ā C b ā Set
foo .{!f a!} c = A -- give "f a" here
-- WAS: foo .f a c ... |
module Tactic.Monoid where
open import Prelude
open import Tactic.Reflection
open import Tactic.Reflection.Quote
open import Tactic.Monoid.Exp
open import Tactic.Monoid.Reflect
open import Tactic.Monoid.Proofs
monoidTactic : ā {a} {A : Set a} {{_ : Monoid/Laws A}} ā Tactic
monoidTactic {A = A} {{laws}} hole = do
... |
module MetaId where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
expr = (\ (a : Set) (x : a) -> x) _ zero
|
{-# OPTIONS --cubical --no-import-sorts #-}
module MoreLogic.Definitions where -- hProp logic
open import Cubical.Foundations.Everything renaming (_ā»Ā¹ to _ā»Ā¹įµ; assoc to ā-assoc)
open import Cubical.Data.Sum.Base renaming (_ā_ to infixr 4 _ā_)
open import Cubical.Relation.Nullary.Base renaming (Ā¬_ to Ā¬įµ_)
open import ... |
open import Nat
open import Prelude
module Hazelnut-core where
-- types
data ĻĢ : Set where
num : ĻĢ
<||> : ĻĢ
_==>_ : ĻĢ ā ĻĢ ā ĻĢ
-- expressions, prefixed with a Ā· to distinguish name clashes with agda
-- built-ins
data eĢ : Set where
_Ā·:_ : eĢ ā ĻĢ ā eĢ
X : Nat ā eĢ
Ā·Ī» : ... |
module Issue259b where
postulate
R : Set
T : R ā Set
I : Set
I = {x : R} ā T x -- The code type checks if this Ī is explicit.
data P : Set where
c : I ā P
data D : P ā Set where
c : (i : I) ā D (c i)
-- When pattern matching we do want to eta contract implicit lambdas.
Foo : (i : I) ā D (c i) ā Setā
Foo i (c... |
{-# OPTIONS --without-K --rewriting #-}
open import PathInduction
open import Pushout
module JamesContractibility {i} (A : Type i) (āA : A) where
open import JamesTwoMaps A āA public
-- We do not prove the flattening lemma here, we only prove that the following pushout is contractible
T : Type i
T = Pushout (span ... |
module FFI.Data.Scientific where
open import Agda.Builtin.Float using (Float)
open import FFI.Data.String using (String)
open import FFI.Data.HaskellString using (HaskellString; pack; unpack)
{-# FOREIGN GHC import qualified Data.Scientific #-}
{-# FOREIGN GHC import qualified Text.Show #-}
postulate Scientific : Se... |
{-
This file document and export the main primitives of Cubical Agda. It
also defines some basic derived operations (composition and filling).
-}
{-# OPTIONS --cubical --safe #-}
module Cubical.Core.Primitives where
open import Agda.Builtin.Cubical.Path public
open import Agda.Builtin.Cubical.Sub public
renaming (... |
module lambda.system-f where
open import Data.Nat
open import Data.Fin hiding (lift)
open import lambda.vec
open import lambda.untyped hiding (lift; subst; ā; substā)
infixr 22 _ā_
infix 20 ā'_
data type (n : ā) : Set where
var : Fin n ā type n
ā'_ : type (suc n) ā type n
_ā_ : type n ā type n ā type n
typeā ... |
open import TypeTheory.Nat.Mono.Structure
module TypeTheory.Nat.Mono.Properties (nat : Nat) where
open import Level renaming (zero to lzero; suc to lsuc)
open import Data.Empty using (ā„)
open import Data.Product using (Ī£; _Ć_; _,_)
open import Data.Sum
open import Relation.Binary using (Rel)
open import Relation.Bina... |
module _ where
infixr 5 _ā_
infixl 6 _ā»_
infix 3 _ā¢_ _ā_
infixr 5 vs_
infixr 4 Ę_
infixl 6 _Ā·_
data Type : Set where
Ī¹ : Type
_ā_ : Type ā Type ā Type
data Con : Set where
Īµ : Con
_ā»_ : Con ā Type ā Con
data _ā_ Ļ : Con ā Set where
vz : ā {Ī} ā Ļ ā Ī ā» Ļ
vs_ : ā {Ī Ļ} ā Ļ ā Ī ā Ļ ā Ī ā» Ļ
d... |
-- TODO: use StrictTotalOrder for QName representation
module Syntax (QName : Set) where
open import Data.Nat.Base
open import Data.Nat.Properties using (+-suc; +-identityŹ³)
open import Data.List.Base hiding (_ā·Ź³_)
open import Relation.Binary.PropositionalEquality using (_ā”_; refl; cong; sym; trans)
-- Well-scoped d... |
open import Data.Product using ( _Ć_ ; _,_ )
open import Web.Semantic.DL.ABox.Model using ( _āØa_ ; āØa-resp-ā² )
open import Web.Semantic.DL.ABox.Interp using ( Interp ; ā_ā )
open import Web.Semantic.DL.ABox.Interp.Morphism using ( _ā_ ; āā_ā ; ā-impl-ā² )
open import Web.Semantic.DL.KB using ( KB ; tbox ; abox )
open im... |
{-# OPTIONS --without-K #-}
{- The type of all types in some universe with a fixed truncation level
behaves almost like a universe itself. In this utility module, we develop
some notation for efficiently working with this pseudo-universe.
It will lead to considerably more briefer and more comprehensible proof... |
module plfa-code.Induction where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_ā”_; refl; cong; sym)
open Eq.ā”-Reasoning using (begin_; _ā”āØā©_)
open import Data.Nat using (ā; zero; suc; _+_; _*_; _āø_)
open import Function
open import plfa-code.Reasoning-legacy
_ : (3 + 4) + 5 ā” 3 + (4 + 5)
_ =
... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category where
open import Level
-- The main definitions are in:
open import Categories.Category.Core public
-- Convenience functions for working over mupliple categories at once:
-- C [ x , y ] (for x y objects of C) - Hom_C(x , y)
-- C [ f ā g ] (for f g arrows ... |
module UselessPrivatePrivate where
private
private
postulate
A : Set
|
module NoBindingForBuiltin where
foo = 42
|
{-# OPTIONS --universe-polymorphism #-}
module TrustMe-with-doubly-indexed-equality where
open import Common.Level
infix 4 _ā”_
data _ā”_ {a} {A : Set a} : A ā A ā Set a where
refl : ā {x} ā x ā” x
{-# BUILTIN EQUALITY _ā”_ #-}
{-# BUILTIN REFL refl #-}
sym : ā {a} {A : Set a} {x y : A} ā x ā” y ā y ā” x
sym ref... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Primality
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Nat.Primality where
open import Data.Empty using (ā„)
open import Data.Fin using... |
module TestNat where
import PreludeNatType
import AlonzoPrelude
import PreludeNat
import PreludeString
import PreludeShow
import RTP
import PreludeList
open AlonzoPrelude
open PreludeShow
open PreludeNatType
open PreludeString
open PreludeNat
open PreludeList hiding(_++_)
one = suc zero
two = suc one
lines : (List St... |
{-# OPTIONS --without-K --safe #-}
-- Multicategories but over an 'index' type, rather than forcing Fin n
module Categories.Multi.Category.Indexed where
open import Level
open import Data.Fin.Base using (Fin)
open import Data.Product using (Ī£; uncurry; curry; _Ć_; _,_; projā; projā)
open import Data.Product.Propertie... |
{-# OPTIONS --without-K #-}
open import HoTT
open import cohomology.FunctionOver
open import cohomology.FlipPushout
module cohomology.CofiberSequence {i} where
{- Lemma: pushing flip-susp through susp-fmap -}
āflip-susp-fmap : {X Y : Ptd i} (f : fst (X āā Y))
ā āflip-susp Y āā āsusp-fmap f == āsusp-fmap f āā āflip... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Functions.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _ā_)
open import LogicalFormulae
open import Setoids.Subset
open import Setoids.Setoids
open import Setoids.Orders.Partial.Definition
open import Fields.Fields
open import Rings.Ord... |
{-# OPTIONS --cubical-compatible --show-implicit #-}
-- {-# OPTIONS -v tc.lhs.split.well-formed:100 #-}
-- Andreas, adapted from Andres Sicard, 2013-05-29
module WithoutKRestrictive where
open import Common.Level
open import Common.Equality
open import Common.Product
data ā : Set where
zero : ā
suc : ā ā ā
data... |
-- Run this test case in safe mode
-- {-# OPTIONS --safe #-} -- does not parse (2012-03-12 Andreas)
module Issue586 where
Foo : Set1
Foo = Set
|
{-# OPTIONS --cubical --safe #-}
open import Prelude
open import Algebra
module Data.FingerTree {ā} (mon : Monoid ā) where
open Monoid mon
record Measured {a} (A : Type a) : Type (a āā ā) where
constructor measured
field Ī¼ : A ā š
open Measured ā¦ ... ā¦ public
data Digit {a} (A : Type a) : Type a where
Dā :... |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020 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.Base.PKCS
open import LibraB... |
{-# OPTIONS --universe-polymorphism #-}
open import Categories.Category
module Categories.Object.Products {o ā e} (C : Category o ā e) where
open Category C
open import Level
import Categories.Object.Terminal as Terminal
import Categories.Object.BinaryProducts as BinaryProducts
open Terminal C
open BinaryProducts... |
{-# OPTIONS --without-K #-}
module Relation.Path.Operation where
open import Basics
open import Relation.Equality
open import Data.Product
infixr 4 _ā_
infix 9 _ā»Ā¹
-- Path inversion
_ā»Ā¹ : ā {a}{A : Set a}{x y : A} ā (x ā” y) ā (y ā” x)
_ā»Ā¹ = indā (Ī» x y _ ā y ā” x) (Ī» _ ā refl) _ _
-- Composition of paths
_ā_ : ā {a}{... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- A solver for proving that one list is a sublist of the other for types
-- which enjoy decidable equalities.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe... |
open import Agda.Primitive
record R (a : Level) : Set (lsuc a) where
field
A : Set a
_ : ā a ā R {!a!} ā Set a
_ = Ī» _ ā R.A
|
{-# OPTIONS --cubical --no-import-sorts #-}
open import Agda.Primitive renaming (_ā_ to ā-max; lsuc to ā-suc; lzero to ā-zero)
module MoreNatProperties where
open import Cubical.Foundations.Everything renaming (_ā»Ā¹ to _ā»Ā¹įµ; assoc to ā-assoc)
open import Cubical.Data.Sigma.Base renaming (_Ć_ to infixr 4 _Ć_)
open im... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of operations on the Stream type
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --sized-types #-}
module Codata.Stream.Properties where
open ... |
------------------------------------------------------------------------------
-- Conversion rules for the division
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism... |
module Issue314 where
postulate A : Set
data _ā”_ (x : A) : A ā Set where
refl : x ā” x
postulate lemma : (x y : A) ā x ā” y
Foo : A ā Setā
Foo x with lemma x _
Foo x | refl = Set
-- Bug.agda:12,9-13
-- Failed to solve the following constraints:
-- x == _23 x : A
-- when checking that the pattern refl has type x... |
{-# OPTIONS --cubical --safe #-}
module Cubical.Data.List.Properties where
open import Agda.Builtin.List
open import Cubical.Core.Everything
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Prelude
open import Cubical.Data.Empty
open import Cubical.Data.Nat
open import Cubical.Data.Prod
open imp... |
module UnequalHiding where
data One : Set where one : One
f : ({A : Set} -> A -> A) -> One
f = \(id : (A : Set) -> A -> A) -> id One one
|
data _ā”_ {X : Set} : X ā X ā Set where
refl : {x : X} ā x ā” x
ap : {X Y : Set} (f : X ā Y) {x x' : X} ā x ā” x' ā f x ā” f x'
ap f refl = refl
_ā_ : {X : Set} {x y z : X} ā x ā” y ā y ā” z ā x ā” z
p ā refl = p
f : {X : Set} {x : X} {A : X ā Set} (Ī· Īø : (y : X) ā x ā” y ā A y)
ā Ī· x refl ā” Īø x refl ā ā y p ā Ī· y p ā” ... |
module Oscar.Data.Step {š£} (FunctionName : Set š£) where
open import Data.Nat using (ā; suc; zero)
open import Relation.Binary.PropositionalEquality using (_ā”_; refl; congā; cong; sym; trans)
open import Function using (_ā_; flip)
open import Relation.Nullary using (Ā¬_; Dec; yes; no)
open import Data.Product using (... |
{-# OPTIONS --cubical #-}
module Data.List.Permute where
open import Prelude
open import Data.Nat
open import Data.Nat.Properties using (_ā¤į“®_)
infixr 5 _ā¹_ā·_
data Premuted {a} (A : Type a) : Type a where
[] : Premuted A
_ā¹_ā·_ : ā ā A ā Premuted A ā Premuted A
mutual
merge : Premuted A ā Premuted A ā Premuted A
... |
module Categories.Monoidal.Closed where
|
module Issue755 where
open import Common.Prelude renaming (Nat to ā)
open import Common.Equality
abstract
foo : ā ā ā
foo x = zero
bar : foo zero ā” foo (suc zero) ā foo zero ā” foo (suc zero)
bar refl = refl
-- 0 != 1 of type ā
-- when checking that the pattern refl has type
-- foo zero ā” foo (suc zero)
|
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NType2
open import lib.types.Empty
open import lib.types.Sigma
open import lib.types.Pi
open import lib.types.Group
open import lib.types.Nat
open import lib.types.List
open import lib.types.Word
open import lib.types.SetQuotient
open impor... |
open import Data.Nat using (ā; _+_) renaming (_ā¤?_ to _ā¤?ā_)
open import Data.Bool using (Bool; not; _ā§_)
open import Data.String using (String; _ā_)
open import Relation.Nullary using (yes; no)
open import Relation.Nullary.Decidable using (ā_ā)
open import Relation.Binary.PropositionalEquality using ... |
{-
There was a bug when partially instantiating a module containing
record projections.
-}
module Issue438 where
module M (A : Set) where
record R (a : A) : Setā where
field
S : Set
postulate
X : Set
x : X
r : M.R X x
module MX = M X
postulate
T : MX.R.S r ā Set
y : M.R.S X r
t : T y
|
{-# OPTIONS --cubical --safe #-}
module Ctt where
open import Cubical.Core.Everything
open import Agda.Primitive.Cubical
using ( primComp )
-- Identity function.
id : ā {ā} {A : Set ā} (x : A) ā A
id x = x
-- Funciton composition.
_ā_ : ā {ā} {A B C : Type ā} (g : B ā C) (f : A ā B) ā A ā C
g ā f = Ī» a ā g (f a)
... |
module Monads.Identity where
open import Class.Functor
open import Class.Monad
open import Class.MonadTrans
open import Level
private
variable
a : Level
Id : Set a -> Set a
Id A = A
IdentityT : (Set a -> Set a) -> Set a -> Set a
IdentityT M A = M A
instance
Id-Monad : Monad (Id {a})
Id-Monad = record { _... |
------------------------------------------------------------------------
-- Untyped hereditary substitution in FĻ with interval kinds
------------------------------------------------------------------------
{-# OPTIONS --safe --exact-split --without-K #-}
module FOmegaInt.Syntax.SingleVariableSubstitution where
open... |
open import Data.Nat as ā using (ā; suc; zero)
open import Data.Pos as āāŗ using (āāŗ; suc; _+_)
open import Data.List as L using (List; []; _ā·_; _++_)
open import Data.List.Any as LA using (Any; here; there)
open import Data.Product using (_,_)
open import Data.Sum using (_ā_; injā; injā)
open import Relation.Binary.Pro... |
{-# OPTIONS --cubical --safe #-}
module Cardinality.Finite.ManifestBishop.Inductive where
open import Data.List public
open import Data.List.Membership public
open import Prelude
ā¬ : Type a ā Type a
ā¬ A = Ī£[ xs ā¦ List A ] Ī [ x ā¦ A ] x ā! xs
|
-- Families with compatible monoid and coal
module SOAS.Coalgebraic.Monoid {T : Set} where
open import SOAS.Common
open import SOAS.Context {T}
open import SOAS.Variable
open import SOAS.Families.Core {T}
import SOAS.Families.Delta {T} as Ī“; open Ī“.Sorted
open import SOAS.Abstract.Hom {T}
import SOAS.Abstract.Box {T}... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.Bouquet
open import homotopy.SphereEndomorphism
open import groups.SphereEndomorphism
open import groups.CoefficientExtensionality
open import cw.CW
open import cw.WedgeOfCells
module cw.DegreeByProjection {i} where
module DegreeAboveOne... |
module tests.Forcing where
open import Prelude.IO
open import Prelude.Unit
open import Prelude.Vec
open import Prelude.Nat
len : {A : Set}{n : Nat} -> Vec A n -> Nat
len {A} .{Z} [] = Z
len {A} .{S n} (_::_ {n} x xs) = S n
len2 : {A : Set}{n : Nat} -> Vec A n -> Nat
len2 [] = 0
len2 (_::_ {n} x xs) =... |
{-# COMPILE GHC myNat = 0 #-}
|
-- Free category over a directed graph/quiver
{-# OPTIONS --safe #-}
module Cubical.Categories.Constructions.Free where
open import Cubical.Categories.Category.Base
open import Cubical.Data.Graph.Base
open import Cubical.Data.Graph.Path
open import Cubical.Foundations.Prelude hiding (Path)
module _ {āv āe : Level} w... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- An All predicate for the partiality monad
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --guardedness #-}
module Category.Monad.Partiality.All where
op... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.FiniteMultiset where
open import Cubical.HITs.FiniteMultiset.Base public
open import Cubical.HITs.FiniteMultiset.Properties public
|
open import Data.Nat using ( zero ; suc ) renaming ( ā to āā ; _+_ to add )
open import Function using () renaming ( _āā²_ to _ā_ )
open import Relation.Binary.PropositionalEquality using ( _ā”_ ; refl ; sym ; trans ; cong ; congā )
open import AssocFree.Util using ( ā”-relevant )
module AssocFree.DNat where
open Relat... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
-- a zero object is both terminal and initial.
module Categories.Object.Zero {o ā e} (C : Category o ā e) where
open import Level
open import Categories.Object.Terminal C
open import Categories.Object.Initial C
open import Categories.Morphism C
ope... |
module Issue279-2 where
data ā„ : Set where
data ā¤ : Set where
tt : ā¤
module M (A : Set) where
data P : ā¤ ā Set where
tt : A ā P tt
module X = M ā„ using (tt)
open X
good : ā„ ā M.P ā„ tt
good = tt
bad : M.P ā¤ tt
bad = tt tt
|
abstract
data D : Set where
d : D
data P : D ā Set where
p : P d
dā² : D
dā² = d
dā : D
dā = d
private
abstract
pā² : P d
pā² = p
A : P dā²
A = pā²
-- A : Setā -- P dā²
-- A = Set -- pā²
-- where
-- abstract
-- pā² : P d
-- pā² = p
|
{-# OPTIONS --rewriting #-}
open import Library
-- Focusing proofs
-- parametrized by positive and negative atoms
-- module Formulas (PosAt NegAt : Set) where
-- module Formulas (Atoms : Set) where
postulate Atoms : Set
-- Polarity + (positive formulas) are those whose introduction requires
data Pol : Set where
... |
postulate
X : Set
T : X ā Set
H : ā x ā T x ā Set
g : ā x ā T x ā Set
g x t = ā x ā H x t
|
-- Copyright: (c) 2016 Ertugrul Sƶylemez
-- License: BSD3
-- Maintainer: Ertugrul Sƶylemez <esz@posteo.de>
module Data.Fin where
open import Data.Fin.Core public
using (Fin; Fin-Number; fsuc; fzero)
|
------------------------------------------------------------------------------
-- Conversion rules for the recursive operator rec
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-univers... |
------------------------------------------------------------------------
-- Functional semantics for an untyped Ī»-calculus with constants
------------------------------------------------------------------------
{-# OPTIONS --no-termination-check #-}
module Lambda.Closure.Functional.No-workarounds where
open import C... |
{-# OPTIONS --allow-unsolved-metas #-}
postulate
A : Set
R : A ā Set
M : (a : A) (s t : R a) ā Set
variable
a : A
s : R a
t : _
postulate
m : M _ s t
t = _
|
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Groups.Abelian.Definition
open import Groups.Definition
open import Groups.Lemmas
open import Rings.Definition
open import Setoids.Setoids
open import Sets.EquivalenceRelations
open import Numbers.Naturals.Semiring
open import N... |
module TelescopingLet5 where
postulate
A : Set
a : A
module B (a : A) where
postulate
C : Set
-- B.C : (a : A) ā Set
module N = B a
module M' (open N) (c : C) where
postulate cc : C
-- M.cc : (a : B.A a) ā B.A a
E = let open B a in C
module M (open B a) (x : A) where
D = C
postulate cc : C
-- M.c... |
{-# OPTIONS --termination-depth=2 #-}
module TerminationWithTwoConstructors where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
f : Nat -> Nat
f zero = zero
f (suc zero) = zero
f (suc (suc n)) with zero
... | m = f (suc n)
{- internal represenation
f : Nat -> Nat
f zero = zero
f (suc zero) = zero
f (suc (s... |
------------------------------------------------------------------------------
-- Testing the erasing of proof terms
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphis... |
-- Andreas, 2016-08-04, issue #964
-- Allow open metas and interaction points in imported files
-- {-# OPTIONS -v import:100 #-}
-- {-# OPTIONS -v meta.postulate:20 #-}
-- {-# OPTIONS -v tc.conv.level:50 #-}
open import Common.Level
open import Common.Equality
postulate something : Setā
open import Common.Issue964.... |
module Sets.PredicateSet.Relations{āā}{āā} where
import Lvl
open import Functional
open import Logic.Propositional{āā Lvl.ā āā}
open import Logic.Predicate{āā}{āā}
open import Numeral.Finite
open import Numeral.Natural
import Relator.Equals
open import Sets.PredicateSet
open import Structure.Function.Domain
... |
{-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.IdPi {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped as U hiding (wk)
open import Definition.Untyped.Properties
open import Definition.Typed
open import De... |
open import MJ.Types
import MJ.Classtable.Core as Core
import MJ.Classtable.Code as Code
import MJ.Syntax as Syntax
import MJ.Semantics.Values as Values
module MJ.Semantics {c}(Ct : Core.Classtable c)(ā : Code.Code Ct) where
-- functional big-step definitional interpreter
-- open import MJ.Semantics.Functional Ī£ ā
o... |
open import Data.Product using ( _,_ )
open import Relation.Nullary using ( yes ; no )
open import Relation.Unary using ( _ā_ )
open import Web.Semantic.DL.ABox.Interp using
( Interp ; _,_ ; ā_ā ; ind ; indĀ² ; Surjective ; surj ; indā»Ā¹ ; surjā )
open import Web.Semantic.DL.ABox.Interp.Morphism using ( _ā²_ ; _,_ ; ā²ā... |
{-# OPTIONS --cubical --no-import-sorts #-}
module MorePropAlgebra.Structures where
open import Agda.Primitive renaming (_ā_ to ā-max; lsuc to ā-suc; lzero to ā-zero)
private
variable
ā ā' ā'' : Level
open import Cubical.Foundations.Everything renaming (_ā»Ā¹ to _ā»Ā¹įµ; assoc to ā-assoc)
open import Cubical.Rela... |
-- Occurs there are several ways to parse an operator application.
module AmbiguousParseForApplication where
postulate
X : Set
if_then_else_ : X -> X -> X -> X
if_then_ : X -> X -> X
bad : X -> X
bad x = if x then if x then x else x
|
module SafeFlagPrimTrustMe-2 where
open import Agda.Builtin.TrustMe
|
-- Andreas, 2015-09-09 Issue 1643
-- {-# OPTIONS -v tc.mod.apply:20 #-}
-- {-# OPTIONS -v scope:50 -v scope.inverse:100 -v interactive.meta:20 #-}
module _ where
module M where
postulate A : Set
module N = M -- This alias used to introduce a display form M.A --> N.A
open M
postulate
a : A
test : Set
test = a... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.OrderedCommMonoid where
open import Cubical.Algebra.OrderedCommMonoid.Base public
open import Cubical.Algebra.OrderedCommMonoid.Properties public
|
------------------------------------------------------------------------------
-- Properties for the equality on streams
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymor... |
{- Adjunction between suspension and loop space (Rongji Kang, Oct. 2021)
Main results:
- Ī©ā : ā ā Pointed ā ā Pointed ā
- Ī£Ī©Adjunction : ((X , xā) : Pointed ā) (Y : Pointed ā') ā (āSusp X āā Y) ā ((X , xā) āā Ī©ā 1 Y)
-}
{-# OPTIONS --safe #-}
module Cubical.HITs.Susp.LoopAdjunction where
open import Cubical.Foundati... |
module Prelude.Fractional where
open import Agda.Primitive
record Fractional {a} (A : Set a) : Set (lsuc a) where
infixl 7 _/_
field
Constraint : A ā A ā Set a
_/_ : (x y : A) {{_ : Constraint x y}} ā A
NoConstraint : Set a
NoConstraint = ā {x y} ā Constraint x y
open Fractional {{...}} using (_/_)... |
{-# OPTIONS --guardedness --without-K #-}
module ky where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_ā”_; _ā¢_; refl; cong; congā; sym)
open Eq.ā”-Reasoning using (begin_; _ā”āØā©_; _ā”āØ_ā©_; _ā)
open import Data.Rational using (ā; _+_; _*_; _-_)
open import Data.Bool
open import Data.Bool.Properties... |
open import Agda.Builtin.Coinduction
open import Agda.Builtin.IO
open import Agda.Builtin.Unit
data D : Set where
c : ā D ā D
d : D
d = c (āÆ d)
postulate
seq : {A B : Set} ā A ā B ā B
return : {A : Set} ā A ā IO A
{-# COMPILE GHC return = \_ -> return #-}
{-# COMPILE GHC seq = \_ _ -> seq #-}
main... |
module Common.Char where
open import Agda.Builtin.Char public
open import Common.Bool
charEq : Char -> Char -> Bool
charEq = primCharEquality
|
module Data.List.Iterable where
open import Data
open import Data.List
import Data.List.Functions as List
open import Logic.Propositional
open import Logic.Predicate
import Lvl
open import Relator.Equals
open import Structure.Container.Iterable
open import Type
private variable ā : Lvl.Level
private variabl... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.S2 where
open import Cubical.HITs.S2.Base public
-- open import Cubical.HITs.S2.Properties public
|
module FRP.JS.Size where
postulate
Size : Set
ā_ : Size ā Size
ā : Size
{-# BUILTIN SIZE Size #-}
{-# BUILTIN SIZESUC ā_ #-}
{-# BUILTIN SIZEINF ā #-}
{-# COMPILED_JS ā_ function(x) { return null; } #-}
{-# COMPILED_JS ā null #-}
|
{-# OPTIONS --universe-polymorphism #-}
module Categories.Monad.Kleisli where
open import Categories.Category
open import Categories.Functor using (Functor; module Functor)
open import Categories.NaturalTransformation hiding (_ā”_; equiv; id)
open import Categories.Monad
Kleisli : ā {o ā e} {C : Category o ā e} ā Mona... |
module Issue533 where
data Empty : Set where
empty : {A B : Set} ā (B ā Empty) ā B ā A
empty f x with f x
... | ()
fail : ā {A : Set} ā Empty ā A
fail {A} = empty absurd
where
absurd : _ ā Empty
absurd ()
-- should check (due to postponed emptyness constraint, see issue 479)
|
open import Agda.Builtin.Nat
data S : Set where
c : S
module _ (A : Set) where
test : S
test with c
... | q = {!q!} -- Splitting on q should succeed
data Vec (A : Set) : Nat ā Set where
[] : Vec A zero
_ā·_ : ā {n} ā A ā Vec A n ā Vec A (suc n)
module _ {A : Set} {n : Nat} (xs : Vec A n) where
foo :... |
data {-sdaf-} Nat {-sdaf-} : {-sdaf-} Set {-sdaf-} where {-sdaf-}
zero {-sdaf-} : {-sdaf-} Nat {-sdaf-}
suc {-sdaf-} :{-sdaf-} Nat {-sdaf-} -> {-sdaf-} Nat {-sdaf-}
data Impossible : Set where {-Comment which should not be duplicated-}
|
------------------------------------------------------------------------
-- Canonical kinding of FĻ with interval kinds
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module FOmegaInt.Kinding.Canonical where
open import Data.Context.WellFormed
open import ... |
------------------------------------------------------------------------------
-- The the power function
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OP... |
module List.Permutation.Base.Concatenation (A : Set) where
open import List.Permutation.Base A
open import List.Permutation.Base.Equivalence A
open import List.Permutation.Base.Preorder A
open import Data.List
open import Data.Product
open import Relation.Binary.PreorderReasoning ā¼-preorder
open import Algebra
open im... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.