text stringlengths 4 690k |
|---|
{-# OPTIONS --without-K #-}
module ConcretePermutation where
import Level using (zero)
open import Data.Nat using (ā; _+_; _*_)
open import Data.Fin using (Fin)
open import Data.Product using (projā; projā)
open import Data.Vec using (tabulate)
open import Algebra using (CommutativeSemiring)
open import Algebra.Str... |
{-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
open import Light.Library.Data.Natural as ā using (ā)
open import Light.Package using (Package)
module Light.Literals.Natural ā¦ package : Package record { ā } ā¦ where
open import Light.Literals.Definition.Natural using (FromNatural)
open... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Decorated star-lists
------------------------------------------------------------------------
{-# OPTIONS --with-K --safe #-}
module Data.Star.Decoration where
open import Data.Unit
open import Function
open i... |
module Category.Fibration where
open import Data.Product
open import Category.Category
open import Category.Subcategory
open import Category.Funct
|
-- 2010-10-04
-- termination checker no longer counts stripping off a record constructor
-- as decrease
module Issue334 where
data Unit : Set where
unit : Unit
record E : Set where
inductive
constructor mkE
field
fromE : E
spam : Unit
f : E -> Set
f (mkE e unit) = f e
-- the record pattern translati... |
open import Relation.Binary.PropositionalEquality
open import Data.Unit using (ā¤ ; tt)
open import Data.Product renaming (_Ć_ to _ā§_ ; projā to fst ; projā to snd)
open import Data.Sum renaming (_ā_ to _āØ_ ; injā to left ; injā to right)
open import Data.Nat using (ā ; zero ; suc)
open import Data.Product renaming (pro... |
record R : Setā where
X = Y -- should get error here
field A : Set
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Simple combinators working solely on and with functions
------------------------------------------------------------------------
-- The contents of this file can be accessed from `Function`.
{-# OPTIONS --witho... |
open import Relation.Binary.Core
module PLRTree.Insert {A : Set}
(_ā¤_ : A ā A ā Set)
(totā¤ : Total _ā¤_) where
open import Data.Sum
open import PLRTree {A}
insert : A ā PLRTree ā PLRTree
insert x leaf = node perfect x leaf leaf
insert x (node perfect y l r)
with totā¤ x... |
open import Common.Prelude
open import Common.Equality
infixr 5 _ā·_
data Vec (A : Set) : Nat ā Set where
[] : Vec A zero
_ā·_ : ā {n} ā A ā Vec A n ā Vec A (suc n)
record Eq (A : Set) : Set where
field
_==_ : (x y : A) ā Maybe (x ā” y)
open Eq {{...}}
data Ī£ (A : Set) (B : A ā Set) : Set where
_,_ : (x ... |
-- Quotient category
{-# OPTIONS --safe #-}
module Cubical.Categories.Constructions.Quotient where
open import Cubical.Categories.Category.Base
open import Cubical.Categories.Functor.Base
open import Cubical.Categories.Limits.Terminal
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Prelude
ope... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Foundations.Pointed.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed.Base
open import Cubical.Foundations.Function
open import Cubical.Foundations.GroupoidLaws
open import Cubical.Foundations.Isomorphism
... |
{-# OPTIONS --safe #-}
module Definition.Typed.EqRelInstance where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.Weakening
open import Definition.Typed.Properties
open import Definition.Typed.Reduction
open import Definition.Typed.Equa... |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020, 2021, Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.Abstract.Types
open import LibraBFT.Abstract.Types... |
module Data.List.First.Properties {ā}{A : Set ā} where
open import Data.Product
open import Data.List
open import Data.List.Any
open import Relation.Binary.PropositionalEquality
open import Function
open import Data.Empty
open import Data.List.First
open import Data.List.Membership.Propositional
firstā¶ā : ā {B : A ā ... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Category.Construction.Spans {o ā e} (š : Category o ā e) where
open import Level
open import Categories.Category.Diagram.Span š
open import Categories.Morphism.Reasoning š
open Category š
open HomReasoning
open Equiv
open Spa... |
{- Definition of join for ā and associated lemmas. -}
module TemporalOps.Diamond.JoinLemmas where
open import CategoryTheory.Categories
open import CategoryTheory.Instances.Reactive
open import CategoryTheory.Functor
open import CategoryTheory.NatTrans
open import CategoryTheory.Monad
open import TemporalOps.Common
o... |
{-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Subtyping where
open import Light.Level using (_ā_ ; ++_)
open import Light.Variable.Levels
open import Light.Variable.Sets
record DirectSubtyping (š : Set aā) (š : Set bā) : Set (aā ā bā) where
constructor #_
... |
module Issue561 where
open import Common.Char
open import Common.Prelude
primitive
primIsDigit : Char ā Bool
postulate
IO : Set ā Set
return : ā {A} ā A ā IO A
{-# BUILTIN IO IO #-}
main : IO Bool
main = return true |
{-# OPTIONS --without-K #-}
module library.types.Types where
open import library.Basics
open import library.types.Empty public
open import library.types.Unit public
open import library.types.Bool public
open import library.types.Nat public
open import library.types.Int public
open import library.types.TLevel public
o... |
record Unit : Set where
constructor tt
postulate
C : Set
c : C
g : C
f : Unit ā C
f tt = c
record R : Set where
constructor r
g = c
|
-- A variant of code reported by Andreas Abel (who suggested that this
-- way to trigger the bug might have been due to NAD).
{-# OPTIONS --guardedness --sized-types #-}
open import Agda.Builtin.Sigma
open import Agda.Builtin.Size
data ā„ : Set where
record Delay (A : Set) : Set where
coinductive
constructor āÆ
... |
test = forall _let_ ā Set
|
module SystemF.BigStep.Types where
open import Prelude
-- types are indexed by the number of open tvars
infixl 10 _ā_
data Type (n : ā) : Set where
Unit : Type n
Ī½ : (i : Fin n) ā Type n
_ā_ : Type n ā Type n ā Type n
ā' : Type (suc n) ā Type n
open import Data.Fin.Substitution
open import Data.Vec
mo... |
record R (A : Set) : Set where
constructor cā
field
f : A ā A
open module Rā² (A : Set) (r : R A) = R {A = A} r
renaming (f to fā²)
_ : (@0 A : Set) ā R A ā A ā A
_ = Ī» A ā fā² {A = A}
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Magma.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Algebra
open import Cubical.Algebra.Magma.Morphism
open import Cubical.Algebra.Magma... |
module Numeral.Natural.Oper.Summation.Range where
import Lvl
open import Data.List
open import Data.List.Functions
open import Numeral.Natural
open import Type
_ā„_ : ā ā ā ā List(ā)
_ ā„ š = ā
š ā„ š b = š ā° map š(š ā„ b)
š a ā„ š b = map š(a ā„ b)
ā„_ : ā ā List(ā)
ā„ b = š ā„ b
_ā„ā_ : ā ā ā ā List(ā)... |
{-# OPTIONS --without-K --safe #-}
module Dodo.Unary.Equality where
-- Stdlib imports
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_ā”_; refl)
open import Level using (Level; _ā_)
open import Function using (_ā_)
open import Relation.Unary using (Pred)
-- # Definitions
infix 4 _āā'_ _āā_ _āā_
... |
{-# OPTIONS --cubical --safe --postfix-projections #-}
module Data.Bool.Properties where
open import Prelude
open import Data.Bool
open import Data.Unit.Properties
T? : ā x ā Dec (T x)
T? x .does = x
T? false .why = ofāæ id
T? true .why = ofŹø tt
isPropT : ā x ā isProp (T x)
isPropT false = isPropā„
isPropT true = i... |
{-# OPTIONS --without-K #-}
module P where
open import Data.Empty
open import Data.Unit
open import Data.Sum
open import Data.Product
open import Relation.Binary.PropositionalEquality
------------------------------------------------------------------------------
-- For now, a groupoid is just a set
G... |
-- Basic intuitionistic logic of proofs, without āØ, ā„, or +.
-- Gentzen-style formalisation of syntax with context pairs.
-- Normal forms and neutrals.
module BasicILP.Syntax.DyadicGentzenNormalForm where
open import BasicILP.Syntax.DyadicGentzen public
-- Derivations.
mutual
-- Normal forms, or introductions.
... |
module EquationalTheory where
open import Library
open import Syntax
open import RenamingAndSubstitution
-- Single collapsing substitution.
sub1 : ā{Ī Ļ Ļ} ā Tm Ī Ļ ā Tm (Ī , Ļ) Ļ ā Tm Ī Ļ
sub1 {Ī}{Ļ}{Ļ} u t = sub (subId , u) t
-- Typed Ī²-Ī·-equality.
data _ā”Ī²Ī·_ {Ī : Cxt} : ā{Ļ} ā Tm Ī Ļ ā Tm Ī Ļ ā Set where
-- ... |
open import Relation.Binary.Core
module InsertSort.Impl2.Correctness.Order {A : Set}
(_ā¤_ : A ā A ā Set)
(totā¤ : Total _ā¤_) where
open import Data.List
open import Function using (_ā_)
open import InsertSort.Impl2 _ā¤_ totā¤
open import List.Sorted _ā¤_
open import OList _ā¤_
open imp... |
{-# OPTIONS --prop #-}
open import Agda.Builtin.Nat
data T : Nat ā Prop where
To : T zero
Tn : ā n ā T n
ummm : ā n ā T n ā {! !}
ummm n t = {! t !}
|
-- A variant of code reported by Andreas Abel.
{-# OPTIONS --guardedness --sized-types #-}
open import Common.Coinduction renaming (ā to Delay)
open import Common.Size
open import Common.Product
data ā„ : Set where
record Stream (A : Set) : Set where
inductive
constructor delay
field
force : Delay (A Ć Str... |
open import Oscar.Prelude
open import Oscar.Class
open import Oscar.Class.IsPrecategory
open import Oscar.Class.IsCategory
open import Oscar.Class.HasEquivalence
open import Oscar.Class.Reflexivity
open import Oscar.Class.Symmetry
open import Oscar.Class.Transextensionality
open import Oscar.Class.Transassociativity
o... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Floats
------------------------------------------------------------------------
module Data.Float where
open import Data.Bool hiding (_ā_)
open import Relation.Nullary.Decidable
open import Relation.Nullary
ope... |
module Issue2447.Type-error where
import Issue2447.M
Rejected : Set
Rejected = Set
|
{-# OPTIONS --safe --warning=error --without-K #-}
open import Groups.Homomorphisms.Definition
open import Groups.Definition
open import Setoids.Setoids
open import Rings.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _ā_)
module Rings.Homomorphisms.Definition where
record RingHom {m n o p : _} {A... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Relation.Binary.Base where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundat... |
module Thesis.SIRelBigStep.Types where
open import Data.Empty
open import Data.Product
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
open import Relation.Binary hiding (_ā_)
data Type : Set where
_ā_ : (Ļ Ļ : Type) ā Type
pair : (Ļ Ļ : Type) ā Type
nat : Type
infixr 20 _ā_
open... |
module MLib.Prelude where
open import MLib.Prelude.FromStdlib public
module Fin where
open import MLib.Prelude.Fin public
open Fin using (Fin; zero; suc) hiding (module Fin) public
|
open import Agda.Builtin.Nat
data Vec (A : Set) : Nat ā Set where
[] : Vec A 0
_ā·_ : ā {n} ā A ā Vec A n ā Vec A (suc n)
infixr 5 _ā·_ _++_
_++_ : ā {A m n} ā Vec A m ā Vec A n ā Vec A (m + n)
[] ++ ys = ys
(x ā· xs) ++ ys = x ā· xs ++ ys
T : ā {A n} ā Vec A n ā Set
T [] = Nat
T (x ā· xs) = Vec Nat 0
foo : ... |
module HelloWorld where
open import Common.IO
open import Common.Unit
main : IO Unit
main = putStr "Hello World"
|
open import Agda.Builtin.Equality
data D (A : Set) : Set where
{-# INJECTIVE D #-}
test : {Aā Aā : Set} ā D Aā ā” D Aā ā Aā ā” Aā
test refl = refl
postulate f : Set ā Set
{-# INJECTIVE f #-}
testā : {Aā Aā : Set} ā f Aā ā” f Aā ā Aā ā” Aā
testā refl = refl
|
module Avionics.Bool where
open import Data.Bool using (Bool; true; false; _ā§_; T)
open import Data.Unit using (ā¤; tt)
open import Data.Product using (_Ć_; _,_)
open import Relation.Binary.PropositionalEquality using (_ā”_; refl; inspect; [_])
--open import Avionics.Product using (_Ć_; āØ_,_ā©)
--TODO: Replace with Tāā”... |
{-# OPTIONS --universe-polymorphism #-}
open import Level
open import Categories.Category
module Categories.Power.Functorial {o ā e : Level} (C : Category o ā e) where
open import Relation.Binary.PropositionalEquality using (ā”-irrelevance)
open import Data.Unit using (ā¤; tt)
open import Function using () renaming (_ā_... |
{-# OPTIONS --without-K --exact-split --allow-unsolved-metas #-}
module 16-sets where
import 15-number-theory
open 15-number-theory public
|
module examplesPaperJFP.ConsoleInterface where
open import examplesPaperJFP.NativeIOSafe
open import examplesPaperJFP.BasicIO hiding (main)
module _ where
data ConsoleCommand : Set where
getLine : ConsoleCommand
putStrLn : String ā ConsoleCommand
ConsoleResponse : ConsoleCommand ā Set
ConsoleRespo... |
------------------------------------------------------------------------
-- A variant of the set quotients from Quotient
------------------------------------------------------------------------
{-# OPTIONS --erased-cubical --safe #-}
-- Partly following the HoTT book.
--
-- Unlike the HoTT book, but following the cub... |
module List.Sorted {A : Set}(_ā¤_ : A ā A ā Set) where
open import Data.List
data Sorted : List A ā Set where
nils : Sorted []
singls : (x : A)
ā Sorted [ x ]
conss : {x y : A}{xs : List A}
ā x ā¤ y
ā Sorted (y ā· xs)
ā Sorted (x ā· y... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.TypeQuotients where
open import Cubical.HITs.TypeQuotients.Base public
open import Cubical.HITs.TypeQuotients.Properties public
|
{-
Descriptor language for easily defining structures
-}
{-# OPTIONS --cubical --no-import-sorts --no-exact-split --safe #-}
module Cubical.Structures.Macro where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.E... |
------------------------------------------------------------------------
-- Lists where all elements satisfy a given property
------------------------------------------------------------------------
module Data.List.All where
open import Data.Function
open import Data.List as List hiding (map; all)
open import Data.L... |
open import Agda.Builtin.List
open import Agda.Builtin.Reflection renaming (bindTC to _>>=_)
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
open import Agda.Builtin.Nat
open import Agda.Builtin.Sigma
data Unit : Set where
unit : Unit
data Empty : Set where
qq : ā {a} {A : Set a} ā A ā Term ā TC _... |
module API.Theorems where
open import Algebra
open import Algebra.Theorems
open import API
open import Prelude
open import Reasoning
-- vertices [x] == vertex x
vertices-vertex : ā {A} {x : A} -> vertices [ x ] ā” vertex x
vertices-vertex = +identity >> reflexivity
-- edge x y == clique [x, y]
edge-cliqu... |
module LC.Reduction where
open import LC.Base
open import LC.Subst
open import Data.Nat
open import Data.Nat.Properties
open import Relation.Nullary
-- Ī²-reduction
infix 3 _Ī²ā_
data _Ī²ā_ : Term ā Term ā Set where
Ī²-Ę-ā : ā {M N} ā ((Ę M) ā N) Ī²ā (M [ N ])
Ī²-Ę : ā {M N} ā M Ī²ā N ā Ę M Ī²ā Ę N
Ī²-ā-l : ā ... |
-- Copyright: (c) 2016 Ertugrul Sƶylemez
-- License: BSD3
-- Maintainer: Ertugrul Sƶylemez <esz@posteo.de>
--
-- This module contains definitions that are fundamental and/or used
-- everywhere.
module Core where
open import Agda.Builtin.Equality public
renaming (refl to ā”-refl)
using (_ā”_)
open import Agda.Bu... |
module Oscar.Data.Term.AlphaConversion.internal {š£} (FunctionName : Set š£) where
open import Oscar.Data.Term FunctionName
open import Oscar.Data.Equality
open import Oscar.Data.Fin
open import Oscar.Data.Vec
open import Oscar.Function
open import Oscar.Relation
infixr 19 _ā_ _ās_
mutual
_ā_ : ā {m n} ā m āØ Fi... |
{-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Definition
module Numbers.Naturals.Addition where
infix 15 _+N_
_+N_ : ā ā ā ā ā
zero +N y = y
succ x +N y = succ (x +N y)
{-# BUILTIN NATPLUS _+N_ #-}
addZeroRight : (x : ā) ā (x +N zero) ā” x
addZeroRight ze... |
module ProcessSyntax where
open import Data.List
open import Typing
open import Syntax
-- processes
data Proc (Ī¦ : TCtx) : Set where
exp : (e : Expr Ī¦ TUnit)
ā Proc Ī¦
par : ā {Ī¦ā Ī¦ā}
ā (sp : Split Ī¦ Ī¦ā Ī¦ā)
ā (Pā : Proc Ī¦ā)
ā (Pā : Proc Ī¦ā)
ā Proc Ī¦
res : (s : SType)
ā (P : Proc (TChan... |
------------------------------------------------------------------------------
-- Distributive laws on a binary operation: Task B
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-univers... |
module Sandbox.IndRec where
-- Ornamental Algebras, Algebraic Ornaments, CONOR McBRIDE
-- https://personal.cis.strath.ac.uk/conor.mcbride/pub/OAAO/Ornament.pdf
-- A Finite Axiomtization of Inductive-Recursion definitions, Peter Dybjer, Anton Setzer
-- http://www.cse.chalmers.se/~peterd/papers/Finite_IR.pdf
open import... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Finite where
open import Level
open import Data.Nat using (ā)
open import Data.Fin
open import Categories.Adjoint.Equivalence
open import Categories.Category
open import Categories.Functor
open import Categories.Category.Finite.Fin
-- definition of a fin... |
module Generic.Lib.Data.Maybe where
open import Data.Maybe.Base using (Maybe; just; nothing; maybe; maybeā²; from-just; fromMaybe) public
open import Generic.Lib.Intro
open import Generic.Lib.Category
infixr 0 _?>_
instance
MaybeMonad : ā {Ī±} -> RawMonad {Ī±} Maybe
MaybeMonad = record
{ return = just
; _>... |
open import Type
module Relator.Sets {ā āā āā} {E : Type{āā}} {S : Type{āā}} (_ā_ : E ā S ā Type{ā}) where
open import Functional
open import Logic.Propositional
open import Logic.Predicate
_ā_ : E ā S ā Type
_ā_ = (Ā¬_) āā (_ā_)
_ā_ : S ā E ā Type
_ā_ = swap(_ā_)
_ā_ : S ā E ā Type
_ā_ = (Ā¬_) āā (_ā_)
_ā_ : S ā S... |
module Issue804 where
mutual
{-# NO_TERMINATION_CHECK #-}
Foo : Set
Foo = Foo
-- WAS: The pragma above doesn't apply to Foo. An informative error message
-- could be helpful.
-- NOW: The pragma does apply to Foo.
|
------------------------------------------------------------------------
-- A type used to index a combined definition of strong and weak
-- bisimilarity and expansion
------------------------------------------------------------------------
{-# OPTIONS --safe #-}
module Delay-monad.Bisimilarity.Kind where
open impor... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.CommRing.BinomialThm where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Data.Nat renaming ( _+_ to _+ā_ ; _Ā·_ to _Ā·ā_ ; _^_ to _^ā_
; +-comm to +... |
postulate
Bool : Set
D : Bool ā Set
f : (a : Bool) ā D a
ā¦_ā§ : ā {a} ā D a ā Bool
record State : Set where
field bool : Bool
open State {{...}}
postulate
guard : {S : Set} ā ({{_ : S}} ā Bool) ā S
test : State
test = guard ā¦ f bool ā§ -- doesn't work, used to work in agda 2.4
|
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Unbundled where
-- This is basically identical to Category, except that the
-- Obj type is a parameter rather than a field.
open import Level
open import Function.Base using (flip)
open import Relation.Binary using (Rel; IsEquivalence)
record Category {o... |
open import Agda.Builtin.Unit
open import Agda.Builtin.Sigma
open import Agda.Builtin.List
open import Agda.Builtin.Equality
open import Agda.Builtin.Reflection renaming (bindTC to infixl 4 _>>=_)
macro
quoteDef : Name ā Term ā TC ā¤
quoteDef f hole = (getDefinition f >>= quoteTC) >>= unify hole
postulate
A : S... |
-- Andreas, 2012-09-17 documenting an internal error in InternalToAbstract.hs
-- {-# OPTIONS -v syntax.reify.con:30 -v tc.with.type:30 #-}
module NameFirstIfHidden where
Total : (D : (A : Set) ā A ā Set)(A : Set) ā Set
Total D A = forall a ā D A a
data D (A : Set) : (a : A) ā Set where
c : Total D A
postulate P : ... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Groups.Definition
open import Setoids.Setoids
open import Sets.EquivalenceRelations
open import Groups.Homomorphisms.Definition
open import Groups.Homomorphisms.Lemmas
open import Groups.Subgroups.Definition
open import Groups.Subgroups.Normal.Definition
o... |
open import Categories
open import Functors
open import RMonads
module RMonads.CatofRAdj {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 RAdjunctions
open Fun
open Cat
record ObjAdj {e f} : Set ((a ā b ā c ā d ā lsuc e ā lsuc f))... |
{-# OPTIONS --universe-polymorphism #-}
open import Categories.Category
module Categories.Functor.Core where
open import Level
open import Categories.Support.EqReasoning
record Functor {o ā e oā² āā² eā²} (C : Category o ā e) (D : Category oā² āā² eā²) : Set (o ā ā ā e ā oā² ā āā² ā eā²) where
eta-equality
private modul... |
module FunClause where
f
: {A : Set}
ā A
ā A
f x
= y
where
y = x
z = x
data List
(A : Set)
: Set
where
nil
: List A
cons
: A
ā List A
ā List A
snoc
: {A : Set}
ā List A
ā A
ā List A
snoc nil y
= cons y nil
snoc (cons x xs) y
= cons x (snoc xs y)
|
------------------------------------------------------------------------
-- Brandt and Henglein's subterm relation
------------------------------------------------------------------------
module RecursiveTypes.Subterm where
open import Algebra
open import Data.Fin using (Fin; zero; suc; lift)
open import Data.Nat
ope... |
-- {-# OPTIONS -v reify:80 #-}
open import Common.Prelude
open import Common.Reflection
open import Common.Equality
module Issue1345 (A : Set) where
unquoteDecl idNat = define (vArg idNat)
(funDef (pi (vArg (def (quote Nat) [])) (abs "" (def (quote Nat) [])))
(clause (vArg (var "") ā· []) (var 0 []) ā· [])... |
------------------------------------------------------------------------------
-- Testing the erasing of the duplicate definitions required by a conjecture
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-... |
{-# OPTIONS --cubical --safe --postfix-projections #-}
module Cardinality.Infinite.ManifestEnumerable where
open import Prelude
open import Data.List.Kleene
open import Data.Fin
import Data.Nat as ā
open import Data.Nat using (_+_)
open import Cubical.Data.Sigma.Properties
open import Cubical.Foundations.Prelude usin... |
{-# OPTIONS --rewriting #-}
open import Agda.Primitive
open import Agda.Builtin.Equality
open import Agda.Builtin.Equality.Rewrite
variable
ā ā' : Level
A : Set ā
B : Set ā'
x y z : A
sym : x ā” y ā y ā” x
sym refl = refl
_ā_ : x ā” y ā y ā” z ā x ā” z
refl ā refl = refl
leftId : (p : x ā” y) ā refl ā p ā” p
left... |
----------------------------------------------------------------------------
-- Well-founded induction on the relation _ā_
----------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymor... |
{-# OPTIONS --no-qualified-instances #-}
module NoQualifiedInstances-ParameterizedImport where
postulate
T : Set
open import NoQualifiedInstances.ParameterizedImport.A T as A
postulate
f : {{A.I}} ā A.I
test : A.I
test = f
|
{- 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
-}
module LibraBFT.ImplShared.Util.Dijkstra.All where
open import Dijkstra... |
{-# OPTIONS --allow-unsolved-metas #-}
module lambda.system-d where
open import Data.Nat
open import Data.Fin hiding (lift)
open import lambda.vec
open import lambda.untyped
infixr 21 _ā§_
infixr 22 _ā_
data type : Set where
base : ā ā type
_ā_ _ā§_ : type ā type ā type
context : ā ā Set
context = vec type
in... |
module README where
------------------------------------------------------------------------
-- The Agda "standard" library, version 0.2
--
-- Author: Nils Anders Danielsson, with contributions from
-- Jean-Philippe Bernardy, Samuel Bronson, Liang-Ting Chen, Dan Doel,
-- Patrik Jansson, Shin-Cheng Mu, and Ulf Norell
-... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Functors
------------------------------------------------------------------------
-- Note that currently the functor laws are not included here.
module Category.Functor where
open import Function
open import L... |
------------------------------------------------------------------------------
-- Testing variable names clash
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
... |
-- Solver for Functor
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Functor renaming (id to idF)
module Experiment.Categories.Solver.Functor
{o ā e oā² āā² eā²} {š : Category o ā e} {š : Category oā² āā² eā²}
(F : Functor š š)
where
open import Level
open import Relat... |
module Thesis.LangChanges where
open import Thesis.Changes
open import Thesis.IntChanges
open import Thesis.Types
open import Thesis.Contexts
open import Thesis.Environments
open import Relation.Binary.PropositionalEquality
ChĻ : (Ļ : Type) ā Set
ChĻ Ļ = ā¦ Īt Ļ ā§Type
ĪĪ : Context ā Context
ĪĪ ā
= ā
ĪĪ (Ļ ā¢ Ī) = Īt Ļ... |
{-# OPTIONS --cubical --guardedness --safe #-}
module Data.PolyP.Universe where
open import Prelude hiding (_āØ_ā©_)
open import Data.Vec.Iterated
open import Data.Fin.Indexed
--------------------------------------------------------------------------------
--
-- The Universe of functors we're interested in.
--
------... |
------------------------------------------------------------------------------
-- The alternating bit protocol (ABP) is correct
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-... |
{-# OPTIONS --safe #-}
module Cubical.Categories.Instances.Rings where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Algebra.Ring
open import Cubical.Categories.Category
open Category
open RingHoms
RingsCategory : ā {ā} ā Category (ā-suc ā) ā
ob RingsCategory ... |
-- Algorithmic equality.
{-# OPTIONS --without-K --safe #-}
module Definition.Conversion where
open import Definition.Untyped
open import Definition.Typed
open import Tools.Nat
open import Tools.Product
import Tools.PropositionalEquality as PE
infix 10 _ā¢_~_ā_
infix 10 _ā¢_~_ā_
infix 10 _ā¢_[convā]_
infix 10 _ā¢_[co... |
{-# OPTIONS --without-K #-}
open import HoTT
open import cohomology.Theory
{- Ordinary cohomology groups of the n-torus Tāæ = (SĀ¹)āæ.
- We have Cįµ(Tāæ) == Cā°(Sā°)^(n choose' k) where _choose'_ defined as below.
- This argument could give Cįµ((Sįµ)āæ) with a little more work. -}
module cohomology.Torus {i} (OT : OrdinaryT... |
module Languages.ILL.TypeCheck where
open import bool
open import maybe
open import Languages.ILL.TypeSyntax
open import Languages.ILL.Syntax
open import Utils.HaskellTypes
open import Utils.HaskellFunctions
open import Utils.Exception
data StateT (s : Set) (m : Set ā Set) (a : Set) : Set where
stateT : (s ā m (Pr... |
module Examples.Resolution where
open import Prelude
open import Implicits.Syntax
open import Implicits.Syntax.Type.Constructors
open import Implicits.WellTyped
open import Implicits.Substitutions
open import Extensions.ListFirst
open Rules
unit = 0
-- simple implicit resolution by implication
module exā where
r :... |
module foldr-monoid-foldl where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_ā”_; refl; sym; trans; cong)
open Eq.ā”-Reasoning
open import lists using (List; []; _ā·_; [_]; [_,_]; [_,_,_]; foldr; IsMonoid)
open IsMonoid
open import foldl using (foldl)
postulate
-- å¤å»¶ę§ć®å
¬ē
extensionality : ā {A ... |
module Human.Empty where
data Empty : Set where
void : ā {P : Set} ā Empty ā P
void ()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.