text stringlengths 4 690k |
|---|
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.MaybeEmbed {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.LogicalRelation
open import Definition.LogicalRelation.Irrelevance
open import Definition.LogicalRelation.... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Base
open import lib.Equivalence
open import lib.NType
open import lib.PathFunctor
open import lib.PathGroupoid
open import lib.PathOver
open import lib.Univalence
module lib.cubical.Square where
{-
*--1--*
| |
0 3
| |
*--2--*
-}
data Squ... |
------------------------------------------------------------------------
-- Some defined parsers, collected in a library
------------------------------------------------------------------------
-- Recursive parsers cannot be defined simply as functions, but have
-- to be defined in terms of a grammar.
-- Non-recursiv... |
-- 2010-11-16
-- compactification of Data.Set.Decoration.gmapAll
--
-- This test case fails if we remove instantiateFull
-- (and with it eta-contraction) from definition bodies in Def.hs
-- see Issue 361
-- {-# OPTIONS -v tc.lhs.unify:25 #-}
module EtaContractionDefBody where
---------------------------------------... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- A bunch of properties about natural number operations
------------------------------------------------------------------------
-- See README.Data.Nat for some examples showing how this module can be
-- used.
{-... |
open import Nat
open import Prelude
open import core
open import checks
open import judgemental-erase
module structural where
-- this module contains proofs that the judgements that mention contexts
-- defined throughout the work enjoy the standard structural properties
-- of contexts:
--
-- exchange
--
... |
module Sets.IterativeSet.Oper.Proofs where
import Lvl
open import Data
open import Data.Boolean
open import Data.Boolean.Stmt
open import Data.Either as Either using (_โ_)
open import Data.Tuple as Tuple using ()
open import Functional
open import Logic
open import Logic.Propositional
open import Logic.Predicate
... |
module Tensor where
open import Basics
open import Ix
open import All
open import Perm
open import Cutting
open import Recutter
open _|>_
open RECUTTER
open SUBCOLLECTLEMMA
_><_ : forall {I J} -> (I |> I) -> (J |> J) -> (I * J) |> (I * J)
Cuts (C >< D) (i , j) = Cuts C i + Cuts D j
inners (C >< D) {i , j} (inl c) ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- An inductive definition for the permutation relation
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Relation.Binary.Permutation.Indu... |
-- Andreas, 2016-10-06 issue #2239
-- We need to subtract number of locals when computing
-- de Bruijn index of split variable!
-- {-# OPTIONS -v interaction.case:50 #-}
data Bool : Set where
true false : Bool
test : (x y z : Bool) โ Bool
test x y = ฮป z โ {!y !} -- splitting on y should succeed
fails : (x y z :... |
------------------------------------------------------------------------
-- Code related to the paper "Partiality, Revisited: The Partiality
-- Monad as a Quotient Inductive-Inductive Type"
--
-- Thorsten Altenkirch, Nils Anders Danielsson and Nicolai Kraus
--------------------------------------------------------------... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Lists
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List where
------------------------------------------------------------------------... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Object.Product.Indexed.Properties {o โ e} (C : Category o โ e) where
open import Level
open import Categories.Category.Discrete
open import Categories.Category.Complete
open import Categories.Category.Construction.Cones
open import... |
{-# OPTIONS --without-K #-}
module hott.truncation.equality where
open import sum
open import equality
open import function.extensionality
open import function.isomorphism
open import function.overloading
open import sets.nat
open import hott.equivalence
open import hott.level.core
open import hott.level.closure
open ... |
-- Andreas, 2014-09-07
open import Common.Equality
data โฅ : Set where
record โค : Set where
-- Agda allows us to prove that A โ (A โ B)
test : {A B : Set} โ A โก (A โ B) โ โฅ
test ()
-- Agda allows us to prove that A โ (B โ A)
test' : {A B : Set} โ A โก (B โ A) โ โฅ
test' ()
-- But โค is isomorphic to โค โ โค, which under ... |
{- The following code gives the basic idea of division by repeated
subtraction. We have to ask Agda not to check termination of this
function, because it is not structurally terminating. The versions
in nat-division.agda and nat-division-wf.agda correct this problem,
and can be judged by Agda to be termin... |
module Miscellaneous.TFlipFlop where
open import Data.Boolean
import Data.Boolean.Operators
open Data.Boolean.Operators.Logic
open import Data.Boolean.Numeral
open import Numeral.Natural
open import Syntax.Number
tFlipFlop : Bool โ (โ โ Bool) โ (โ โ Bool)
tFlipFlop init T(๐) = init
tFlipFlop init T(๐... |
open import Nat
open import Prelude
open import dynamics-core
open import contexts
open import progress
open import htype-decidable
open import lemmas-complete
module complete-progress where
-- as in progress, we define a datatype for the possible outcomes of
-- progress for readability.
data okc : (d : ihexp)... |
module Whitespace where
-- The following definition contains several different whitespace
-- characters, and they are all treated as whitespace.
fooโ:โโSetโ->โSetโ
โ->โโSet
fooโxโ_ = ย x
-- Tab characters are not treated as white space, but are still
-- allowed in character and string literals and non-pragma comments
... |
{-# OPTIONS --without-K --safe #-}
module Loop where
open import Loop.Definitions public
open import Loop.Bundles public
open import Loop.Structures public
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Natural numbers, basic types and operations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Nat.Base where
open import Level using (0โ)
o... |
-- MIT License
-- Copyright (c) 2021 Luca Ciccone and Luca Padovani
-- Permission is hereby granted, free of charge, to any person
-- obtaining a copy of this software and associated documentation
-- files (the "Software"), to deal in the Software without
-- restriction, including without limitation the rights to use... |
module Network where
open import Data.Fin hiding (lift; _<_)
open import Function
open import Data.Nat
open import Data.Nat.Show
open import Data.String hiding (show)
open import Data.Vec hiding (_++_)
open import Foreign.Haskell
open import IO
import IO.Primitive as IOPrim
import Network.Primitive as NetPrim
withSoc... |
-- Andreas, 2019-11-10, issue #4185, reported and test case by nad.
--
-- Problem: no-eta-equality was ignored during Miller pattern unification
-- when turning meta-variable applied to constructed record expression
-- into meta-variable applied to record field(s).
-- {-# OPTIONS -v tc.meta.assign:30 #-}
open import ... |
{-# OPTIONS --without-K --safe #-}
module Definition.Typed.Consequences.SucCong where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Weakening
open import Definition.Typed.Properties
open import Definition.Typed.Consequences.Syntactic
open import Definition.Typed.Consequences... |
module Structure.Topology.Properties where
|
{-# OPTIONS --without-K #-}
module sum-properties where
open import Type
import Level as L
open L using (Lift)
open import Data.Zero using (๐)
open import Data.Bool.NP
open Data.Bool.NP.Indexed
open import Data.Nat.NP
open import Data.Nat.Properties
open import Data.Product renaming (map to pmap)
open import Data.Sum... |
module Numeral.Finite.Proofs where
import Lvl
open import Data
open import Data.Boolean.Stmt
open import Functional
open import Logic.Classical
open import Logic.Propositional
open import Logic.Propositional.Theorems
open import Logic.Predicate
open import Numeral.Finite
import Numeral.Finite.Oper.Comparisons as ... |
open import Prelude
open import core
module grounding where
grounding : โ{ ฯ1 ฯ2} โ
ฯ1 โธgnd ฯ2 โ
((ฯ2 ground) ร (ฯ1 ~ ฯ2) ร (ฯ1 โ ฯ2))
grounding (MGArr x) = GHole , TCArr TCHole1 TCHole1 , x
|
{-
Module in which the Grothendieck Group ("Groupification") of a commutative monoid is defined.
-}
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommMonoid.GrothendieckGroup where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cu... |
{-# OPTIONS --with-K #-}
open import Level using (Level)
open import Axiom.UniquenessOfIdentityProofs.WithK using (uip)
open import Relation.Binary.PropositionalEquality
open โก-Reasoning
open import Data.Nat using (โ)
open import Data.Vec using (Vec)
open import FLA.Axiom.Extensionality.Propositional
open import F... |
open import Proc
module Mission (param : Param) where
import Interp
import Hear
open import Basics
private
open module P = Process param
open module I = Interp param
open module H = Hear param
renaming ( sound to hear-sound
; uniq to hear-uniq
; complete to hear-complete
... |
{-# OPTIONS --warning=error #-}
module UselessPrivatePrivate where
private
private
postulate
A : Set
|
module optics where
open import Function
open import Data.Nat
open import Data.Vec
open import Agda.Builtin.Sigma
open import Data.Product
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_โก_; refl; trans; sym; cong; cong-app; subst)
record TraversalF (S T A B : Set) : Set where
... |
module Prologue where
open import Relation.Binary.Core
open IsEquivalence โฆ โฆ โฆ
|
{-# OPTIONS --safe --warning=error --without-K #-}
open import Setoids.Setoids
open import Sets.EquivalenceRelations
open import Rings.Definition
module Rings.Ideals.Principal.Lemmas {a b : _} {A : Set a} {S : Setoid {a} {b} A} {_+_ _*_ : A โ A โ A} (R : Ring S _+_ _*_) where
open Setoid S
open Ring R
open Equivale... |
-- 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: ???
{-# OPTIONS --allow-exec #-}
open import Vehicle
open import Data.Integer as โค using (โค)
open import Data.Rational as โ usin... |
-- Andreas, 2012-09-11
{-# OPTIONS --show-implicit #-}
-- {-# OPTIONS -v tc.meta:50 #-}
module Const where
import Common.Level
const : {A B : Set} โ A โ B โ A
const a b = a
-- If this is analyzed as {A B : Set} โ A โ .B โ A
-- then, due to constraint solving insensitive to subtyping,
-- the following will trigger an ... |
module PolyDepPrelude where
data Pi {X : Set} (Y : X -> Set) : Set where
pi : ((x : X) -> Y x) -> Pi Y
apply : {a : Set} -> {f : a -> Set} -> Pi f -> (x : a) -> f x
apply (pi f) x = f x
data Forall {X : Set} (Y : X -> Set) : Set where
forAll : ((x : X) -> Y x) -> Forall Y
data _=>_ (X Y : Set) : Set where
lam... |
open import Oscar.Prelude
open import Oscar.Class.HasEquivalence
open import Oscar.Class.Smap
open import Oscar.Class.Symmetry
open import Oscar.Class.Symmetrical
open import Oscar.Data.Surjcollation
import Oscar.Class.HasEquivalence.Pฬroperty
import Oscar.Class.Surjection.โ
import Oscar.Data.Proposequality
module Os... |
{-# OPTIONS --cubical --safe #-}
module Cubical.Data.Fin.Arithmetic where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat
open import Cubical.Data.Nat.Mod
open import Cubical.Data.Nat.Order
open import Cubical.Data.Fin
open import Cubical.Data.Sigma
infixl 6 _+โ_ _-โ_ _ยทโ_
infix 7 -โ_
-- Additio... |
-- Operator example
module Operators where
data True : Set where
tt : True
data False : Set where
data Bool : Set where
false : Bool
true : Bool
-- An operator is declared with '_' where the arguments go
if_then_else_ : Bool -> {A : Set} -> A -> A -> A
if true then x else y = x
if false then x else y = y
... |
-- Andreas, 2014-01-10
-- Code by Jesper Cockx and Conor McBride and folks from the Coq-club
{-# OPTIONS --cubical-compatible #-}
-- An empty type.
data Zero : Set where
-- A unit type as W-type.
mutual
data WOne : Set where wrap : FOne -> WOne
FOne = Zero -> WOne
-- Type equality.
data _<->_ (X : Set) : Set... |
module Data.QuadTree.Implementation.QuadrantLenses where
open import Haskell.Prelude renaming (zero to Z; suc to S)
open import Data.Lens.Lens
open import Data.Logic
open import Data.QuadTree.Implementation.PropDepthRelation
open import Data.QuadTree.Implementation.Definition
open import Data.QuadTree.Implementation.V... |
------------------------------------------------------------------------------
-- Proving properties without using pattern matching on refl
------------------------------------------------------------------------------
{-# OPTIONS --no-pattern-matching #-}
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-si... |
open import Agda.Builtin.Bool
data D : Set where
c : Bool โ D
f : @0 D โ Bool
f (c true) = true
f (c false) = false
|
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
postulate
D : Set
_โก_ : D โ D โ Set
a b : D
postulate p : a โก b
{-# ATP axiom p #-}
postulate foo : a โก b
{-# ATP prove foo #-}
|
{-# OPTIONS --without-K --safe #-}
module Categories.CoYoneda where
-- CoYoneda Lemma. See Yoneda for more documentation
open import Level
open import Function.Base using (_$_)
open import Function.Bundles using (Inverse)
open import Function.Equality using (ฮ ; _โจ$โฉ_; cong)
open import Relation.Binary.Bundles using ... |
{-# OPTIONS --without-K #-}
open import HoTT.Base
open import HoTT.Equivalence
open import HoTT.Identity.Pi
module HoTT.Sigma.Universal where
ฮฃ-univ : โ {i j k} {X : ๐ฐ i} {A : X โ ๐ฐ j} (P : (x : X) โ A x โ ๐ฐ k) โ
((x : X) โ ฮฃ (A x) ฮป a โ P x a) โ
(ฮฃ ((x : X) โ A x) ฮป g โ (x : X) โ P x (g x))
ฮฃ-un... |
module Function.Iteration.Proofs where
import Lvl
open import Functional
open import Function.Names as Names using (_โ_)
open import Function.Iteration
open import Function.Proofs
open import Logic.Propositional
open import Logic.Predicate
open import Numeral.Natural
open import Numeral.Natural.Oper using (_+_ ; _โ
_ ;... |
module Vec where
open import Star
open import Nat
data Step (A : Set) : Nat -> Nat -> Set where
step : (x : A){n : Nat} -> Step A (suc n) n
Vec : (A : Set) -> Nat -> Set
Vec A n = Star (Step A) n zero
[] : {A : Set} -> Vec A zero
[] = ฮต
_::_ : {A : Set}{n : Nat} -> A -> Vec A n -> Vec A (suc n)
x :: xs = step x... |
module sv20.exam2 where
-------------------------- FIRST TASK PREPARATION CODE --------------------------
open import Data.Unit using (โค; tt)
open import Data.Product using (_ร_ ; โ) renaming (_,_ to โจ_,_โฉ)
open import Relation.Nullary using (ยฌ_)
open import Data.Sum using (_โ_; injโ; injโ)
open import Function using ... |
------------------------------------------------------------------------
-- A parser for PBM images; illustrates "essential" use of bind
------------------------------------------------------------------------
-- Note that I am using the simple "Plain PBM" format, and I try to
-- adhere to the following statement from... |
module L where
open import Data.Nat using (โ; suc) -- ; _*_)
open import Relation.Binary.PropositionalEquality using (_โก_; refl; cong; sym; trans)
open import Data.Product
open import Data.Empty
-- Recursion principle
recโ : (C : Set) โ C โ (โ โ C โ C) โ โ โ C
recโ C c f 0 = c
recโ C c f (suc n) = f n (recโ C c f n)... |
open import MLib.Algebra.PropertyCode
open import MLib.Algebra.PropertyCode.Structures
module MLib.Matrix.Tensor {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.Algebra.Oper... |
open import Prelude
open import Nat
open import core
open import contexts
open import lemmas-disjointness
module lemmas-freshness where
-- if x is fresh in an eexp, it's fresh in its expansion
mutual
fresh-elab-synth1 : โ{x e ฯ d ฮ ฮ} โ
x # ฮ โ
freshe x e โ
... |
module Issue499 where
data A : Set where
a : A
data B : Set where
b : .A โ B
data C : B โ Set where
c : C (b a)
f : โ {i} โ C i โ A
f x = {!!} -- Hitting C-c C-c x
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
module cw.cohomology.GridMap {i j k}
{A : Type i} {B : Type j} {C : Type k}
(f : A โ B) (g : B โ C) where
B/A = Cofiber f
C/A = Cofiber (g โ f)
C/B = Cofiber g
B/A-to-C/A-span-map : SpanMap (cofiber-span f) (cofiber-span (g โ f))
B/A-to-C/A-span... |
------------------------------------------------------------------------------
-- The gcd is divisible by any common divisor
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-pol... |
module Vecs where
open import Nats
infixr 5 _โท_ _++_ _โทสณ_
infix 4 _โ_ _โ_
data Vec {a} (A : Set a) : โ โ Set a where
[] : Vec A zero
_โท_ : โ {n} (x : A) (xs : Vec A n) โ Vec A (suc n)
data _โ_ {a} {A : Set a} : A โ {n : โ} โ Vec A n โ Set a where
here : โ {n} {x} {xs : Vec A n} โ x โ x โท xs
there : โ {n... |
{-# OPTIONS --erased-cubical --safe --no-sized-types --no-guardedness
--no-subtyping #-}
module Agda.Builtin.Cubical.Path where
open import Agda.Primitive.Cubical using (PathP) public
infix 4 _โก_
-- We have a variable name in `(ฮป i โ A)` as a hint for case
-- splitting.
_โก_ : โ {โ} {A : Set โ... |
{-# OPTIONS --no-universe-polymorphism #-}
open import Data.List
open import Data.Product
open import Data.Unit hiding (_โค_)
open import Data.Nat
open import Data.Empty
open import Relation.Nullary
open import Relation.Binary.Core hiding (Total)
import Level as L using (zero)
open import Lists
open import BagEquality... |
{-# OPTIONS --without-K --safe #-}
module Categories.Adjoint.Instance.StrictCore where
-- The adjunction between the forgetful functor from (strict) Cats to
-- (strict) Groupoids and the (strict) Core functor.
open import Data.Product
open import Level using (_โ_)
import Function
open import Relation.Binary using (I... |
open import Data.Product using ( โ ; _ร_ ; _,_ )
open import Relation.Binary.PropositionalEquality using ( _โก_ ; refl )
open import Relation.Nullary using ( ยฌ_ )
open import Relation.Unary using ( _โ_ ; โ
)
open import Web.Semantic.DL.Signature using ( Signature ; CN ; RN )
open import Web.Semantic.Util using ( Setoid ... |
{-
This is the readme of the Agda mechanization accompanying our
POPL 2018 paper:
"Intrinsically-Typed Interpreters for Imperative Languages"
The repository is hosted here:
- https://github.com/metaborg/mj.agda
A rendered and linked version of this readme can be found here:
- https://metaborg.github.... |
{-# OPTIONS --without-K #-}
{- Here, we derive our main theorem: there is a type in the n-th universe
that is not an n-type, implying the n-th universe is not n-truncated.
The n-th universe restricted to n-types is hence a 'strict' n-type.
For this, we first derive local-global looping in a modular way.
A... |
-- Andreas, 2015-07-20, record patterns
open import Common.Product
open import Common.Prelude
open import Common.Equality
swap : {A B : Set} (p : A ร B) โ B ร A
swap record{ projโ = a; projโ = b } = record{ projโ = b; projโ = a }
fst : {A : Set}{B : A โ Set} (p : ฮฃ A B) โ A
fst record{ projโ = a } = a
snd : {A : Se... |
{-# OPTIONS --safe #-} -- --without-K #-}
open import Relation.Binary.PropositionalEquality using (_โก_; _โข_; refl; sym; subst; cong; trans)
open import Relation.Nullary.Decidable using (toWitness; fromWitness)
open import Relation.Nullary using (yes; no)
open import Function.Reasoning
open import Function using (_โ_)
... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Homotopy.Connected where
open import Cubical.Core.Everything
open import Cubical.Foundations.Everything
open import Cubical.Foundations.Function
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundation... |
module Data.Num.Core where
open import Data.Num.Digit public
open import Data.Nat
open import Data.Nat.Properties
open import Data.Nat.Properties.Simple
open import Data.Nat.Properties.Extra
open import Data.Fin as Fin
using (Fin; fromโโค; injectโค; toโ; zero; suc; #_)
open import Data.Fin.Properties as FinProps us... |
{-# OPTIONS --warning=error --safe --without-K #-}
open import Functions.Definition
open import Rings.Homomorphisms.Definition
open import Groups.Homomorphisms.Definition
open import Setoids.Setoids
open import Rings.Definition
open import Sets.EquivalenceRelations
open import Groups.QuotientGroup.Definition
module R... |
{-# OPTIONS --safe #-}
module Cubical.Data.Int.MoreInts.DiffInt.Properties where
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Univalence
open import Cubical.Data.Int.MoreInts.DiffInt.Base
open import Cubical.Data.Nat as โ renaming (_+_ to _+โ_ ; _ยท_ ... |
------------------------------------------------------------------------------
-- Main properties of the McCarthy 91 function
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-po... |
{-# OPTIONS --allow-unsolved-metas #-}
open import CS410-Prelude
------------------------------------------------------------------------------
-- Vectors
------------------------------------------------------------------------------
data Vec (X : Set) : Nat -> Set where
[] : Vec X ... |
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
module DTGP
{Domain Word : Set}
(pre post : Word โ Domain โ Domain)
(_โ_ : (x y : Domain) โ Dec (x โก y))
where
open import Function
open import Relation.Binary
open import Data.Bool hiding (_โ_)
open import Data.Nat hiding (_โฅ_; _โ_)
o... |
{- 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 Optics.All
open import LibraBFT.Prelude
open import LibraBFT... |
-- {-# OPTIONS -v 20 #-}
-- {-# OPTIONS -v tc.polarity:30 #-}
-- {-# OPTIONS -v tc.decl:30 #-}
-- {-# OPTIONS -v tc.term:30 #-}
-- {-# OPTIONS -v tc.conv.coerce:20 #-}
-- {-# OPTIONS -v tc.signature:30 #-}
-- {-# OPTIONS -v import.iface:100 #-}
module Issue1168 where
open import Agda.Primitive
open import Agda.Builti... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Groups.Definition
open import Setoids.Setoids
open import Setoids.Orders.Partial.Definition
open import Functions.Definition
open import Rings.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _โ_)
module Rings.Orders.Partial.Definition {n... |
data D : Setโ where
โจ_โฉ_ : Set โ Set โ D
Test : D โ Set
Test ((โจ_โฉ X) _) = X
|
open import Relation.Binary.Core
module BBHeap.Drop {A : Set}
(_โค_ : A โ A โ Set)
(totโค : Total _โค_)
(transโค : Transitive _โค_) where
open import BBHeap _โค_
open import BBHeap.Compound _โค_
open import BBHeap.Equality _โค_
open import BBHeap.Equality.Properties _โค_
... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of unique lists (setoid equality)
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Relation.Unary.Unique.Propositional.Prop... |
------------------------------------------------------------------------
-- Properties of functions, such as associativity and commutativity
------------------------------------------------------------------------
-- These properties can (for instance) be used to define algebraic
-- structures.
open import Relation.B... |
------------------------------------------------------------------------
-- A type soundness result
------------------------------------------------------------------------
open import Prelude
open import Prelude.Size
import Lambda.Syntax
module Lambda.Type-soundness
{Name : Type}
(open Lambda.Syntax Name)
(op... |
open import Common.Prelude
test : Nat โ Nat
test = __+ 2
|
{-
This file contains:
- Eliminator for propositional truncation
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.PropositionalTruncation.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.F... |
module OpBind where
postulate _โ_ : Set -> Set -> Set
Homomorphicโ : Set โ Set
Homomorphicโ โ = โ
|
module _ where
open import Data.Nat using (โ ; _+_ ; _โคโฒ_ ; suc)
open import Induction.Nat using (<โฒ-rec)
open import Esterel.Lang.CanFunction
open import Function using (_โ_ ; _โ_ ; id ; _$_)
open import Data.Nat.Properties.Simple using ( +-comm ; +-assoc)
open import utility
open import noetherian using (noetherian... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import groups.ProductRepr
open import cohomology.Theory
open import homotopy.WedgeCofiber
{- For the cohomology group of a suspension ฮฃX, the group inverse has the
- explicit form Cโฟ(flip-susp) : Cโฟ(ฮฃX) โ Cโฟ(ฮฃX).
-}
module cohomology.InverseInSusp {i} (... |
------------------------------------------------------------------------
-- A type for values that should be erased at run-time
------------------------------------------------------------------------
-- This module reexports definitions that do not depend on an
-- implementation of []-cong.
{-# OPTIONS --without-K -... |
module Dave.Functions where
_โ_ : โ {A B C : Set} โ (B โ C) โ (A โ B) โ (A โ C)
(g โ f) a = g (f a)
_โยด_ : โ {A B C : Set} โ (B โ C) โ (A โ B) โ (A โ C)
(g โยด f) = ฮป x โ g (f x) |
{-# OPTIONS --no-positivity-check
#-}
{-
Data, Deliberately
Conor McBride
Workshop in Dependently Typed Programming
Nottingham, 2008
(Agda rendering by Ulf Norell)
-}
module Talk where
open import SomeBasicStuff
-- Codes for (first order) inductive families.
data Code (I : Set) : Set1 where
arg : (... |
------------------------------------------------------------------------
-- An implementation of the Thue-Morse sequence
------------------------------------------------------------------------
-- The paper "Productivity of stream definitions" by Endrullisย etย al.
-- (TCSย 2010) uses a certain definition of the Thue-Mor... |
-- {-# OPTIONS -v tc.proj.like:30 #-}
open import Common.Bool
open import Common.Equality
abstract
Id : Set โ Set
Id A = A
f : โ A โ Id A โ Id A
f A x = x
postulate
foo : โ{X : Set} (x y : X) โ x โก y โ Set
abstract
bla : Set
bla = foo (f Bool true) false refl
-- WAS:
-- true != false of type Bool
-- whe... |
-- Andreas, 2019-07-04, issue #3886
-- Override forcing with explicit quantity attributes.
open import Common.Prelude
pattern [_] x = x โท []
module _ {a} {A : Set a} where
variable
x y z : A
@0 xs ys zs : List A
data FSet : List A โ Set a where
โ
: FSet []
_โช_ : FSet xs โ FSet ys โ FSet (xs +... |
{-# OPTIONS --cubical --safe #-}
module Data.List.Syntax where
open import Data.List
open import Prelude
record ListSyntax {a b} (A : Type a) (B : Type b) : Type (a โโ b) where
field [_] : B โ List A
open ListSyntax โฆ ... โฆ public
instance
cons : โฆ _ : ListSyntax A B โฆ โ ListSyntax A (A ร B)
[_] โฆ cons โฆ (x... |
open import Level using () renaming (zero to โโ)
open import Relation.Binary using (DecSetoid)
module Bidir (A : DecSetoid โโ โโ) where
open import Data.Nat using (โ)
open import Data.Fin using (Fin)
import Level
import Category.Monad
import Category.Functor
open import Data.Maybe using (Maybe ; nothing ; just ; mayb... |
------------------------------------------------------------------------
-- A bunch of properties
------------------------------------------------------------------------
module Data.Bool.Properties where
open import Data.Bool as Bool
open import Data.Fin
open import Data.Function
open import Algebra
open import Alge... |
------------------------------------------------------------------------
-- Syntax of Fฯ with interval kinds
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module FOmegaInt.Syntax where
open import Algebra using (Monoid)
import Data.Context as Context
open... |
open import Poly
open import Function
open import Data.Nat
open import Data.Empty
open import Data.Unit
open import Data.Product as Prod
open import Data.Sum
open import Relation.Binary.PropositionalEquality
data โโ : Set where
fin : โ โ โโ
ฯ : โโ
data _<'_ : โโ โ โโ โ Set where
ltSuc : (n : โ) โ fin n <' fin (... |
module Numeric.Nat.Divide where
open import Prelude
open import Control.WellFounded
open import Numeric.Nat.Properties
open import Numeric.Nat.DivMod
open import Tactic.Nat
--- Divides predicate ---
data _Divides_ (a b : Nat) : Set where
factor : โ q (eq : q * a โก b) โ a Divides b
pattern factor! q = factor q re... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.