text stringlengths 4 690k |
|---|
module Oscar.Data.Proposequality where
open import Agda.Builtin.Equality public using (_≡_) renaming (refl to ∅) public
open import Relation.Binary.PropositionalEquality public using (_≢_) public
open import Oscar.Category.Setoid
open import Relation.Binary.PropositionalEquality using (sym; trans)
open import Osca... |
-- Andreas, 2017-01-27, issue #2437
-- Polarity checker turns Nonvariant to Unused arg in types,
-- thus, reducing them.
-- However, this should not happen without need.
-- We wish to preserve the types as much as possible.
-- {-# OPTIONS -v 20 #-}
-- {-# OPTIONS -v tc.polarity:30 #-}
-- {-# OPTIONS -v tc.decl:30 #-}
... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommMonoid.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Equiv.HalfAdjoint
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.U... |
------------------------------------------------------------------------
-- The derivative operator does not remove any ambiguity
------------------------------------------------------------------------
module TotalParserCombinators.Derivative.RightInverse where
open import Data.List
open import Data.Maybe
open impor... |
-- Copyright: (c) 2016 Ertugrul Söylemez
-- License: BSD3
-- Maintainer: Ertugrul Söylemez <esz@posteo.de>
module Data.Nat.Core where
open import Agda.Builtin.Nat public
renaming (Nat to ℕ)
using (suc; zero)
renaming (_+_ to _+ℕ_; _*_ to _*ℕ_)
open import Classes
open import Core
instance
ℕ-Number : Num... |
------------------------------------------------------------------------
-- Some boring lemmas used by the ring solver
------------------------------------------------------------------------
-- Note that these proofs use all "almost commutative ring" properties
-- except for zero and -‿pres-≈.
open import Algebra
op... |
module Membership-equality where
import Membership-old
open import Relation.Binary.PropositionalEquality as PropEq
open import Data.List
open import Data.List.Any
open import Relation.Binary
import Relation.Binary.InducedPreorders as Ind
open import Function.Related as Related hiding (_∼[_]_)
private
open module M ... |
------------------------------------------------------------------------
-- A small definition of a dependently typed language, using the
-- technique from McBride's "Outrageous but Meaningful Coincidences"
------------------------------------------------------------------------
-- The code contains an example, a part... |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Functor.Properties where
open import Relation.Binary using (_Preserves_⟶_)
open import Categories.Category
open import Categories.Functor
import Categories.Morphisms as Morphisms
module FunctorsAlways {o ℓ e o′ ℓ′ e′} {C : Category o ℓ e} {D : Category o′ ℓ′ ... |
module LibA where
import LibB
|
-- Andreas, 2014-03-02, issue reported by roly.perera
-- Test case by Nisse
{-# OPTIONS --allow-unsolved-metas #-}
-- To see what is going on:
-- {-# OPTIONS -v tc.meta.assign.proj:25 #-}
record Σ (A : Set) (B : A → Set) : Set where
constructor t
field
proj₁ : A
proj₂ : B proj₁
open Σ public
map : {A B... |
module PrintNat where
import PreludeShow
open PreludeShow
mainS = showNat 42
|
{-# OPTIONS --safe #-}
module Definition.Typed.Consequences.NeTypeEq where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.Weakening
open import Definition.Typed.Consequences.Syntactic
open import Definition.Typed.Consequences.Injectivit... |
module _ where
module M where
open M using () renaming () hiding ()
-- empty lists should not be errors here
|
{-# OPTIONS --universe-polymorphism #-}
open import Common.Prelude
open import Common.Level
open import Common.Reflection
module UnquoteSetOmega where
`Level : Term
`Level = def (quote Level) []
-- while building the syntax of ∀ ℓ → Set ℓ (of type Setω) is harmless
`∀ℓ→Setℓ : Term
`∀ℓ→Setℓ = pi (vArg `Level) (abs "_... |
{-
TBA - Talk 'Bout Agda
Ulf Norell
Chalmers
DTP 2008, Nottingham
-}
module Talk where
-- Normal everyday lists
data List (A : Set) : Set where
[] : List A
_::_ : A -> List A -> List A
infixr 40 _::_
map : {A B : Set} -> (A -> B) -> List A -> List B
map f [] = []
map f (x :: xs) = f... |
open import Agda.Builtin.Equality
record IsGroup (G : Set) : Set where
field _∙_ : G → G → G
open IsGroup ⦃ ... ⦄
record Group : Set₁ where
field G : Set
⦃ IsG ⦄ : IsGroup G
open Group using () renaming (G to [_])
variable
G : Group
postulate
works : ∀ {G} → (x : [ G ]) → (x ∙ x) ≡ x
fail... |
module Colist where
open import Size using (Size ; Size<_)
data Colist (i : Size) {a} (A : Set a) : Set a
record ∞Colist (i : Size) {a} (A : Set a) : Set a where
coinductive
constructor delay_
field force : ∀ {j : Size< i} → Colist j A
data Colist (i : Size) {a} (A : Set a) where
[] : Colist i A... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Strictness combinators
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Strict where
open import Level
open import Agda.Builtin.Equality
open ... |
module Common.Predicate where
open import Common public
open import Common.Context public
using (Cx ; VCx ; ∅ ; _,_)
-- Predicates.
Pred : ∀ {ℓ} → Set ℓ → Set (sucᴸ ℓ)
Pred {ℓ} U = U → Set ℓ
-- Set membership.
module _ {U : Set} where
infix 3 _∈ᴾ_
_∈ᴾ_ : U → Pred U → Set
A ∈ᴾ P = P A
infix 3 _∉ᴾ_
_... |
open import Agda.Primitive
variable
a : Level
A : Set a
x : A
postulate
P : ∀ {a b} {A : Set a} {B : Set b} → (A → B) → Set
p : P x
postulate
H : ∀ a (A : Set a) (x : A) → Set
Id : ∀ {a} (A : Set a) → A → A → Set a
h : (i : H _ _ x) (j : H a _ _) → Id (H _ A _) i j
|
{-
The sheaf property of a presheaf on a distributive lattice or a basis thereof
can be expressed as preservation of limits over diagrams defined in this file.
-}
{-# OPTIONS --safe #-}
module Cubical.Categories.DistLatticeSheaf.Diagram where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.I... |
module list-thms where
-- see list-thms2 for more
open import bool
open import bool-thms
open import functions
open import list
open import nat
open import nat-thms
open import product-thms
open import logic
++[] : ∀{ℓ}{A : Set ℓ} → (l : 𝕃 A) → l ++ [] ≡ l
++[] [] = refl
++[] (x :: xs) rewrite ++[] xs = refl
++-a... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Pointwise lifting of relations to vectors
------------------------------------------------------------------------
module Relation.Binary.Vec.Pointwise where
open import Category.Applicative.Indexed
open import... |
-- Andreas, 2017-01-26. Testing the --no-eta-equality option.
-- Records in files without the option (unless Agda runs with this
-- option globally), should have eta.
module HaveEtaForImportedRecords.EtaRecord where
open import Agda.Builtin.Equality public
record ⊤ : Set where
private
test : ∀{x y : ⊤} → x ≡ y
... |
module _ where
open import Agda.Builtin.Nat
module Postulates where
infixl 5 _<*>_
postulate
F : Set → Set
pure : ∀ {A} → A → F A
_<*>_ : ∀ {A B} → F (A → B) → F A → F B
test₀ : F Nat → F Nat → F Nat
test₀ a b = (| a + b |)
test₁ : F Nat
test₁ = (| 5 |)
test₂ : F Nat → F Nat
tes... |
open import Data.Boolean
open import Type
module Data.List.Sorting.HeapSort {ℓ} {T : Type{ℓ}} (_≤?_ : T → T → Bool) where
import Lvl
open import Data.List
import Data.List.Functions as List
open import Data.BinaryTree
import Data.BinaryTree.Heap as Heap
open import Functional using (_∘_)
heapSort : Li... |
module Lemmachine.Default.Lemmas where
open import Lemmachine
import Lemmachine.Default
import Lemmachine.Lemmas
open Lemmachine.Lemmas Lemmachine.Default.resource
open import Relation.Binary.PropositionalEquality
open import Data.Empty
open import Data.Maybe
open import Data.Product hiding (map)
open import Data.Funct... |
-- Andreas, 2020-03-27, issue #3684
-- Warn about duplicate fields instead of hard error.
module DuplicateFields where
postulate X : Set
record D : Set where
field x : X
d : X → X → D
d x y = record{ x = x; x = y }
|
{-# OPTIONS --without-K --exact-split --allow-unsolved-metas #-}
module 14-image where
import 13-propositional-truncation
open 13-propositional-truncation public
{- We introduce the image inclusion of a map. -}
precomp-emb :
{ l1 l2 l3 l4 : Level} {X : UU l1} {A : UU l2} (f : A → X)
{B : UU l3} ( i : B ↪ X) (q ... |
module Builtin where
data Bool : Set where
false : Bool
true : Bool
not : Bool -> Bool
not true = false
not false = true
_||_ : Bool -> Bool -> Bool
true || _ = true
false || x = x
_&&_ : Bool -> Bool -> Bool
true && x = x
false && _ = false
{-# BUILTIN BOOL Bool #-}
{-# BUILTIN TRUE true #-}
{-# BUILTI... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category using (Category)
-- 'Heterogeneous' identity morphism and some laws about them.
module Categories.Morphism.HeterogeneousIdentity {o ℓ e} (C : Category o ℓ e) where
open import Level
open import Relation.Binary.PropositionalEquality
import Categories... |
{-# OPTIONS --allow-unsolved-metas #-}
open import Oscar.Class
open import Oscar.Class.Smap
open import Oscar.Class.Transitivity
open import Oscar.Class.Reflexivity
open import Oscar.Class.Transleftidentity
open import Oscar.Class.Symmetry
open import Oscar.Class.Hmap
open import Oscar.Data.Proposequality
open import ... |
open import Level
open import Ordinals
module VL {n : Level } (O : Ordinals {n}) where
open import zf
open import logic
import OD
open import Relation.Nullary
open import Relation.Binary
open import Data.Empty
open import Relation.Binary
open import Relation.Binary.Core
open import Relation.Binary.PropositionalEqu... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Discrete where
-- Discrete Category.
-- https://ncatlab.org/nlab/show/discrete+category
-- says:
-- A category is discrete if it is both a groupoid and a preorder. That is,
-- every morphism should be invertible, any two parallel morphisms should be equal.
... |
module Issue417 where
data _≡_ (A : Set₁) : Set₁ → Set₂ where
refl : A ≡ A
abstract
A : Set₁
A = Set
unfold-A : A ≡ Set
unfold-A = refl
-- The result of inferring the type of unfold-A is the following:
--
-- Set ≡ Set
|
open import Mockingbird.Forest using (Forest)
module Mockingbird.Forest.Combination.Vec {b ℓ} (forest : Forest {b} {ℓ}) where
open import Mockingbird.Forest.Combination.Vec.Base forest public
|
module Serializer.Fin where
open import Data.Fin hiding (_+_)
open import Data.Nat
open import Function using (_∘_ ; _$_ ; _∋_ ; id ; const)
open import Function.Bijection
open import Relation.Binary.PropositionalEquality using (_≡_ ; refl ; cong ; setoid )
open import Serializer
instance
serializerFin : ∀ {n} -> ... |
module List where
open import Prelude
open import Star
[_] : Set -> Rel True
[ A ] = \_ _ -> A
List : Set -> Set
List A = Star [ A ] _ _
-- Actually there isn't really that much interesting stuff to be
-- done for lists that isn't generic.
{- Note that the "proofs" are the elements of the list. -}
|
{-# OPTIONS --safe #-}
{-
This file has been split in two due to slow type checking
combined with insufficient reductions when the
experimental-lossy-unification flag is included.
Part 2: Cubical.Homotopy.Group.Pi4S3.S3PushoutIso2
The goal of these two files is to show that
π₄(S³) ≅ π₃((S² × S²) ⊔ᴬ S²) where A = S² ∨ ... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Construction.Properties.EilenbergMoore where
open import Level
import Relation.Binary.PropositionalEquality as ≡
open import Categories.Adjoint
open import Categories.Adjoint.Properties
open import Categories.Category
open import Categories.Functor using (... |
{-# OPTIONS --without-K #-}
module overloading.bundle where
open import level
record Bundle {i j} {Base : Set i}
(Struct : Base → Set j) : Set (lsuc (i ⊔ j)) where
constructor bundle
field
parent : Base
struct : Struct parent
|
{-# OPTIONS --without-K #-}
--open import HoTT
open import homotopy.3x3.PushoutPushout
open import homotopy.3x3.Transpose
import homotopy.3x3.To as To
import homotopy.3x3.From as From
open import homotopy.3x3.Common
module homotopy.3x3.FromToInit {i} (d : Span^2 {i}) where
open Span^2 d
open M d hiding (Pushout^2)
o... |
module Issue4260 where
open import Issue4260.M
-- syntax F X = G X
H : Set → Set
H X = G X
|
module plfa-code.Negation where
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
open import Data.Nat using (ℕ; zero; suc)
open import Data.Empty using (⊥; ⊥-elim)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Data.Product using (_×_) renaming (_,_ to ⟨_,_⟩)
open import plfa-code.Isomorph... |
{-# OPTIONS -Werror -WnoEmptyRewritePragma #-}
{-# REWRITE #-}
|
{-# OPTIONS --without-K --exact-split #-}
module hott-i where
import 04-inductive-types
open 04-inductive-types public
data 𝕀 : UU lzero where
left : 𝕀
postulate right : 𝕀
data Path {l : Level} (A : 𝕀 → UU l) : (a : A left) (a' : A right) → UU l where
pcon : (f : (x : 𝕀) → A x) → Path A (f left) (f right)... |
open import Agda.Primitive
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
infix 2 _↔_
record _↔_ {a} {b} (p : Set a) (q : Set b) : Set (a ⊔ b) where
field
l2r : p → q
r2l : q → p
_&_ : Bool → Bool → Bool
true & true = true
_ & _ = false
[_] : Bool → Set
[ P ] = P ≡ true
record ∃ {A : Set}... |
------------------------------------------------------------------------
-- An up-to technique for weak similarity
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
open import Labelled-transition-system
module Similarity.Weak.Up-to {ℓ} (lts : LTS ℓ) where
open i... |
{-# OPTIONS --without-K #-}
module pointed.equality where
open import sum
open import equality.core
open import function.extensionality
open import function.isomorphism.core
open import function.isomorphism.utils
open import pointed.core
pmap-eq : ∀ {i j}{X : Set i}{Y : Set j}{x₀ : X}{y₀ : Y}
→ {f : X → Y}{p ... |
{-# OPTIONS --safe #-}
module Cubical.Data.Unit.Pointed where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed.Base
open import Cubical.Data.Unit
private
variable
ℓ : Level
Unit∙ : Pointed ℓ
Unit∙ = Unit* , tt*
|
{-# OPTIONS --cubical --safe #-}
module Data.Bits.Fold where
open import Data.Bits
open import Strict
open import Prelude
module _ {a} {A : Type a} (zer : A → A) (one : A → A) (base : A) where
foldr-bits : Bits → A
foldr-bits [] = base
foldr-bits (0∷ xs) = zer (foldr-bits xs)
foldr-bits (1∷ xs) = one (foldr-... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Functions
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import LogicalFormulae
open import Setoids.Subset
open import Setoids.Setoids
open import Setoids.Orders
open import Fields.Fields
open import Rings.Orders.Total.Definition
open impo... |
-- {-# OPTIONS --allow-unsolved-metas #-}
module GUIgeneric.GUIFeaturesPart5 where
open import GUIgeneric.Prelude renaming (addButton to addButton')
open import GUIgeneric.GUIDefinitions renaming (add to add'; add' to add)
open import GUIgeneric.GUI
open import GUIgeneric.GUIExampleLib
open import StateSizedIO.GUI.Wx... |
{-# OPTIONS --safe --cubical #-}
module Relation.Binary.Bool where
open import Prelude
-- record TotalOrder {e} (E : Type e) : Type e where
-- field
-- _≤?_ : E → E → Bool
-- _≤_ : E → E → Type
|
{-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Properties.Escape {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Weakening
open import Definition.Typed.Properties
open imp... |
{-# OPTIONS --without-K --safe #-}
-- We do not parameterize this module since we do not have access to _+_ or _*_
-- for the fields that we want (real numbers)
module FLA.Algebra.Structures where
open import Level using (Level) renaming (suc to lsuc)
open import Data.Sum using (_⊎_)
open import Relation.Binary.Prop... |
{-# OPTIONS --safe #-}
module Cubical.Categories.Constructions.FullSubcategory where
-- Full subcategory (not necessarily injective on objects)
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Categories.Category
open import Cubical.Categories.Functor renaming (𝟙⟨_... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.ListedFiniteSet where
open import Cubical.HITs.ListedFiniteSet.Base public
open import Cubical.HITs.ListedFiniteSet.Properties public
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Algebra.FunctionProperties.Consequences.Core
{a} {A : Set a} where... |
module OldO where
open import Data.Product
open import Function renaming (_∘_ to _○_)
open import Circle
------------------------------------------------------------------------------
-- Abstract interpretation:
-- natural numbers with paths equating all even numbers in one
-- connected component and all o... |
{-# OPTIONS --cubical --safe #-}
module Data.Finite where
open import Prelude
open import Data.Fin
𝒞 : Type a → Type a
𝒞 A = ∃ n × ∥ A ≃ Fin n ∥
ℂ : Type _
ℂ = Σ[ T ⦂ Type ] × 𝒞 T
|
{- 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.Concrete.System.Parameters
open import LibraBFT.Im... |
-- Andreas, 2020-03-27, issue #4534
-- Better error message for quote.
open import Agda.Builtin.Reflection
_ : Name
_ = quote Set
-- Can only quote defined names, but encountered Set
-- when checking that the expression quote Set has type Name
|
open import Formalization.PredicateLogic.Signature
module Formalization.PredicateLogic.Classical.SequentCalculus (𝔏 : Signature) where
open Signature(𝔏)
open import Data.List
open import Data.List.Functions using () renaming (singleton to · ; _++_ to _∪_)
open import Data.List.Relation.Permutation
open import Forma... |
module FreezingTest where
data _≡_ {A : Set} (x : A) : A → Set where
refl : x ≡ x
data ℕ : Set where
zero : ℕ
suc : (n : ℕ) → ℕ
force : let one : ℕ
one = _ -- this meta is not frozen after the end of let
in one ≡ suc zero
force = refl
|
postulate
C : Set
anything : C
record I : Set where
constructor c
field
f : C
data Wrap : (j : I) → Set where
wrap : ∀ {j} → Wrap j
works1 : ∀ {j} → Wrap j → C
works1 {c ._} (wrap {j = c _}) with anything
... | z = z
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Some examples showing where the natural numbers and some related
-- operations and properties are defined, and how they can be used
------------------------------------------------------------------------
{-# OP... |
module test.IntegerOverflow where
open import Type
open import Declarative
open import Builtin
open import Builtin.Constant.Type
open import Builtin.Constant.Term Ctx⋆ Kind * # _⊢⋆_ con size⋆
open import Agda.Builtin.Sigma
open import Data.Integer
open import Data.Nat
open import Data.Empty
-- zerepoch/zerepoch-core/... |
---------------------------------------------------------------------
-- This file contains the definition of heterogenous equality and --
-- related facts. A lot of this code is old, and could be written --
-- better. This equality is mainly used for object equivalence. --
-- ... |
open import Oscar.Prelude
open import Oscar.Class.Transitivity
module Oscar.Class.Congruity where
module _ where
module _
{ℓ} (_∼_ : ∀ {𝔬} {𝔒 : Ø 𝔬} → 𝔒 → 𝔒 → Ø ℓ)
𝔵 𝔶
where
𝓬ongruity = ∀ {𝔛 : Ø 𝔵} {𝔜 : Ø 𝔶} {x₁ x₂} (f : 𝔛 → 𝔜) → x₁ ∼ x₂ → f x₁ ∼ f x₂
record 𝓒ongruity : Ø ℓ ∙̂ ↑... |
module Issue478b where
record Ko (Q : Set) : Set₁ where
field
T : Set
foo : T
foo = Set
-- This previously said Set₁ !=< T r |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.GradedRing.DirectSumFun where
{-
This file give a graded ring construction in the case of the fun direct sum.
Because of the current proofs this is done only in the case where
- Idx is ℕ and for a monoid on it
- For the usual ∸ ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Notation for adding an additional point to any set
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Relation.Nullary.Construct.Add.Point where
... |
{-# OPTIONS --without-K #-}
open import M-types.Base.Core
module M-types.Base.Prod where
∏ : (X : Ty ℓ₀) → (Y : X → Ty ℓ₁) → Ty (ℓ-max ℓ₀ ℓ₁)
∏ X Y = (x : X) → Y x
∏-syntax : (X : Ty ℓ₀) → (Y : X → Ty ℓ₁) → Ty (ℓ-max ℓ₀ ℓ₁)
∏-syntax = ∏
infix 2 ∏-syntax
syntax ∏-syntax X (λ x → Y) = ∏[ x ∈... |
{-# OPTIONS --cumulativity #-}
open import Agda.Primitive
module _ (a ℓ : Level) where
mutual
X : Level
X = _
X<=a : Set X → Set a
X<=a A = A
test : Set₁
test with (lsuc ℓ)
... | _ = Set
where
a<=X : Set a → Set X
a<=X A = A
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import lib.types.TwoSemiCategory
module homotopy.HSpace where
-- This is just an approximation because
-- not all higher cells are killed.
record HSpaceStructure {i} (X : Ptd i) : Type i where
constructor hSpaceStructure
field
⊙μ : (X ⊙× X) ⊙→ 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.ImplShared.Base.Types
open import LibraBFT.Abstra... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties related to All
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Relation.Unary.All.Properties where
open import Axiom.Exte... |
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Paths
open import lib.types.Pi
open import lib.types.Unit
open import lib.types.Nat
open import lib.types.TLevel
open import lib.types.Pointed
open import lib.types.Sigma
open import lib.NType2
open import lib.types.PathSeq
open import nicolai.... |
module FormalLanguage.ContextFreeGrammar where
|
-- Andreas, 2015-02-13
-- Termination errors in parametrized modules
module Issue1429 (A : Set) (f : A → A) where
test : A → A
test a = test (f a)
-- should report problematic call
--
-- test (f a)
--
-- not
--
-- test (f₁ a)
|
{-# OPTIONS --cubical --safe #-}
module Algebra.Construct.Sign where
open import Prelude
data Signed {a} (A : Type a) : Type a where
⁻_ : A → Signed A
±0 : Signed A
⁺_ : A → Signed A
unsign : (A → B) → B → (A → B) → Signed A → B
unsign f g h (⁻ x) = f x
unsign f g h ±0 = g
unsign f g h (⁺ x) = h x
|
{-# OPTIONS --without-K #-}
open import HoTT
{-
This file contains three proofs of Ω(S¹) = ℤ and the fact that the circle is
a 1-type:
- Something closely related to Mike’s original proof
- Dan’s encode-decode proof
- Guillaume’s proof using the flattening lemma.
This file is divided in a lot of different parts so th... |
open import FRP.JS.Bool using ( Bool ; _∨_ ; not )
open import FRP.JS.True using ( True )
open import FRP.JS.Maybe using ( Maybe )
open import FRP.JS.Float using ( ℝ ) renaming ( _/?_ to _/?r_ )
open import FRP.JS.Primitive using ( ℕ ; String )
module FRP.JS.Int where
infixr 4 _≤_ _<_ _≟_
infixl 6 _+_ _-_
infixl 7 _*... |
{-
Define finitely generated ideals of commutative rings and
show that they are an ideal.
Parts of this should be reusable for explicit constructions
of free modules over a finite set.
-}
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommRing.FGIdeal where
open import Cubical.Foundations.Prelude
open import Cu... |
open import MJ.Types as Types
import MJ.Classtable.Core as Core
module MJ.Semantics.Objects {c}(Ct : Core.Classtable c) where
open import Prelude
open import Level renaming (suc to lsuc; zero to lzero)
open import Data.List
open import Data.List.Relation.Unary.All
open import Data.List.Prefix
open Core c
open Class... |
postulate
Nat : Set
Fin : Nat → Set
Foo : (n : Nat) → Fin n → Set
private
module M where
variable
n : Nat
m : Fin _
postulate
Bar : Foo n m → Set
open M public using (Bar)
variable
n : Nat
m : Fin _
l : Foo n m
before : Bar l
before {n} {m} {l} = {!C-c C-e!}
after : Bar l
after {n} ... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommRing.Instances.UnivariatePoly where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat using (ℕ ; zero ; suc)
open import Cubical.Algebra.CommRing
open import Cubical.Algebra.Polynomials.Univariate.Base
open import Cubical.Algebra.Polynomials.Univar... |
module Utils.NatOrdLemmas where
open import Data.Nat.Properties.Simple
open import Data.Nat
open import Data.Empty
open import Relation.Binary.PropositionalEquality
open import Relation.Nullary
open import Function
{- Just a bunch of lemmas about the standard ordering on naturals -}
data Cmp (a b : ℕ) : Set where
... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.PtdMapSequence
open import groups.HomSequence
open import cohomology.Theory
module cohomology.PtdMapSequence {i} (CT : CohomologyTheory i) where
open CohomologyTheory CT
-- FIXME maybe this should be named [ap-C-seq],
-- but I do no... |
module Structure.Category.Equiv where
import Lvl
open import Structure.Setoid
open import Structure.Category
-- TODO: https://en.wikipedia.org/wiki/Equivalence_of_categories
module _ {ℓₒ ℓₘ : Lvl.Level} {Obj : Type{ℓₒ}} (Morphism : Obj → Obj → Type{ℓₘ}) ⦃ morphism-equiv : ∀{x y} → Equiv(Morphism x y) ⦄ where
... |
{-# OPTIONS --without-K --safe #-}
module Definition.Conversion.FullReduction where
open import Definition.Untyped as U hiding (wk)
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.Weakening
open import Definition.Conversion
op... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Setoids.Setoids
open import Rings.Definition
open import Rings.IntegralDomains.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
module Rings.Primes.Definition {a b : _} {A : Set a} {S : Setoid {a} {b} A} {... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of operations on characters
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Char.Properties where
open import Data.Bool.Base u... |
module Dave.Logic.Bool where
data Bool : Set where
false : Bool
true : Bool
¬_ : Bool → Bool
¬ true = false
¬ false = true
_∧_ : Bool → Bool → Bool
a ∧ true = a
a ∧ false = false
if_then_else_ : {A : Set} → Bool → A → A → A
if false then a else b = b
i... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Setoids.Setoids
open import Rings.Definition
open import Rings.IntegralDomains.Definition
open import Vectors
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Order
open import Numbers.Naturals.Definition
open... |
module Oscar.Function where
open import Function public using (id; _∘_; _∘′_; flip; _on_; _$_) renaming (const to const_)
infix -1 _∋_
_∋_ : ∀ {a} (A : Set a) → A → A
_ ∋ x = x
open import Prelude.Function public using (it)
|
{-# OPTIONS --no-termination-check #-}
module PiMeadow where
open import Level
open import Data.Empty
open import Data.Unit
open import Data.Sum
open import Data.Product
open import Relation.Binary.PropositionalEquality
-- infixr 20 _◎_
{-
postulate
A : Set
a b c : A
p : a ≡ b
q : b ≡ c
data <_> {a : Level... |
------------------------------------------------------------------------------
-- Properties of the alter list
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.