text stringlengths 4 690k |
|---|
open import FRP.JS.Bool using ( Bool )
open import FRP.JS.True using ( ⊤ ; tt )
open import FRP.JS.String using ( String )
open import FRP.JS.True using ( True )
open import FRP.JS.RSet
open import FRP.JS.Behaviour
module FRP.JS.QUnit where
infixr 4 _,_
data Test : Set where
ε : Test
_,_ : Test → Test → Test
o... |
module _ where
module A where
data D : Set₁ where
!_ : Set → D
infix 3 !_
data C : Set₁ where
#_ : A.D → C
infix 2 #_
module B where
data D : Set₁ where
!_ : C → D
infix 1 !_
open A
open B
ok₁ : B.D → B.D
ok₁ (! # X) = ! # X
... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Setoids.Setoids
open import Sets.EquivalenceRelations
open import Rings.Definition
open import Rings.Homomorphisms.Definition
module Rings.Homomorphisms.Image {a b c d : _} {A : Set a} {B : Set c} {S : Setoid {a} {b} A} {T : S... |
open import Data.Nat
open import Data.Vec
open import Data.List
open import Relation.Binary.PropositionalEquality
open ≡-Reasoning
module DependentFold where
Nat = ℕ
dfold : ∀ {a : Set}
→ {k : Nat}
→ (p : Nat → Set)
→ ((l : Nat) → a → p l → p (1 + l))
→ p 0
→ Vec a k
→ p k
dfold ... |
module Issue1251.NonTerminating where
open import Common.Prelude -- an import is necessary to trigger internal error
-- a non-termination function using imported stuff
bla : Nat → Set
bla zero = bla zero
bla (suc x) = bla x
|
------------------------------------------------------------------------------
-- Well-founded relation on lists based on their structure
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no... |
{-# OPTIONS --cubical --sized-types --type-in-type #-} -- Oh my Nathaniel Hawthorne
module n2o.Network.Internal where
open import proto.Base
open import proto.Map
open import proto.IO
{-# FOREIGN GHC import Network.N2O.Types #-}
postulate
Header : Set
data Event (A : Set) : Set where
Init : Event ... |
module Issue1839.A where
postulate
PrintThis : Set
|
module _ where
-- open import Common.Prelude
module Id (A : Set) where
id : A → A
id x = x
module _ (A : Set) where
open Id A
id2 = id
|
-- Copyright: (c) 2016 Ertugrul Söylemez
-- License: BSD3
-- Maintainer: Ertugrul Söylemez <esz@posteo.de>
module Data.Nat where
open import Algebra.Group
open import Classes
open import Core
open import Data.Nat.Core
open import Data.Nat.Core public
using (ℕ; ℕ-Number; ℕ-Plus; ℕ-Times;
ℕ,≤; module ℕ,≤... |
module RecordConstructorOutOfScope where
record R : Set where
constructor con
id : R
id = con
|
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.ZCohomology.RingStructure.CohomologyRing where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Transport
open import Cubical.Data.Nat renaming (_+_ to _+n_ ; _·_ to _·n_)
open imp... |
open import Relation.Binary
module Data.FingerTree.Relation.Binary.Reasoning.FasterInference.Setoid {ℓ₁ ℓ₂} (setoid : Setoid ℓ₁ ℓ₂) where
open import Relation.Binary.PropositionalEquality as ≡ using (_≡_)
open Setoid setoid
infix 4 _IsRelatedTo_
infix 3 _∎
infixr 2 step-≈ step-≈˘ step-≡ step-≡˘
infixr 2 _≡⟨⟩_
inf... |
module Generic.Test.Data.Vec where
open import Generic.Main
import Data.Vec as Vec
infixr 5 _∷ᵥ_
Vec : ∀ {α} -> Set α -> ℕ -> Set α
Vec = readData Vec.Vec
-- []ᵥ : ∀ {α} {A : Set α} -> Vec A 0
pattern []ᵥ = #₀ lrefl
-- _∷ᵥ_ : ∀ {n α} {A : Set α} -> A -> Vec A n -> Vec A (suc n)
pattern _∷ᵥ_ {n} x xs = !#₁ (relv n... |
-- Andreas, issue reported by Matteo Acerbi, 2014-09-04.
-- Short summary: x = c x is not impossible for coinductive constructors c,
-- so x should not be considered a strictly rigid occurrence in (c x).
-- Matteo:
-- In the following I cannot understand what justifies the absurd pattern
-- in the definition of ¬id≡I... |
open import Common.Prelude
open import Common.Level
open import Common.Reflection
open import Common.Equality
test₁ : quoteTerm lzero ≡ def (quote lzero) []
test₁ = refl
foo : (l : Level) → Bool → Bool
foo _ false = true
foo _ true = false
test₂ : quoteTerm (foo lzero) ≡ def (quote foo) (arg (argInfo visible relevan... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Results concerning uniqueness of identity proofs
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Axiom.UniquenessOfIdentityProofs where
open i... |
------------------------------------------------------------------------------
-- Commutativity of addition of total natural numbers
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-univ... |
module _ where
id : {A : Set} → A → A
id x = x
{-# INLINE id #-}
-- Adding COMPILE to an INLINE'd function has no effect, since the
-- treeless compiler will inline all uses of the function. Hence, we
-- warn the user that the pragma is pointless when compiling.
{-# COMPILE GHC id = \ _ x -> x #-}
|
open import Data.Nat using ()
open import Data.Bool using (true; false)
open import Data.Product using (_×_; _,_)
open import Data.String using (String; _≟_)
open import Data.Empty using ()
open import Level using (suc; _⊔_)
open import Relation.Nullary using (yes; no)
open import Relation.Nullary.Decidable u... |
module Structure.Relator.Properties.Proofs where
import Lvl
open import Data.Tuple as Tuple using (_⨯_ ; _,_)
open import Functional
open import Logic
-- open import Logic.Classical
open import Logic.Propositional
open import Logic.Propositional.Theorems
open import Structure.Relator.Properties
open import Struct... |
{-# OPTIONS --without-K --safe #-}
module Reasoning where
open import PiFrac
------------------------------------------------------------------------------
-- Useful for examples
infixr 2 _⟷⟨_⟩_
infix 3 _□
_⟷⟨_⟩_ : (t₁ : 𝕌) {t₂ : 𝕌} {t₃ : 𝕌} →
(t₁ ⟷ t₂) → (t₂ ⟷ t₃) → (t₁ ⟷ t₃)
_ ⟷⟨ α ⟩ β = α ⊚ β
_... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.List.Relation.Binary.Permutation.Inductive directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
mod... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Lists where all elements satisfy a given property
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Relation.Unary.All where
open impo... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommAlgebra.Instances.Initial where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Unit
open import Cubical.Data.Sigma.Properties using (Σ≡Prop)
open import Cubical.Alge... |
module _ where
module Batch4 where
data D1 (open Star) (A : ★) : ★ where
c : (x : A) → D1 A
data D2 (open Star) : ★ where
data D3 (open Star) : ★₁ where
c : (A : ★) → D3
data D4 : (open Star) → ★ where
data D0 (A : Set) (let B = A → A) : B → Set where
c : (f : B) → D0 A f
module _ where
... |
open import Level hiding ( suc ; zero )
open import Algebra
module sym4 where
open import Symmetric
open import Data.Unit
open import Function.Inverse as Inverse using (_↔_; Inverse; _InverseOf_)
open import Function
open import Data.Nat hiding (_⊔_) -- using (ℕ; suc; zero)
open import Relation.Nullary
open import Da... |
open import Logic
open import Type
module Structure.Sets.Quantifiers {ℓₑ ℓₛ ℓₗ}{E : Type{ℓₑ}}{S : Type{ℓₛ}} (_∈_ : E → S → Stmt{ℓₗ}) where
import Lvl
open import Logic.Propositional
open import Logic.Predicate
open import Syntax.Function
private variable ℓ : Lvl.Level
-- Set restricted existential quantifier.
... |
{-# OPTIONS --without-K --safe #-}
module Source.Term where
open import Source.Size as S using
( Size ; _<_ ; Δ ; Δ′ ; Δ″ ; Ω ; Ω′ ; Ω″ ; n ; m ; o ; b ; v0 ; v1 ; ⋆ )
open import Source.Size.Substitution.Theory
open import Source.Size.Substitution.Canonical as SC using () renaming
( Sub⊢ to Subₛ⊢ )
open import So... |
module Structure.Operator.Group.Proofs where
open import Functional hiding (id)
open import Function.Iteration.Order
import Lvl
open import Lang.Instance
open import Logic.Propositional
open import Logic.Predicate
open import Structure.Setoid
open import Structure.Function.Domain
open import Structure.Operator.Gr... |
open import Agda.Builtin.Nat
data Vec (a : Set) : {n : Nat} → Set where
Nil : Vec a {0}
Cons : {n : Nat} → a → Vec a {n} → Vec a {suc n}
{-# COMPILE AGDA2HS Vec #-}
mapV : {a b : Set} {n : Nat} (f : a → b) → Vec a {n} → Vec b {n}
mapV f Nil = Nil
mapV f (Cons x xs) = Cons (f x) (mapV f xs)
{-# COMPILE AGDA2HS ma... |
{-
The goal of this file is to prove the iso π₄S³≅ℤ/β
where β is a natural number (aka "the Brunerie number",
defined below).
-}
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Homotopy.Group.Pi4S3.BrunerieNumber where
open import Cubical.Homotopy.Loopspace
open import Cubical.Homotopy.Group.B... |
module UniDB.Morph.WeakenPrime where
open import UniDB.Spec
open import UniDB.Morph.ShiftsPrime
open import Function
--------------------------------------------------------------------------------
data Weaken` : MOR where
baseW : {γ : Dom} → Weaken` γ γ
stepW : {γ₁ γ₂ : Dom} → Weaken` γ₁ γ₂ → Weaken` γ₁ (suc ... |
{-# OPTIONS --without-K --safe #-}
-- A cartesian functor preserves products (of cartesian categories)
module Categories.Functor.Cartesian where
open import Data.Product using (Σ; _,_)
open import Level
open import Categories.Category.Cartesian
open import Categories.Category using (Category; _[_,_])
open import Cat... |
{-# OPTIONS --without-K --safe #-}
module Categories.Adjoint.Instance.0-Truncation where
-- The adjunction between 0-truncation and the inclusion functor from
-- Setoids to Categories/Groupoids.
open import Level using (Lift)
open import Data.Unit using (⊤)
import Function
open import Relation.Binary using (Setoid)
... |
module AbstractInterfaces where
open import Prelude public
-- Process identifiers.
record IsProc : Set₁ where
field
Proc : Set
_≡ₚ?_ : Decidable (_≡_ {A = Proc})
_<ₚ_ : Proc → Proc → Set
trans<ₚ : Transitive _<ₚ_
tri<ₚ : Trichotomous _≡_ _<ₚ_
_≮ₚ_ : Proc → Proc → Set
P ≮ₚ P′ = ¬... |
-- Andreas, 2016-12-30, issue #1886, reported by nad
--
-- Omitted hidden parameters are not in scope.
postulate
A : Set
P : A → Set
data D {a} (X : P a) : Set₁
data D X where
c : P a → D _
-- Expected error:
--
-- Not in scope: a
|
{-# OPTIONS --without-K #-}
module Ch2-1 where
open import Level
infixl 4 _≡_
data _≡_ {a} {A : Set a} (x : A) : A → Set a where
refl : x ≡ x
J : {a b : Level} (A : Set a) (C : (x y : A) → x ≡ y → Set b)
→ ((x : A) → C x x refl)
→ (x y : A) (P : x ≡ y)
→ C x y P
J A C b x .x refl = b x
-- K : (A : S... |
------------------------------------------------------------------------
-- The "interval"
------------------------------------------------------------------------
{-# OPTIONS --erased-cubical --safe #-}
-- Partly based on the HoTT book.
-- The module is parametrised by a notion of equality. The higher
-- constructo... |
-- Andreas, 2017-01-26.
-- The --no-eta-equality option
{-# OPTIONS --no-eta-equality #-}
{-# OPTIONS --allow-unsolved-metas #-}
-- is only valid for the record types defined in this file.
open import HaveEtaForImportedRecords.EtaRecord
-- Eta holds for the imported record.
test-imported : ∀{x y : ⊤} → x ≡ y
test-... |
------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Correctness of differentiation (Lemma 3.10 and Theorem 3.11).
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
imp... |
module Data.Nat.Properties.Extra where
open import Data.Nat
open import Data.Product
open import Data.Nat.Properties
open import Data.Nat.Properties.Simple
open import Function
open import Level using ()
open import Relation.Binary
open import Relation.Binary.Core
open import Relation.Nullary.Negation
open import Rela... |
open import Data.List using () renaming
( List to ♭List ; [] to []♭ ; _∷_ to _∷♭_ ; _++_ to _++♭_
; length to length♭ ; map to ♭map )
open import Data.Maybe using ( Maybe ; just ; nothing )
open import Data.Nat using ( zero ; suc ) renaming ( _+_ to _+♭_ )
open import Function using () renaming ( _∘′_ to _∘_ )
ope... |
-- Andreas, 2012-02-14. No short-circuit conversion test for sizes!
{-# OPTIONS --sized-types --show-implicit #-}
-- {-# OPTIONS -v tc.size.solve:20 -v tc.conv.size:20 -v tc.term.con:50 -v tc.term.args:50 #-}
module Issue298b where
open import Common.Size
data BTree : {size : Size} → Set where
leaf : {i : Size} →... |
{-# OPTIONS --without-K #-}
module PiTracedLevel0 where
open import Data.Empty using (⊥; ⊥-elim)
open import Data.Unit using (⊤; tt)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Data.Product using (_×_; _,_; proj₁; proj₂)
--------------------------------------------------------------------------... |
{-# OPTIONS --rewriting --without-K #-}
open import Prelude
open import GSeTT.Syntax
open import GSeTT.Rules
open import GSeTT.Disks
open import GSeTT.Uniqueness-Derivations
open import GSeTT.Dec-Type-Checking
open import CaTT.Ps-contexts
open import CaTT.Relation
open import CaTT.Uniqueness-Derivations-Ps
module CaT... |
open import FRP.JS.String using ( _<_ )
open import FRP.JS.True using ( True )
module FRP.JS.String.Properties where
postulate
<-trans : ∀ {k l m} → True (k < l) → True (l < m) → True (k < m)
|
{-# OPTIONS --without-K --safe #-}
open import Categories.Category using () renaming (Category to Setoid-Category)
open import Categories.Category.Monoidal using (Monoidal)
module Categories.Enriched.Functor {o ℓ e} {V : Setoid-Category o ℓ e}
(M : Monoidal V) where
open import Lev... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Unsafe machine word operations
------------------------------------------------------------------------
{-# OPTIONS --with-K #-}
module Data.Word.Unsafe where
import Data.Nat as ℕ
open import Data.Word using (... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import cohomology.Theory
open import groups.Exactness
open import groups.ExactSequence
open import cw.CW
module cw.cohomology.HigherCoboundaryGrid {i} (OT : OrdinaryTheory i)
{n} (⊙skel : ⊙Skeleton {i} (S (S n))) (ac : ⊙has-cells-with-choice 0 ⊙skel i) ... |
-- Andreas, 2019-04-10, re #3687, better test case for #1926
-- {-# OPTIONS -v interaction.contents.record:20 #-}
module _ (Foo : Set) where
open import Agda.Builtin.Sigma
test : {A : Set} {B : A → Set} (r : Σ A B) → Set
test r = {!r!} -- C-c C-o
|
{- Conatural numbers (Tesla Ice Zhang, Feb. 2019)
This file defines:
- A coinductive natural number representation which is dual to
the inductive version (zero | suc Nat → Nat) of natural numbers.
- Trivial operations (succ, pred) and the pattern synonyms on conaturals.
While this definition can be seen as a coin... |
-- Andreas, 2016-06-21, issue #2054
-- Size solver should not default to ∞ in where block signatures
-- {-# OPTIONS --v tc.size:20 #-}
-- {-# BUILTIN SIZEUNIV SizeU #-}
-- {-# BUILTIN SIZE Size #-}
-- {-# BUILTIN SIZESUC ↑_ #-}
-- {-# BUILTIN SIZEINF ∞ #-}
open import Common.Size
data N : Size → Set... |
open import Agda.Builtin.Nat
data Vec (A : Set) : Nat → Set where
[] : Vec A 0
cons : (n : Nat) → A → Vec A n → Vec A (suc n)
tail : {A : Set} (n : Nat) → Vec A (suc n) → Vec A n
tail n (cons n x xs) = xs
tail' : {A : Set} (n : Nat) → Vec A (suc n) → Vec A n
tail' 0 (cons 0 x []) = []
tail' (suc n) (cons (suc n)... |
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Properties.Successor {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.LogicalRe... |
open import Nat
open import Prelude
open import core
open import contexts
open import typed-elaboration
open import lemmas-gcomplete
open import lemmas-complete
module complete-elaboration where
mutual
complete-elaboration-synth : ∀{e τ Γ Δ d} →
Γ gcomplete →
... |
------------------------------------------------------------------------
-- Universe levels
------------------------------------------------------------------------
module Common.Level where
postulate
Level : Set
lzero : Level
lsuc : (i : Level) → Level
_⊔_ : Level -> Level -> Level
{-# IMPORT Common.FFI ... |
module Forcing4 where
open import Common.Nat renaming (zero to Z; suc to S)
open import Lib.Fin
open import Common.Equality
open import Common.String
open import Common.IO
open import Common.Unit
{-
toNat : {n : Nat} → Fin n → Nat
toNat (zero _) = 0
toNat (suc _ i) = suc (toNat i)
-}
Rel : (X : Set) -> Set1
Rel X... |
module NatIf3 where
open import Data.Nat
open import Data.Vec
natIf3 : (a : Set) -> a -> a -> a -> ℕ -> a
natIf3 a x y z zero = x
natIf3 a x y z (suc zero) = y
natIf3 a x y z (suc (suc n)) = z
nilNat : Vec ℕ 0
nilNat = []
--test1 = natIf3 _ 1 nilNat 3 0
test2 = natIf3 _ nilNat 2 3 0
|
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module FOT.Common.FOL.Existential.Syntax where
-- We add 3 to the fixities of the Agda standard library 0.8.1 (see
-- Relation.Binary.Core).
infix... |
module prelude.int where
open import Data.Nat as Nat renaming (suc to s; zero to z)
open import Agda.Builtin.Int public
⁺1 : Int → Int
⁺1 (pos n) = pos (s n)
⁺1 (negsuc z) = pos z
⁺1 (negsuc (s n)) = negsuc n
⁻1 : Int → Int
⁻1 (pos Nat.zero) = negsuc Nat.zero
⁻1 (pos (Nat.suc n)) = pos n
⁻1 (negsuc n) = negsuc (Nat.s... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Category.Cartesian.Properties {o ℓ e} (C : Category o ℓ e) where
open import Function using (_$_)
open import Categories.Category.Cartesian C
open import Categories.Diagram.Pullback C
open import Categories.Diagram.Equalizer C
ope... |
-- Andreas, 2012-11-06 this has been fixed with issue 655
module Issue378 where
infix 7 _≡_
infixl 9 _+_
postulate
ℕ : Set
_≡_ : ℕ → ℕ → Set
zero : ℕ
_+_ : ℕ → ℕ → ℕ
postulate
S₁ : ∀ {m n o} → m ≡ n → m ≡ o → n ≡ o
S₅ : ∀ n → zero + n ≡ n
-- Calling Auto on the hole generates the invalid expressio... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Creates trivially indexed records from their non-indexed counterpart.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Relation.Binary.Indexed.H... |
open import Oscar.Prelude
open import Oscar.Class.Reflexivity
open import Oscar.Class.Transitivity
open import Oscar.Class.Transextensionality
open import Oscar.Class.Transassociativity
module Oscar.Class.IsPrecategory where
module _
{𝔬} {𝔒 : Ø 𝔬}
{𝔯} (_∼_ : 𝔒 → 𝔒 → Ø 𝔯)
{ℓ} (_∼̇_ : ∀ {x y} → x ∼ y → x ... |
{- 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
module LibraBFT.ImplShared.Util.Dijkstra.... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommMonoid.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphis... |
module Common where
open import Agda.Builtin.Size public
using (Size ; Size<_)
renaming (ω to ∞)
open import Agda.Primitive public
using ()
renaming (_⊔_ to _⊔ᴸ_ ; lsuc to sucᴸ)
open import Data.Bool public
using (true ; false)
renaming (Bool to 𝔹 ; _∧_ to _∧ᴮ_ ; _∨_ to _∨ᴮ_ ; not to ¬ᴮ_ ; if_then_else_... |
------------------------------------------------------------------------
-- Lists where at least one element satisfies a given property
------------------------------------------------------------------------
module Data.List.Any where
open import Data.Empty
open import Data.Fin
open import Data.Function
open import ... |
-- The category of monadic functions.
open import Level
open import Relation.Binary
open import Relation.Binary.PropositionalEquality
open import Axiom.FunctionExtensionality
open import Control.Monad
open import Control.Category
module Control.Kleisli where
-- The type of monadic functions.
Kleisli : (M : Set →... |
------------------------------------------------------------------------------
-- The FOTC types without using data, i.e. using Agda as a logical framework
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-... |
{-# OPTIONS --safe #-}
module Issue639-2 where
postulate A : Set
|
module Trees where
open import Data.Unit using (⊤)
data BinTree {a} (A : Set a) : Set a where
Empty : A → BinTree A
Node : A → BinTree A → BinTree A → BinTree A
BareBinTree : Set
BareBinTree = BinTree ⊤
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties related to list membership
------------------------------------------------------------------------
-- List membership is defined in Data.List.Any. This module does not
-- treat the general variant of... |
{-# OPTIONS --without-K --safe #-}
module Cats.Util.SetoidReasoning where
open import Relation.Binary.Reasoning.MultiSetoid public
open import Relation.Binary using (Setoid)
module _ {c ℓ} (S : Setoid c ℓ) where
open Setoid S
triangle :
∀ m {x y}
→ x ≈ m
→ y ≈ m
→ x ≈ y
triangle m x≈m y≈m = t... |
-- {-# OPTIONS -v tc.meta:30 #-}
module GiveSize where
{-# BUILTIN SIZE Size #-}
postulate
A : Size → Set
c : ∀ i → A i
k : ∀ i → A i
k i = c {!i!}
|
{-# OPTIONS --allow-unsolved-metas #-}
-- This file documents a bug caused by one of the fixes for issue 153.
module Issue153 where
open import Common.Coinduction
record R : Set₁ where
field
S : Set
T : S → Set
module D (r : R) (s : R.S r) where
open R r
data D (t : T s) : Set where
module M (r : R... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Groups.Definition
open import Setoids.Setoids
open import Sets.EquivalenceRelations
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
-- Following Part IB's course Groups, Rings, and Modules, we take rings to be commutative with one.
module Ring... |
module MLib.Matrix.Core where
open import MLib.Prelude
open import MLib.Algebra.PropertyCode
open import MLib.Algebra.PropertyCode.Structures
import Relation.Binary.Indexed as I
Matrix : ∀ {a} → Set a → ℕ → ℕ → Set a
Matrix A m n = Fin m → Fin n → A
module _ {a} (A : Set a) where
row : ∀ {m n} → Fin m → Matrix A ... |
module to-string-tests where
open import lib
open import cedille-types
open import syntax-util
open import to-string
t = mapp (mapp (mvar "plus") (mvar "Z")) (mvar "Z")
s = term-to-string t
|
-- 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... |
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution {{eqrel : EqRelSet}} where
open import Agda.Primitive
open import Definition.Untyped
open import Definition.Typed
open import Definition.LogicalRelation
open import Tools.Embedding
open i... |
module ExpressionChanging where
open import ParseTree
open import Data.Maybe hiding (map)
open import Data.List.NonEmpty
open import ParseTreeOperations
open import AgdaHelperFunctions
open import Data.List
open import Data.Nat
open import Data.Vec using (Vec)
open import Data.Fin
open import ScopeState
import Data.Nat... |
{-# OPTIONS --without-K --safe #-}
module Categories.Adjoint.Instance.Core where
-- The adjunction between the forgetful functor from Cats to Groupoids
-- and the Core functor.
open import Level using (_⊔_)
import Function
open import Categories.Adjoint using (_⊣_)
open import Categories.Category using (Category)
i... |
{-# OPTIONS --without-K #-}
module Fiber where
open import Equivalence
open import NTypes.Contractible
open import PathOperations
open import Types
fib : ∀ {a b} {A : Set a} {B : Set b}
(f : A → B) (y : B) →
Set _
fib {A = A} f y = Σ A λ x → f x ≡ y
fib→dom : ∀ {a b} {A : Set a} {B : Set b} (f : A → B) →
Σ B (... |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Monoidal.Braided.Helpers where
open import Categories.Monoidal.Helpers
open import Data.Nat using (_+_)
open import Function using (flip)
open import Categories.Category
import Categories.Functor
open import Categories.Bifunctor hiding (identityˡ; identityʳ;... |
module Data.ListNonEmpty where
open import Data.Boolean
import Data.IndexedList
open import Functional
import Lvl
open import Numeral.Natural
open import Type
private variable ℓ : Lvl.Level
private variable T : Type{ℓ}
module _ (T : Type{ℓ}) where
open Data.IndexedList(T){Bool} using (IndexedList ; intro... |
{-# OPTIONS --universe-polymorphism #-}
open import Categories.Category
open import Categories.Support.Equivalence
module Categories.Morphism.Indexed {o ℓ e c q} (C : Category o ℓ e) (B : Setoid c q) where
open import Level using (_⊔_)
open import Data.Product as P using (_,_; _×_)
open import Function as F using () ... |
{-# OPTIONS --cubical --safe #-}
-- Counterpoint Exercises
module Exercises where
open import MidiEvent
open import Note
open import Pitch
open import Data.Fin
open import Data.List
open import Data.Nat
-- Exercise 5.4
cantusFirmus : List Pitch
cantusFirmus = a 4 ∷ c 5 ∷ b 4 ∷ c 5 ∷ d 5 ∷ e 5 ∷ c 5 ∷ b 4 ∷ a 4 ∷ ... |
module examplesPaperJFP.SpaceShipSimpleVar where
open import SizedIO.Base
open import StateSizedIO.GUI.BaseStateDependent
open import Data.Bool.Base
open import Data.List.Base
open import Data.Integer
open import Data.Product hiding (map)
open import SizedIO.Object
open import SizedIO.IOObject
open import NativeIO
... |
-- {-# OPTIONS --no-coverage #-}
-- {-# OPTIONS -v tc.cover:20 #-}
open import Common.Bool
open import Common.Equality
_∨_ : Bool → Bool → Bool
a ∨ b = if a then true else b
module Works where
data Term : Bool → Set where
I : Term false
App : ∀ a b c → a ∨ b ≡ c → Term a → Term b → Term c
-- The follo... |
{-# OPTIONS --without-K --safe #-}
open import Algebra
module Data.FingerTree.View
{r m}
(ℳ : Monoid r m)
where
open import Level using (_⊔_)
open import Data.Product
open import Function
open import Data.List as List using (List; _∷_; [])
open import Data.FingerTree.Structures ℳ
open import Data.FingerTree.... |
module Logic.Predicate.Multi where
open import Data.Tuple.RaiseTypeᵣ
open import Function.Multi
open import Function.Multi.Functions
open import Numeral.Natural
open import Logic.Predicate
open import Logic
-- Universal quantification of multiple variables.
-- Example:
-- ∀₊(3) P = ∀{x}{y}{z} → P(x)(y)(z)
∀₊ : (n :... |
{-# OPTIONS --cubical --safe --no-sized-types --no-guardedness
--no-subtyping #-}
module Agda.Builtin.Cubical.Glue where
open import Agda.Primitive
open import Agda.Builtin.Sigma
open import Agda.Primitive.Cubical renaming (primINeg to ~_; primIMax to _∨_; primIMin to _∧_;
... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.RingSolver.NatAsAlmostRing where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat
open import Cubical.Algebra.RingSolver.AlmostRing
open import Cubical.Algebra.Semigroup
open import Cubical.Algebra.Monoid
open import Cubical.... |
open import Nat
open import Prelude
open import core
open import contexts
open import lemmas-consistency
open import type-assignment-unicity
open import binders-disjoint-checks
open import lemmas-subst-ta
module preservation where
-- if d and d' both result from filling the hole in ε with terms of the
-- same ty... |
{-# OPTIONS --without-K --safe #-}
module Categories.NaturalTransformation.NaturalIsomorphism.Properties where
open import Level
open import Categories.Category
open import Categories.Category.Instance.Setoids
open import Categories.Functor renaming (id to idF)
open import Categories.Functor.Construction.LiftSetoids... |
{-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Implementation.Standard where
module Data where
module Empty where open import Light.Implementation.Standard.Data.Empty public
module Unit where open import Light.Implementation.Standard.Data.Unit public
mod... |
module Oscar.Data where
open import Agda.Builtin.Unit
open import Oscar.Function
open import Oscar.Level
infixr 20 ∷_
infixr 20 _∷_
data NAT : Set where
∅ : NAT
∷_ : NAT → NAT
testNAT : NAT
testNAT = ∷ ∷ ∷ ∅
-- List
data ⟦_⟧ {a} (A : Set a) : Set a where
∅ : ⟦ A ⟧
_∷_ : A → ⟦ A ⟧ → ⟦ A ⟧
-- Nat
⟦⟧ = ⟦ ⊤ ... |
open import Agda.Builtin.Nat
record R : Set where
field
x : Nat
open R {{...}}
f₁ f₂ : R
-- This is fine.
x ⦃ f₁ ⦄ = 0
-- THIS WORKS BUT MAKES NO SENSE!!!
f₂ ⦃ .x ⦄ = 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.