text stringlengths 4 690k |
|---|
module Data.List.Equiv where
open import Logic.Propositional
import Lvl
open import Data.List
open import Structure.Operator
open import Structure.Setoid
open import Type
private variable ℓ ℓₑ ℓₚ : Lvl.Level
private variable T : Type{ℓ}
-- A correct equality relation on lists should state that prepend is a func... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Groups.Lemmas
open import Groups.Definition
open import Setoids.Orders.Partial.Definition
open import Setoids.Orders.Total.Definition
open import Setoids.Setoids
open import Functions.Definition
open import Sets.EquivalenceRelat... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.AbGroup.TensorProduct where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function hiding (flip)
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLe... |
module int where
open import bool
open import eq
open import nat
open import product
----------------------------------------------------------------------
-- datatypes
----------------------------------------------------------------------
data pol : Set where
pos : pol
neg : pol
data sign : Set where
nonzero... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.Group.Instances.Int where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Int
renaming (ℤ to ℤType ; _+_ to _+ℤ_ ; _-_ to _-ℤ_; -_ to -ℤ_ ; _·_ to _·ℤ_)
open import Cubical.Algebra.Group.Base
open import Cubica... |
{-# OPTIONS --without-K --rewriting #-}
{-
This file contains a bunch of basic stuff which is needed early.
Maybe it should be organised better.
-}
module lib.Base where
{- Universes and typing
Agda has explicit universe polymorphism, which means that there is an actual
type of universe levels on which you can quan... |
{-# OPTIONS --show-implicit #-}
module AgdaFeatureTerminationViaExplicitness where
data Nat : Set where
zero : Nat
suc : (n : Nat) → Nat
id : {A : Set} → A → A
id = λ x → x
data Pat (n : Nat) : Set where
pzero : Pat n
psuc : Pat n → Pat n
data Cat : Nat → Set where
cat : ∀ {n} → Cat (suc n)
postulate
... |
{-# OPTIONS --rewriting --confluence-check #-}
module Issue4333.M where
postulate
A : Set
_==_ : A → A → Set
{-# BUILTIN REWRITE _==_ #-}
postulate
a a₀' a₁' : A
p₀ : a == a₀'
p₁ : a == a₁'
B : A → Set
b : B a
|
{-# OPTIONS --without-K --safe #-}
open import Algebra
open import Data.Bool.Base using (Bool; if_then_else_)
open import Function.Base using (_∘_)
open import Data.Integer.Base as ℤ
using (ℤ; +_; +0; +[1+_]; -[1+_]; +<+; +≤+)
import Data.Integer.Properties as ℤP
open import Data.Integer.DivMod as ℤD
open i... |
-- 2010-09-29 Andreas, mail to Ulf
module ExistentialsProjections where
postulate
.irrelevant : {A : Set} -> .A -> A
record Exists (A : Set) (P : A -> Set) : Set where
constructor exists
field
.fwitness : A
fcontent : P fwitness
.witness : forall {A P} -> (x : Exists A P) -> A
witness (exists a p) = ir... |
------------------------------------------------------------------------
-- Some definitions related to and properties of finite sets
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
module Fin
{reflexive} (eq : ∀ {a p} → Equality-with... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties satisfied by total orders
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
module Relation.Binary.Properties.To... |
{-# OPTIONS --without-K #-}
open import HoTT.Base
open import HoTT.HLevel
open import HoTT.HLevel.Truncate
open import HoTT.Logic
open import HoTT.Identity
open import HoTT.Identity.Identity
open import HoTT.Identity.Coproduct
open import HoTT.Identity.Sigma
open import HoTT.Identity.Pi
open import HoTT.Identity.Univer... |
{-# OPTIONS --without-K #-}
module sets.vec.core where
open import function.core
open import sets.nat.core using (ℕ; zero; suc)
open import sets.fin
data Vec {i}(A : Set i) : ℕ → Set i where
[] : Vec A 0
_∷_ : ∀ {n} → A → Vec A n → Vec A (suc n)
infixr 5 _∷_
head : ∀ {i}{A : Set i}{n : ℕ} → Vec A (suc n) → A
hea... |
-- Andreas, 2020-05-08, issue #4637
-- Print record pattern (in with-function) in termination error.
-- {-# OPTIONS -v reify:60 #-}
record R : Set where
pattern; inductive
field foo : R
postulate
bar : R → R
test : R → R
test r with bar r
test r | record { foo = x } with bar x
test r | record { foo = x } | _ ... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Lists.Definition
open import Lists.Fold.Fold
open import Lists.Concat
open import Lists.Length
open import Numbers.Naturals.Semiring
module Lists.Monad where
open import Lists.Map.Map public
flatten : {a : _} {A : Set a} → (l... |
-- Andreas, 2013-06-22, bug reported by evancavallo
{-# OPTIONS --allow-unsolved-metas #-}
-- {-# OPTIONS -v tc.conv:20 -v impossible:100 #-}
module Issue874 where
record Σ (A : Set) (B : A → Set) : Set where
constructor _,_
field
fst : A
snd : B fst
module _ {A : Set} where
postulate
P : A → Set
... |
{-# OPTIONS --without-K --safe #-}
-- adding eta/epsilon to PiPointed
-- separate file for presentation in paper
module PiPointedFrac where
open import Data.Empty
open import Data.Unit
open import Data.Sum
open import Data.Product
open import Relation.Binary.PropositionalEquality
open import Singleton
infixr 90 _#... |
module Formalization.LambdaCalculus.SyntaxTransformation where
open import Formalization.LambdaCalculus
open import Lang.Instance
open import Numeral.Natural
open import Numeral.Finite
open import Numeral.Finite.Bound
open import Numeral.Natural.Relation.Order
open import Numeral.Natural.Relation.Order.Proofs
open imp... |
{-# OPTIONS --cubical --no-import-sorts --no-exact-split --safe #-}
module Cubical.HITs.InfNat.Properties where
open import Cubical.Core.Everything
open import Cubical.Data.Maybe
open import Cubical.Data.Nat
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.HITs... |
{-# OPTIONS --cubical --safe #-}
module Function.Surjective where
open import Function.Surjective.Base public
|
module Issue3295 where
open import Issue3295.Incomplete
open import Issue3295.Incomplete2
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
_ : f 0 ≡ 0
_ = {!!}
_ : g 0 ≡ 0
_ = {!!}
_ : f 1 ≡ 1 -- the evaluation of `f` should be blocked here
_ = {!!} -- so looking at the normalised type should not c... |
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (Poset)
-- A thin (or posetal) category is a category with at most one
-- morphism between any pair of objects.
--
-- As explained on nLab:
--
-- "Up to isomorphism, a thin category is the same thing as a
-- proset. Up to equivalence, a thin cat... |
{-# OPTIONS --safe --without-K #-}
open import Data.Char.Base using (Char)
open import Data.List.Base using (List; []; _∷_)
module PiCalculus.Syntax where
Name : Set
Name = List Char
module Raw where
infixr 20 _∥_
infixr 15 ⦅ν_⦆_
infixr 10 _⦅_⦆_ _⟨_⟩_
data Raw : Set where
𝟘 : Raw
⦅ν_⦆_ : Name ... |
{-
Day 3, 1st part
-}
module a3 where
open import Agda.Builtin.IO using (IO)
open import Agda.Builtin.Unit using (⊤)
open import Agda.Builtin.String using (String; primShowNat)
open import Agda.Builtin.Equality
open import Data.Nat
open import Data.Bool
open import Data.List hiding (lookup;allFin)
... |
{-# OPTIONS --prop --without-K #-}
module Data.Nat.Square where
open import Data.Nat
open import Data.Nat.Properties
open import Relation.Nullary
open import Relation.Binary
open import Relation.Binary.PropositionalEquality as Eq using (_≡_; refl)
_² : ℕ → ℕ
n ² = n * n
n^2≡n² : ∀ n → n ^ 2 ≡ n ²
n^2≡n² n = Eq.con... |
module Structure.Type.Quotient where
import Lvl
open import Logic
open import Logic.Propositional
open import Structure.Function hiding (intro)
open import Structure.Function.Domain hiding (intro)
open import Structure.Relator.Equivalence hiding (intro)
open import Structure.Setoid hiding (intro)
import Type... |
module GUIgeneric.Prelude where
open import Data.Sum public hiding (map)
open import Data.List public
open import Data.Bool public
open import Data.String hiding (decSetoid) renaming (_++_ to _++Str_; _==_ to _==Str_; _≟_ to _≟Str_) public
open import Data.Unit hiding (_≟_; decSetoid; setoid) public
open import Data.E... |
module Dave.Extensionality where
open import Dave.Equality
postulate
extensionality : ∀ {A B : Set} {f g : A → B}
→ (∀ (x : A) → f x ≡ g x)
→ f ≡ g
postulate
∀-extensionality : ∀ {A : Set} {B : A → Set} {f g : ∀(x : A) → B x}
→ (∀ (x : A) → f x ≡ g x)
... |
module Cats.Category.Preorder where
open import Data.Unit using (⊤ ; tt)
open import Level
open import Relation.Binary as Rel
using (Rel ; IsEquivalence ; _Preserves₂_⟶_⟶_ ; Setoid)
open import Cats.Category
open import Cats.Category.Setoids using (Setoids ; ≈-intro)
open import Cats.Util.Conv
open import Cats.Util... |
module plfa.part1.Isomorphism where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong; cong-app)
open Eq.≡-Reasoning
open import Data.Nat using (ℕ; zero; suc; _+_)
open import Data.Nat.Properties using (+-comm)
|
module Issue2447.Internal-error where
import Issue2447.M
{-# IMPOSSIBLE #-}
|
{-# OPTIONS --without-K #-}
module sets.nat.ordering.lt where
open import sets.nat.ordering.lt.core public
open import sets.nat.ordering.lt.level public
|
module Thesis.SIRelBigStep.DLangDerive where
open import Thesis.SIRelBigStep.DSyntax public
derive-const : ∀ {Δ σ} → (c : Const σ) → DSVal Δ σ
derive-const (lit n) = dconst (lit 0)
derive-dterm : ∀ {Δ σ} → (t : Term Δ σ) → DTerm Δ σ
derive-dsval : ∀ {Δ σ} → (t : SVal Δ σ) → DSVal Δ σ
derive-dsval (var x) = dvar x
d... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.elims.CofPushoutSection as CofPushoutSection
module homotopy.SmashIsCofiber {i j} (X : Ptd i) (Y : Ptd j) where
{- the proof that our smash matches the more classical definition as a cofiber -}
Smash-equiv-Cof : Smash X Y ≃ Cofiber (∨-to-... |
------------------------------------------------------------------------
-- The abstract syntax is a set, and the semantics is propositional
------------------------------------------------------------------------
open import Atom
module Propositional (atoms : χ-atoms) where
open import Equality.Propositional.Cubica... |
{-# OPTIONS --safe #-}
module Cubical.HITs.Sn.Properties where
open import Cubical.Foundations.Pointed
open import Cubical.Foundations.Path
open import Cubical.Foundations.Function
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubi... |
open import Data.Product using ( ∃ ; _×_ ; _,_ ; proj₁ ; proj₂ )
open import Relation.Unary using ( _∈_ )
open import Web.Semantic.DL.TBox.Interp using
( Interp ; Δ ; _⊨_≈_ ; con ; rol ; ≈-refl ; ≈-sym ; ≈-trans ; con-≈ ; rol-≈ )
open import Web.Semantic.DL.Signature using ( Signature )
open import Web.Semantic.Util ... |
{-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Implementation.Data.Empty where
open import Light.Library.Data.Empty using (Library ; Dependencies)
open import Light.Level using (0ℓ)
open import Light.Variable.Sets
instance dependencies : Dependencies
dependencies = recor... |
-- Andreas, 2018-06-19, issue #3130
-- Do not treat .(p) as projection pattern, but always as dot pattern.
record R : Set₁ where
field f : Set
open R
-- Shouldn't pass.
mkR : (A : Set) → R
mkR A .(f) = A
|
-- Alternative proof of LLPO => MP∨
{-# OPTIONS --without-K --safe #-}
module Constructive.Axiom.Properties.Alternative where
-- agda-stdlib
open import Level renaming (suc to lsuc; zero to lzero)
open import Data.Empty using (⊥; ⊥-elim)
open import Data.Unit using (⊤; tt)
open import Data.Bool using (Bool; true; fa... |
-- Andreas, 2021-04-28, issue #5336
-- data...where is already extensible.
module _ where
module C where
postulate
Name QName : Set
variable
x y : C.Name
xs ys : C.QName
interleaved mutual
-- Scope of a declaration.
data Scope : Set
variable
sc sc' : Scope
-- Declarations in a scope.
d... |
{-# OPTIONS --rewriting #-}
{-# OPTIONS --no-fast-reduce #-}
open import Agda.Builtin.Equality
{-# BUILTIN REWRITE _≡_ #-}
data A : Set where
a b : A
postulate rew : a ≡ b
{-# REWRITE rew #-}
test : a ≡ b
test = refl
|
module Lvl.Functions where
open import Lvl
open import Numeral.Natural
add : ℕ → Lvl.Level → Lvl.Level
add ℕ.𝟎 ℓ = ℓ
add (ℕ.𝐒 n) ℓ = Lvl.𝐒(add n ℓ)
|
module RawSemantics where
open import Data.Maybe
open import Data.Nat hiding (_⊔_; _⊓_)
open import Data.Product
open import Data.Sum
open import Data.String using (String)
open import Data.Unit hiding (_≟_)
open import Data.Empty
open import Function using (_∘_)
open import Relation.Nullary
import Relation.Binary.P... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Many properties which hold for `∼` also hold for `flip ∼`. Unlike
-- the module `Relation.Binary.Construct.Flip` this module does not
-- flip the underlying equality.
---------------------------------------------... |
-- {-# OPTIONS -v tc.conv:50 -v tc.reduce:100 -v tc:50 -v tc.term.expr.coind:15 -v tc.meta:20 #-}
-- 2012-03-15, reported by Nisse
module Issue585 where
open import Common.Coinduction
data ℕ : Set where
zero : ℕ
suc : (n : ℕ) → ℕ
data Fin : ℕ → Set where
zero : ∀ {n} → Fin (suc n)
suc : ∀ {n} → Fin... |
module IPC.Metatheory.Gentzen-KripkeExploding where
open import IPC.Syntax.Gentzen public
open import IPC.Semantics.KripkeExploding public
-- Soundness with respect to all models, or evaluation.
eval : ∀ {A Γ} → Γ ⊢ A → Γ ⊨ A
eval (var i) γ = lookup i γ
eval (lam {A} {B} t) γ = return {A ▻... |
-- 2013-11-xx Andreas
-- Previous clauses did not reduce in later clauses under
-- a module telescope.
{-# OPTIONS --copatterns #-}
-- {-# OPTIONS -v interaction.give:20 -v tc.cc:60 -v reify.clause:60 -v tc.section.check:10 -v tc:90 #-}
-- {-# OPTIONS -v tc.lhs:20 #-}
-- {-# OPTIONS -v tc.cover:20 #-}
module Issue937... |
-- 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... |
open import Functional
open import Logic
open import Logic.Propositional
open import Type
module Relator.Ordering where
module From-[<][≡] {ℓ₁}{ℓ₂}{ℓ₃} {T : Type{ℓ₁}} (_<_ : T → T → Stmt{ℓ₂}) (_≡_ : T → T → Stmt{ℓ₃}) where
-- Greater than
_>_ : T → T → Stmt
_>_ = swap(_<_)
-- Lesser than or equals
_≤_ : T ... |
{-
This second-order equational theory was created from the following second-order syntax description:
syntax Sub | S
type
L : 0-ary
T : 0-ary
term
vr : L -> T
sb : L.T T -> T
theory
(C) x y : T |> sb (a. x[], y[]) = x[]
(L) x : T |> sb (a. vr(a), x[]) = x[]
(R) a : L x : L.T |> sb (b. x[b], vr(... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import LogicalFormulae
open import Functions.Definition
module Orders.Partial.Definition {a : _} (carrier : Set a) where
record PartialOrder {b : _} : Set (a ⊔ lsuc b) where
field
_<_ : Rel {a} {... |
module x08-747Quantifiers-hc where
-- Library
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong; sym)
open import Data.Nat using (ℕ; zero; suc; _+_; _*_; _≤_; z≤n; s≤s) -- added ≤
-- open import Data.Nat.Properties using (≤-refl)
open import Relation.Nullary using (¬_)
open import Data... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.Vec.Relation.Unary.Any directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Vec.Any whe... |
{-# OPTIONS --safe #-}
module Cubical.Categories.NaturalTransformation.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism renaming (iso to iIso)
open import Cubical.Data.Sigma
open imp... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Divisibility
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Nat.Divisibility where
open import Algebra
open import Data.Nat as Nat
open ... |
{- 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.Types
open import... |
------------------------------------------------------------------------------
-- Testing the use of local hints
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-... |
{-# OPTIONS --cubical --safe #-}
-- Free join semilattice
module Algebra.Construct.Free.Semilattice where
open import Algebra.Construct.Free.Semilattice.Definition public
open import Algebra.Construct.Free.Semilattice.Eliminators public
open import Algebra.Construct.Free.Semilattice.Union public using (_∪_; 𝒦-semila... |
open import Agda.Primitive
open import Agda.Builtin.Sigma
open import Agda.Builtin.Equality
record R {A : Set} {B : A → Set} p@ab : Set where
field
prf : p ≡ p
|
module PreludeList where
open import AlonzoPrelude as Prelude
open import PreludeNat
infixr 50 _::_ _++_
data List (A : Set) : Set where
[] : List A
_::_ : A -> List A -> List A
{-# BUILTIN LIST List #-}
{-# BUILTIN NIL [] #-}
{-# BUILTIN CONS _::_ #-}
[_] : {A : Set} -> A -> List A
[ x ] = x :: []
l... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Functor.Core where
open import Level
open import Function renaming (id to id→; _∘_ to _●_) using ()
open import Relation.Binary hiding (_⇒_)
import Relation.Binary.Reasoning.Setoid as SetoidR
import Categories.Morphism as M
priva... |
module *-comm where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong; sym)
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_; step-≡; _∎)
open import Data.Nat using (ℕ; zero; suc; _+_; _*_)
open import Induction′ using (+-assoc; +-comm; +-suc)
open import +-swap using (+-swap)
*-comm : ∀ (m n... |
{-
Maybe structure: X ↦ Maybe (S X)
-}
{-# OPTIONS --cubical --no-import-sorts --no-exact-split --safe #-}
module Cubical.Structures.Relational.Maybe where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
... |
{-# OPTIONS --sized-types #-}
module SizedTypesVarSwap where
postulate
Size : Set
_^ : Size -> Size
∞ : Size
{-# BUILTIN SIZE Size #-}
{-# BUILTIN SIZESUC _^ #-}
{-# BUILTIN SIZEINF ∞ #-}
data Nat : {size : Size} -> Set where
zero : {size : Size} -> Nat {size ^}
suc : {size : Size} -> Nat {size} -... |
module Pi.Opsem where
open import Data.Empty
open import Data.Unit
open import Data.Sum
open import Data.Product
open import Relation.Binary.PropositionalEquality
open import Base
open import Pi.Syntax
infix 1 _↦_
-- Base combinators
base : ∀ {A B} (c : A ↔ B) → Set
base unite₊l = ⊤
base uniti₊l = ⊤
base swap₊ = ⊤
... |
------------------------------------------------------------------------
-- Atoms
------------------------------------------------------------------------
module Atom where
open import Equality.Propositional.Cubical
open import Logical-equivalence using (_⇔_)
open import Prelude
open import Bag-equivalence equality-... |
{-# OPTIONS --without-K --safe #-}
open import Level using (Level)
open import Relation.Binary.PropositionalEquality
open ≡-Reasoning
open import Data.Nat using (ℕ; zero; suc)
open import Data.Vec using (Vec; []; _∷_; _++_; foldr; map; replicate)
open import Data.Vec.Properties
open import FLA.Algebra.Structures
op... |
module Problem1 where
-- 1.1
data Nat : Set where
zero : Nat
suc : Nat -> Nat
-- 1.2
infixl 60 _+_
_+_ : Nat -> Nat -> Nat
zero + m = m
suc n + m = suc (n + m)
-- 1.3
infixl 70 _*_
_*_ : Nat -> Nat -> Nat
zero * m = zero
suc n * m = m + n * m
-- 1.4
infix 30 _==_
data _==_ {A : Set}(x : A) : A -> Set... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Solver for monoid equalities
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Algebra
module Algebra.Solver.Monoid {m₁ m₂} (M : Monoid m₁ ... |
open import Oscar.Prelude
open import Oscar.Data.¶
open import Oscar.Data.Fin
open import Oscar.Data.Term
module Oscar.Data.Substitunction where
module Substitunction {𝔭} (𝔓 : Ø 𝔭) where
open Term 𝔓
Substitunction : ¶ → ¶ → Ø 𝔭
Substitunction m n = ¶⟨< m ⟩ → Term n
module SubstitunctionOperator {𝔭} (�... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
open import Cubical.Foundations.HLevels
module Cubical.Algebra.Magma.Construct.Free {ℓ} (Aˢ : hSet ℓ) where
open import Cubical.Foundations.Prelude
open import Cubical.Algebra.Magma
open import Cubical.Data.Empty.Polymorphic
open... |
open import SOAS.Common
open import SOAS.Families.Core
open import Categories.Object.Initial
open import SOAS.Coalgebraic.Strength
import SOAS.Metatheory.MetaAlgebra
-- Traversals parametrised by a pointed coalgebra
module SOAS.Metatheory.Traversal {T : Set}
(⅀F : Functor 𝔽amiliesₛ 𝔽amiliesₛ) (⅀:Str : Strength ⅀F... |
module Category.Functor.Const where
open import Category.Functor using (RawFunctor ; module RawFunctor )
open import Category.Functor.Lawful
open import Relation.Binary.PropositionalEquality using (refl)
Const : ∀ {l₁ l₂} (R : Set l₂) (_ : Set l₁) → Set l₂
Const R _ = R
constFunctor : ∀ {l₁} {R : Set l₁} →... |
module MLib.Algebra.PropertyCode where
open import MLib.Prelude
open import MLib.Finite
open import MLib.Algebra.PropertyCode.RawStruct public
open import MLib.Algebra.PropertyCode.Core as Core public
using (Property; Properties; Code; IsSubcode; _∈ₚ_; _⇒ₚ_; ⟦_⟧P)
renaming (⇒ₚ-weaken to weaken)
open Core.PropKin... |
{-# OPTIONS --safe #-}
module Cubical.Data.FinData.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
import Cubical.Data.Empty as ⊥
open import Cubical.Data.Nat using (ℕ; zero; suc; _+_; _·_; +-assoc)
open import Cubical.Data.Bool.Base
open import Cubical.Relation.Nullary
pr... |
module Issue784.Values where
open import Data.Bool using (Bool; true; false; not)
open import Data.String public using (String)
open import Data.String.Properties public using (_≟_)
open import Function public
open import Data.List using (List; []; _∷_; _++_; [_]; filterᵇ) renaming (map to mapL)
open import Data.List... |
{-# OPTIONS --without-K #-}
module mini-lob where
open import common
infixl 2 _▻_
infixl 3 _‘’_
infixr 1 _‘→’_
infixl 3 _‘’ₐ_
mutual
data Context : Set where
ε : Context
_▻_ : (Γ : Context) → Type Γ → Context
data Type : Context → Set where
_‘’_ : ∀ {Γ A} → Type (Γ ▻ A) → Term {Γ} A → Type Γ
‘Typ... |
{-# OPTIONS --without-K --safe #-}
module Bundles where
open import Algebra.Core
open import Quasigroup.Structures
open import Relation.Binary
open import Level
open import Algebra.Bundles
open import Algebra.Structures
open import Structures
record InverseSemigroup c ℓ : Set (suc (c ⊔ ℓ)) where
infixl 7 _∙_
inf... |
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
-- From: Hancock (2008). (Ordinal-theoretic) proof theory.
module Ordinals where
data ℕ : Set where
zero : ℕ
succ : ℕ → ℕ
data Ω : Set where... |
-- Andreas, 2019-11-12, issue #4168b
--
-- Meta variable solver should not use uncurrying
-- if the record type contains erased fields.
open import Agda.Builtin.Equality
open import Agda.Builtin.Sigma
open import Common.IO
P : (A B : Set) → (A → B) → Set
P A B f = (y : B) → Σ A (λ x → f x ≡ y)
record R (A B : Set) :... |
open import Data.Product using ( _×_ ; _,_ ; proj₁ ; proj₂ )
open import Data.Sum using ( inj₁ ; inj₂ )
open import Data.Unit using ( tt )
open import Relation.Binary.PropositionalEquality using ( refl )
open import Relation.Unary using ( _∈_ ; _⊆_ )
open import Web.Semantic.DL.ABox using
( ABox ; Assertions ; ε ; _,... |
------------------------------------------------------------------------
-- A simplification of Hinze.Section2-4
------------------------------------------------------------------------
module Hinze.Simplified.Section2-4 where
open import Stream.Programs
open import Stream.Equality
open import Stream.Pointwise hiding... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of homogeneous binary relations
------------------------------------------------------------------------
-- This file contains some core definitions which are reexported by
-- Relation.Binary or Relat... |
{-# OPTIONS --cubical --no-import-sorts --allow-unsolved-metas #-}
open import Agda.Primitive renaming (_⊔_ to ℓ-max; lsuc to ℓ-suc; lzero to ℓ-zero)
module Number.Base where
private
variable
ℓ ℓ' ℓ'' : Level
open import Cubical.Foundations.Everything renaming (_⁻¹ to _⁻¹ᵖ; assoc to ∙-assoc)
open import Cubi... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Operations on and properties of decidable relations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Relation.Nullary.Decidable where
open impo... |
module Impossible where
-- The only way to trigger an __IMPOSSIBLE__ that isn't a bug.
{-# IMPOSSIBLE #-}
|
module Web.Semantic.DL.Category.Properties.Composition where
open import Web.Semantic.DL.Category.Properties.Composition.RespectsEquiv
public using ( compose-resp-≣ )
open import Web.Semantic.DL.Category.Properties.Composition.LeftUnit
public using ( compose-unit₁ )
open import Web.Semantic.DL.Category.Propertie... |
{-# OPTIONS -v scope.import:10 #-}
import Common.Level
import Common.Level
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- An inductive definition of the sublist relation. This is commonly
-- known as Order Preserving Embeddings (OPE).
------------------------------------------------------------------------
{-# OPTIONS --without-K -... |
{-# OPTIONS --without-K --safe #-}
module Function where
open import Level
infixr 9 _∘_ _∘′_
_∘_ : ∀ {A : Type a} {B : A → Type b} {C : {x : A} → B x → Type c} →
(∀ {x} (y : B x) → C y) → (g : (x : A) → B x) →
((x : A) → C (g x))
f ∘ g = λ x → f (g x)
{-# INLINE _∘_ #-}
_∘′_ : (B → C) → (A → B) → A ... |
module FileNotFound where
import A.B.WildGoose
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import groups.KernelImage
module cohomology.ChainComplex where
record ChainComplex i : Type (lsucc i) where
field
head : AbGroup i
chain : ℕ → AbGroup i
augment : AbGroup.grp (chain 0) →ᴳ AbGroup.grp head
boundary : ∀ n → (Ab... |
{-# OPTIONS -v tc.lhs.shadow:30 #-}
{-# OPTIONS --copatterns #-}
module PatternShadowsConstructor4 where
module A where
data B : Set where
x : B
data C : Set where
c : B → C
open A using (C; c)
record R : Set where
field
fst : C → C
snd : A.B
open R
r : R
fst r (c x) = x
snd r = A.B.... |
module Logic.WeaklyClassical where
import Lvl
open import Functional
open import Logic.Names
open import Logic.Predicate
open import Logic.Propositional
open import Logic.Propositional.Theorems
open import Type
private variable ℓ : Lvl.Level
private variable T X Y : Type{ℓ}
private variable P : T → Type{ℓ}
-- T... |
-- Solutions to ExerciseSession2
{-# OPTIONS --cubical #-}
module SolutionsSession2 where
open import Part1
open import Part2
open import ExerciseSession1
-- Exercise 1
JEq : {x : A} (P : (z : A) → x ≡ z → Type ℓ'')
(d : P x refl) → J P d refl ≡ d
JEq P p d = transportRefl p d
-- Exercise 2
isContr→isProp : i... |
open import x1-Base
module x2-Sort
{X : Set}
{_≈_ : Rel X}
{_≤_ : Rel X}
(_≤?_ : Decidable _≤_)
(ord : TotalOrder _≈_ _≤_)
where
open TotalOrder ord using (total; equivalence)
open Equivalence equivalence using (refl)
-- represent bounded lists, but want b... |
{-# OPTIONS --prop --rewriting --confluence-check #-}
open import Agda.Builtin.Equality
open import Agda.Builtin.Equality.Rewrite
postulate
A : Prop
a : A
B : Set
b : B
f : A → B → Set₁
g : B → Set₁
rew₁ : ∀ y → f a y ≡ g y
rew₂ : ∀ x → f x b ≡ Set
rew₃ : ∀ y → g y ≡ Set
{-# REWRITE rew₁ rew₂ rew₃... |
test = forall (_Set_ : Set) → Set
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.