text stringlengths 4 690k |
|---|
module L.Base.Sigma.Properties where
open import L.Base.Sigma.Core
choice : ∀{a b c} {A : Set a} {B : Set b} → {C : A → B → Set c}
→ ((x : A) → Σ B (λ y → C x y)) → Σ (A → B) (λ f → (a : A) → C a (f a))
choice = λ F → ((λ x → fst (F x)) , λ a → snd (F a))
|
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 ... |
module InductiveAndCoinductiveConstructors where
open import Common.Coinduction
record ⊤ : Set where
data _×_ (A : Set) (B : Set) : Set where
_,_ : (x : A) (y : B) → A × B
data Stream (A : Set) : Set where
_≺_ : (x : A) (xs : ∞ (Stream A)) → Stream A
data U : Set where
stream : (a : U) → U
_⊗_ : (a b : ... |
open import Agda.Builtin.Bool
f : Bool → Bool
f x =
let id : Bool → Bool
id b = {!!}
in id x
|
module Aexamples where
open import Data.List hiding (reverse)
open import Data.List.All
open import Data.Nat
open import Typing
open import Syntax
open import Async
{-
Lithmus test for asynchronous operations
A thread send something to an asynchronous channel and receives it afterwards.
-}
aex1 : Expr [] TUnit
aex1 ... |
{-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Orders.WellFounded.Definition
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Order
open import Semirings.Definition
module Numbers.Naturals.Order.WellFounded where
open Semiring ℕSemiring
<NWellfounded : We... |
{- 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.Prelude
open import LibraBFT.Base.PKCS
open import... |
module NotLeqSort where
data Err : Set where
err : (A : Set) -> Err
|
{-# OPTIONS --safe #-}
module Cubical.Algebra.Direct-Sum.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Algebra.AbGroup
-- Conventions :
-- Elements of the index are named r, s, t...
-- Elements of the groups are called a, b, c...
-- Elements of the di... |
{-# OPTIONS --safe #-}
module CF.Syntax.Hoisted where
open import Level
open import Data.List
open import Relation.Unary hiding (_⊢_)
open import Relation.Ternary.Core
open import Relation.Ternary.Structures
open import Relation.Ternary.Structures.Syntax
open import CF.Types
open import CF.Contexts.Lexical
open impo... |
------------------------------------------------------------------------------
-- Incompatible options
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTI... |
module Structure.Type.Identity.Proofs.Multi where
open import Data.Tuple.Raise
open import Data.Tuple.RaiseTypeᵣ
import Data.Tuple.RaiseTypeᵣ.Functions as RaiseType
import Lvl
open import Functional using (_→ᶠ_ ; id ; _on₂_ ; swap ; _$_ ; apply)
open import Function.Multi
import Function.Multi.Functions... |
{-# OPTIONS --cubical --no-exact-split --safe #-}
module Multidimensional.Data.Extra.Nat.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat
open import Cubical.Data.Empty
open import Cubical.Relation.Nullary
open import Multidimensional.Data.Ex... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Coprimality
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Integer.Coprimality where
open import Data.Integer
open import Data.Integer.D... |
open import Relation.Nullary.Decidable using (False)
open import Relation.Binary.PropositionalEquality using (_≡_; refl; sym; cong; cong₂)
open import Relation.Binary.PropositionalEquality.WithK using (≡-erase)
module AKS.Nat.Divisibility where
open import Data.Nat.Divisibility using (_∣_) public
open import Agda.Bui... |
{-# OPTIONS --without-K --safe #-}
module Tools.Embedding where
open import Agda.Primitive
data ι {ℓ : Level} (A : Set ℓ) : Set (lsuc ℓ) where
ιx : A → ι A
data ι′ {ℓ : Level} (A : Set) : Set ℓ where
ιx : A → ι′ A
data ι″ {ℓ} (A : Set ℓ) : Setω where
ιx : A → ι″ A
|
{-# OPTIONS --rewriting #-}
module Everything where
import Examples
import Properties
import PrettyPrinter
import Interpreter
|
{-# OPTIONS --safe #-}
module Cubical.HITs.AssocList.Properties where
open import Cubical.HITs.AssocList.Base as AL
open import Cubical.Foundations.Everything
open import Cubical.Foundations.SIP
open import Cubical.HITs.FiniteMultiset as FMS
hiding (_++_; unitl-++; unitr-++; assoc-++; cons-++; comm-++)
open import C... |
{-# OPTIONS --cubical --safe #-}
module DivModAlt where
open import Cubical.Core.Everything using (_≡_; Level; Type; Σ; _,_; fst; snd; _≃_; ~_)
open import Cubical.Foundations.Prelude using (refl; sym; _∙_; cong; transport; subst; funExt; transp; I; i0; i1; hcomp; primPOr; _∨_)
open import Cubical.Foundations.Fu... |
module PiQ.Properties where
open import Data.Empty
open import Data.Unit hiding (_≟_)
open import Data.Sum
open import Data.Product
open import Data.Maybe
open import Data.Maybe.Properties
open import Data.Nat hiding (_≟_)
open import Data.Nat.Induction
open import Data.Nat.Properties hiding (_≟_)
open import Function ... |
-- Proof irrelevance is nice when you want to work with subsets.
module Subset where
data True : Prop where
tt : True
data False : Prop where
data (|) (A:Set)(P:A -> Prop) : Set where
sub : (x:A) -> P x -> A | P
data Nat : Set where
zero : Nat
suc : Nat -> Nat
mutual
IsEven : Nat -> Prop
IsEven zero... |
------------------------------------------------------------------------
-- Document renderers
------------------------------------------------------------------------
{-# OPTIONS --guardedness #-}
module Renderer where
open import Algebra
open import Data.Bool
open import Data.Char using (Char)
open import Data.Emp... |
module Optics where
open import Agda.Primitive using (_⊔_; lsuc)
open import Data.Maybe using (Maybe; just)
open import Data.Sum using (_⊎_; inj₁)
open import Function using (const; id)
open import Category.Functor.Arr
open import Category.Functor.Const
open import Category.Functor.Either
open import Category.Profuncto... |
{-# OPTIONS --safe #-}
module Cubical.Experiments.ZCohomologyExperiments where
open import Cubical.ZCohomology.Base
open import Cubical.ZCohomology.Properties
open import Cubical.ZCohomology.GroupStructure
open import Cubical.ZCohomology.Groups.Sn
open import Cubical.ZCohomology.Groups.WedgeOfSpheres
open import Cubica... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Reflexive closures
--
-- This module is DEPRECATED. Please use the
-- Relation.Binary.Construct.Closure.Reflexive module directly.
------------------------------------------------------------------------
{-# OPT... |
open import Relation.Binary.Core
module BBHeap.Drop.Properties {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_)
(trans≤ : Transitive _≤_) where
open import BBHeap _≤_
open import BBHeap.Compound _≤_
open import BBHeap.Drop _≤_ tot≤ trans≤
open import BBHeap.Equal... |
module Inductive.Examples.Product where
open import Inductive
open import Tuple
open import Data.Fin
open import Data.Product hiding (_×_; <_,_>)
open import Data.List
open import Data.Vec
_×_ : Set → Set → Set
A × B = Inductive (((A ∷ (B ∷ [])) , []) ∷ [])
<_,_> : {A B : Set} → A → B → A × B
< a , b > = construct ... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Data.NatPlusOne where
open import Cubical.Data.NatPlusOne.Base public
open import Cubical.Data.NatPlusOne.Properties public
|
{-# OPTIONS -v tc.conv.fun:20 #-}
-- Andreas, 2019-11-06, issue #4175, reported and test case by nad.
-- Check quantity for function type subtyping.
postulate
F : Set → Set
G : (@0 Set → Set) → Set
-- If an erased function is expected, we cannot pass one
-- that might actually use its arguments.
ShouldFail : Se... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import groups.Cokernel
open import cw.WedgeOfCells
open import cohomology.Theory
open import cw.CW
module cw.cohomology.reconstructed.HigherCoboundary {i} (OT : OrdinaryTheory i)
{n} (⊙skel : ⊙Skeleton {i} (S (S n))) where
open OrdinaryTheory OT
open i... |
module Structure.Sets where
open import Functional
open import Lang.Instance
import Lvl
open import Logic
open import Logic.Propositional
open import Logic.Predicate
open import Structure.Setoid
open import Structure.Sets.Relator
open import Type
private variable ℓ ℓₑ ℓₗ : Lvl.Level
private variable S E : Type{ℓ... |
-- The SIP applied to groups
{-# OPTIONS --safe #-}
module Cubical.Algebra.Group.GroupPath where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Foundations.HLevels
open impor... |
{-# OPTIONS --cubical-compatible #-}
module Common.Char where
open import Agda.Builtin.Char public
open import Common.Bool
charEq : Char -> Char -> Bool
charEq = primCharEquality
|
module Array where
open import Array.Base public
open import Array.Properties public
|
module Data.Tuple.Category where
import Lvl
open import Data.Tuple as Tuple using (_⨯_ ; _,_)
open import Data.Tuple.Equivalence
import Functional as Fn
open import Logic.Propositional
open import Logic.Predicate
open import Structure.Category
open import Structure.Category.Functor
open import Structure.Cate... |
module Haskell.Prim.Integer where
open import Agda.Builtin.Nat
open import Agda.Builtin.Bool
open import Agda.Builtin.List
open import Agda.Builtin.String
open import Agda.Builtin.Char
open import Agda.Builtin.Unit
import Agda.Builtin.Int
open Agda.Builtin.Int public using () renaming (Int to Integer)
open Agda.Buil... |
{-# OPTIONS --without-K --exact-split --safe #-}
module Fragment.Extensions.Semigroup where
open import Fragment.Equational.Theory.Bundles
open import Fragment.Algebra.Signature
open import Fragment.Algebra.Homomorphism Σ-magma
open import Fragment.Algebra.Free Σ-magma hiding (_~_)
open import Fragment.Algebra.Algeb... |
module _ where
open import Agda.Builtin.Equality
open import Agda.Builtin.Nat
module Vars (A : Set) where
variable
x : A
-- Was
-- Panic: Unbound name: Issue3121._.x [0,10,12]@8066984681118411118
-- when checking that the expression
-- {A : Set} (let open Vars A) → ;Issue3121.x ≡ ;Issue3121.x has type _... |
------------------------------------------------------------------------
-- Virtual machine instructions, state etc.
------------------------------------------------------------------------
open import Prelude
module Lambda.Virtual-machine.Instructions (Name : Type) where
open import Equality.Propositional
open imp... |
{-# OPTIONS --without-K --safe #-}
module Categories.Adjoint.Equivalence.Properties where
open import Level
open import Categories.Category
open import Categories.Adjoint.Equivalence
open import Categories.Functor renaming (id to idF)
open import Categories.Functor.Properties
open import Categories.NaturalTransforma... |
{-
Copyright (c) 2017 Diego Pedraza.
This is Free/Libre Open Source Software, released under the MIT License.
For the full copyright and license information, please view the LICENSE
file that was distributed with this source code.
-}
module R1 where
open import Data.List using (List; _∷_; _++_; [_]; [])... |
{-# OPTIONS --copatterns #-}
module Copatterns where
record Stream (A : Set) : Set where
field
head : A
tail : Stream A
open Stream
repeat : {A : Set}(a : A) -> Stream A
head (repeat a) = a
tail (repeat a) = repeat a
map : {A B : Set}(f : A -> B)(as : Stream A) -> Stream B
head (map f as) = f (head as)
ta... |
module Numeral.Integer.Sign where
open import Numeral.Natural
using (ℕ)
open import Numeral.Integer
open import Numeral.Sign as Sign
using (+|− ; +|0|−)
sign : ℤ → (+|−)
sign(+ₙ _) = Sign.➕
sign(−𝐒ₙ _) = Sign.➖
sign0 : ℤ → (+|0|−)
sign0(𝟎) = Sign.𝟎
sign0(+𝐒ₙ _) = Sign.➕
sign0(−𝐒ₙ _) = Sign.➖
signum0 : ℤ → ... |
------------------------------------------------------------------------
-- And
------------------------------------------------------------------------
module TotalParserCombinators.And where
open import Category.Monad
open import Data.List.Relation.Binary.BagAndSetEquality
open import Data.List.Membership.Propositi... |
test : Set
test = {! M !}
|
module Eq.Theory where
open import Prelude
open import T
open import DynTheory
open import SubstTheory
open import Contexts
open import Eq.Defs
open import Eq.KleeneTheory
open import Eq.ObsTheory
open import Eq.LogicalTheory
-- Theory about the interactions between the relationships between the equivs
-- Now that w... |
{-# OPTIONS --prop #-}
open import Agda.Primitive
open import Agda.Builtin.Equality
open import Agda.Builtin.List
open import Agda.Builtin.Reflection
macro
doQuote : ∀ {ℓ} {A : Set ℓ} → A → Term → TC _
doQuote x hole = bindTC (quoteTC x) (λ qx → bindTC (quoteTC qx) (unify hole))
testQuote₁ : doQuote Prop ≡ agda-... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
open import Cubical.Relation.Binary
module Cubical.Relation.Binary.Construct.StrictToNonStrict
{a ℓ} {A : Type a}
(_<_ : Rel A ℓ)
where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open im... |
-- Andreas, 2010-09-24 deactivated this annoying test case in Makefile
module Impossible where
-- The only way to trigger an __IMPOSSIBLE__ that isn't a bug.
{-# IMPOSSIBLE #-}
|
-- Andreas, 2019-08-17, issue #1346
-- Allow changing fixity in renaming statement
module Issue1346 where
data Bool : Set where true false : Bool
module Product where
infixr 4 _,_
record _×_ (A B : Set) : Set where
constructor _,_
field
fst : A
snd : B
module List where
infixr 5 _∷_
... |
{-# OPTIONS --without-K #-}
module lib.groups.Groups where
open import lib.groups.Homomorphisms public
open import lib.groups.Lift public
open import lib.groups.Unit public
open import lib.groups.PropSubgroup public
open import lib.groups.GroupProduct public
open import lib.groups.PullbackGroup public
open import li... |
-- Exponential and compatible strengths
module SOAS.Abstract.ExpStrength {T : Set} where
open import SOAS.Families.Core {T}
open import SOAS.Context
open import SOAS.Variable
open import SOAS.ContextMaps.Combinators
open import SOAS.ContextMaps.CategoryOfRenamings
open import SOAS.Common
open import SOAS.Coalgebraic... |
module Structure.Operator.Monoid.Monoids.Function where
open import Functional
open import Function.Equals
open import Function.Equals.Proofs
import Lvl
open import Logic
open import Logic.Predicate
open import Structure.Function
open import Structure.Operator.Monoid
open import Structure.Operator.Properties
open... |
{-# OPTIONS --rewriting #-}
open import Agda.Builtin.Equality
postulate
A : Set
x0 : A
f : A → A → A
{-# BUILTIN REWRITE _≡_ #-}
postulate
fxx : (x : A) → (f x x) ≡ x
{-# REWRITE fxx #-}
meta : A
meta-reveal : meta ≡ x0
test : f x0 meta ≡ x0
meta = _
test = refl
meta-reveal = refl
|
-- Implementation of Gödel's System T as an example for
-- Σ-terms (Σ = {Z, S}; α(Z) = 0; α(S) = 1) with primitive recursion
module SystemT where
open import Data.Vec hiding (_++_)
open import Data.Nat
open import Data.List
open import Data.List.All
-- Not in use yet:
-- Σ is a vector of given length n of natural num... |
{- Box operator. -}
module TemporalOps.Box where
open import CategoryTheory.Categories
open import CategoryTheory.Instances.Sets
open import CategoryTheory.Instances.Reactive
open import CategoryTheory.BCCCs
open import CategoryTheory.Functor
open import CategoryTheory.CartesianStrength
open import CategoryTheory.Nat... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Lists.Lists
open import Setoids.Setoids
open import Functions.Definition
open import Sets.EquivalenceRelations
module Setoids.Lists where
listEquality : {a b : _} {A : Set a} (S : Setoid {a} {b} A) → Rel {a} {b} (List A)
listE... |
open import Common.Reflection
open import Common.Prelude hiding (_<$>_)
open import Common.Equality
_<$>_ : ∀ {A B : Set} → (A → B) → Maybe A → Maybe B
f <$> just x = just (f x)
f <$> nothing = nothing
_==_ = primQNameEquality
-- This is awkward!
awkwardUnquoteBool : Term → Maybe Bool
awkwardUnquoteBool (con c [])... |
{-# OPTIONS --cubical --no-import-sorts #-}
module Number.Instances.QuoIntFromIntSIP where
open import Agda.Primitive renaming (_⊔_ to ℓ-max; lsuc to ℓ-suc; lzero to ℓ-zero)
open import Cubical.Foundations.Everything hiding (⋆) renaming (_⁻¹ to _⁻¹ᵖ; assoc to ∙-assoc)
open import Cubical.Foundations.Logic renaming (i... |
{-# OPTIONS --universe-polymorphism #-}
-- There was a bug with reducing levels which could leave
-- instantiated metas in the term.
module Issue469 where
open import Common.Level
postulate
∃ : ∀ {a b} {A : Set a} → (A → Set b) → Set (a ⊔ b)
E : ∀ {c d} → Set c → Set d → Set (c ⊔ d)
data K : Set where
k₁ : K
... |
{-# OPTIONS --without-K #-}
open import Data.Product using (_×_)
open import Data.String
open import Level
open import Relation.Binary.PropositionalEquality.Core
Valence : Set
Valence = String
data Type : Set where
Outgoing : Type
Incoming : Type
infix 5 _,_⦂_
data Context : Set where
∅ : Context
_,_⦂_ :... |
module Cats.Category.Wedges where
open import Level using (_⊔_ ; suc)
open import Relation.Binary using (Rel ; IsEquivalence)
open import Cats.Category
open import Cats.Category.Setoids using (Setoids)
open import Cats.Profunctor
open import Cats.Util.Function using (_on_ ; on-isEquivalence)
module _ {lo la l≈ lo′ ... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Join.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.HITs.S1
open import Cubical.HITs.S3
-- redtt version : https://github.com/RedPRL/redtt/b... |
module _ where
open import Agda.Builtin.Nat
postulate
F : Set → Set
pure : ∀ {A} → A → F A
_<*>_ : ∀ {A B} → F (A → B) → F A → F B
data Vec (A : Set) : Nat → Set where
[] : Vec A zero
_∷_ : ∀ {n} → A → Vec A n → Vec A (suc n)
ok : ∀ n → F Nat → F (Vec Nat n) → F (Vec Nat (suc n))
ok n a as = (| a ∷ as |... |
-- Andreas, 2016-08-02 issue #2127 reported by petercommand
data Test : Set₁ where
field
A : Set
B : Set -- second field necessary to trigger internal error
-- WAS: internal error
-- Should give proper error
|
-- Andreas, 2011-10-03
-- allow matching on irrelevant data as long as there is at most one
-- matching constructor
{-# OPTIONS --experimental-irrelevance #-}
module MatchIrrelevant where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
data NAT : Nat -> Set where
Zero : NAT zero
Suc : (n : Nat) -> NAT n ->... |
{-# OPTIONS --without-K #-}
open import lib.Basics
module lib.types.Sigma where
-- Cartesian product
_×_ : ∀ {i j} (A : Type i) (B : Type j) → Type (lmax i j)
A × B = Σ A (λ _ → B)
module _ {i j} {A : Type i} {B : A → Type j} where
pair : (a : A) (b : B a) → Σ A B
pair a b = (a , b)
-- pair= has already bee... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Some properties about subsets
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Fin.Subset.Properties where
import Algebra.Definitions as A... |
{-# OPTIONS --universe-polymorphism #-}
module tests.Literals where
open import Prelude.Nat
open import Prelude.Float
open import Prelude.Char
open import Prelude.String
open import Prelude.Unit
open import Prelude.IO
afloat : Float
afloat = 1.23
astring : String
astring = "abc"
achar : Char
achar = 'd'
anat : Nat... |
import Lvl
module Structure.Category {ℓₒ ℓₘ ℓₑ : Lvl.Level} where
open import Functional using (swap)
open import Logic
open import Logic.Propositional
import Structure.Categorical.Names as Names
open import Structure.Categorical.Properties
open import Structure.Semicategory{ℓₒ}{ℓₘ}{ℓₑ}
open import Structur... |
{-# OPTIONS --without-K --rewriting #-}
module PropT where
open import Base
open import lib.Basics
open import lib.types.Sigma
open import lib.NType2
open import lib.types.Truncation
open import lib.types.Lift
_is-contractible : {i : ULevel} (A : Type i) → Type i
_is-contractible = is-contr
⊤-is... |
{-# OPTIONS --safe --warning=error --without-K --guardedness #-}
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 Setoids.Orders.Total.Definition
open import Sets.Equi... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.ZCohomology.RingStructure.CohomologyRingFun where
{-
There is two definitionof the Cohomology Ring.
We recommend to use the HIT definition (the other one)
as the ring product is eaiser to handle.
Nevertheless the equality is harder to h... |
{-# OPTIONS --no-import-sorts #-}
open import Agda.Primitive using (Prop)
postulate
Set₁ : Prop
open import Agda.Primitive using (Set)
postulate
A : Set₁
|
-- Andreas, 2014-10-09
-- Reported by ohmanjoakim
infixr 8 _⇒_
data Ty : Set where
_⇒_ : Ty → Ty → Ty
⟦_⟧ : Ty → Set
⟦ A ⇒ B ⟧ = ⟦ A ⟧ → ⟦ B ⟧
data Term : Ty → Set where
K : (A B : Ty) → Term (A ⇒ B ⇒ A)
test : (A : Ty) (a : Term A) → ⟦ A ⟧
test A a = {!a!}
-- When doing a case split on a in foo, the followin... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category using (module Commutation)
renaming (Category to Setoid-Category)
open import Categories.Category.Monoidal using (Monoidal)
open import Categories.Category.Monoidal.Symmetric using (Symmetric)
module Categories.Enriched.Category.Opposite
{o ℓ e} {... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.Product.Relation.Binary.Pointwise.NonDependent directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
... |
{-# OPTIONS --without-K #-}
module sets.nat.ordering.lt.core where
open import sum
open import equality.core
open import function.isomorphism.core
open import sets.core
open import sets.nat.core
open import sets.nat.ordering.leq.core
_<_ : ℕ → ℕ → Set
m < n = suc m ≤ n
infixr 4 _<_
z<n : ∀ {n} → 0 < suc n
z<n = s≤s... |
{- NEW TRANSLATION: notation change to avoid exponential increase in term size during translation -}
open import Preliminaries
open import Source
open import Complexity
module Translation-WithLet where
mutual
⟨⟨_⟩⟩ : Tp → Complexity.CTp
⟨⟨ unit ⟩⟩ = unit
⟨⟨ nat ⟩⟩ = nat
⟨⟨ susp A ⟩⟩ = || A ||
⟨... |
module _ where
record LinearOrderStr (D : Set) : Set₁ where
no-eta-equality
field
_<_ : D -> D -> Set
open LinearOrderStr {{...}}
postulate
D : Set
module _ {{O : LinearOrderStr D}} where
abstract
broken : {b c : D} -> (b < c) -> b < c
broken {b} {c} b<c = b<c
where
b<c2 : b < c
... |
------------------------------------------------------------------------
-- A simple backend
------------------------------------------------------------------------
module RecursiveDescent.Hybrid.Simple where
open import Data.Bool renaming (true to ⊤; false to ⊥)
open import Data.Product.Record
import Data.Product a... |
{-# OPTIONS --cubical --safe #-}
module Cardinality.Finite.SplitEnumerable.Isomorphism where
open import Prelude
open import Container
open import Container.List
open import Data.Fin
open import Container.Membership (ℕ , Fin)
open import Path.Reasoning
open import Data.Sigma.Properties
open import Function.Surjective... |
module Σ where
A : Set₁
A = Set
|
module STLCRef.SemanticsLB where
-- This file contains a definitional interpreter for STLC+Ref as
-- described in Section 3 of the paper. The interpreter operates with
-- the notion of monadic bind described in Section 3.3 of the paper;
-- see `Semantics.agda` for the version of the interpreter of STLC+Ref
-- using m... |
module Library where
open import Function using (id; _∘_; _$_) public
open import Relation.Binary.HeterogeneousEquality public
open ≅-Reasoning renaming (begin_ to proof_) public
open import Data.Product renaming (proj₁ to fst; proj₂ to snd) public
open import Data.Empty public using (⊥; ⊥-elim)
open import Data.Unit ... |
{-# OPTIONS --without-K #-}
open import library.Basics hiding (Type ; Σ)
open import library.types.Sigma
open import Sec2preliminaries
open import Sec3hedberg
open import Sec4hasConstToSplit
-- In this section, we require function extensionality again.
module Sec6populatedness where
-- Definition 6.1
Pop : Type ... |
{-# OPTIONS --type-in-type #-}
U = Set
id : {A : Set} → A → A
id = λ x → x
id2 : ∀ {A} → A → A
id2 = id id
id3 : ∀ {A} → A → A
id3 = λ x → id x
id4 : {A : Set} -> A -> A
id4 = \x -> x
the : (A : Set) → A → A
the = λ _ x → x
constTy = {A B : Set} → A → B → A
const : constTy
const = λ x y → x
constU = const {Se... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
-- Biproducts, a-la Karvonen.
--
-- This definition has advantages over more traditional ones,
-- namely that that we don't require either enrichment in CMon/Ab, or Zero Objects.
--
-- See https://arxiv.org/abs/1801.06488
module Categories.Object.Bipr... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Category.Monoidal.Core using (Monoidal)
module Categories.Category.Monoidal.Rigid {o ℓ e} {C : Category o ℓ e} (M : Monoidal C) where
open import Level
open import Categories.Functor.Bifunctor
open import Categories.NaturalTra... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Instance.StrictGroupoids where
-- The 'strict' category of groupoids.
-- The difference here is that _≈_ is not |NaturalIsomorphism| but |_≡F_|
open import Level
open import Relation.Binary.PropositionalEquality using (refl)
open import Categories.Categor... |
open import Data.PropFormula 2
⋀comm : ∀ {Γ}{φ ψ : PropFormula} → Γ ⊢ φ ∧ ψ ⊃ ψ ∧ φ
⋀comm {Γ} {φ = φ}{ψ} =
⊃-intro $
∧-intro
(∧-proj₂ $ assume {Γ = Γ} $ φ ∧ ψ)
(∧-proj₁ {ψ = ψ} $ assume {Γ = Γ} $ φ ∧ ψ)
|
{-# OPTIONS --without-K #-}
module BitVec where
open import Data.Bool using (Bool; false; true; _∨_; _∧_)
open import Data.Fin using (Fin; toℕ)
open import Data.List using (List; []; _∷_; foldr)
open import Data.Nat using (ℕ; zero; suc; _≡ᵇ_)
open import Data.Product using (_×_; _,_; proj... |
{-# OPTIONS --without-K #-}
module NTypes.Negation where
open import FunExt
open import NTypes
open import Types
¬-isProp : ∀ {a} {A : Set a} → isProp (¬ A)
¬-isProp ¬a _ = funext λ a → 0-elim (¬a a)
|
-- Some theorems about operations on non-deterministic values
module nondet-thms where
open import bool
open import bool-thms
open import nat
open import eq
open import nat-thms
open import functions
open import nondet
----------------------------------------------------------------------
-- Theorems about values co... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
open import Cubical.Foundations.HLevels
module Cubical.Algebra.Semigroup.Construct.Free {ℓ} (Aˢ : hSet ℓ) where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Un... |
-- 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.Unit
module let-output where
private
VEHICLE_PROJECT_F... |
-----------------------------------------------------------------------
-- This file formalizes the proof that Dial₂(Sets) is a full linear --
-- category. See Lemma 12 of the paper. --
-----------------------------------------------------------------------
module FullLinCat where
open im... |
open import Nat
open import Prelude
open import List
open import core
-- erasure of cursor in the types and expressions is defined in the paper,
-- and in the core file, as a function on zexpressions. because of the
-- particular encoding of all the judgments as datatypes and the agda
-- semantics for pattern matching... |
open import Relation.Binary hiding (_⇒_)
open import Level
module Relation.Unary.Monotone {c i}(pre : Preorder i c i) where
open Preorder pre renaming (Carrier to I; _∼_ to _≤_)
open import Relation.Unary
open import Data.Product hiding (map)
open import Data.List
open import Function
record Monotone {ℓ}(p : Pred I ... |
module AKS.Nat where
open import AKS.Nat.Base public
open import AKS.Nat.Properties public
open import AKS.Nat.WellFounded public
open import AKS.Nat.Divisibility public
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.