text stringlengths 4 690k |
|---|
-- Operators used in the wrong way.
module NoParseForApplication where
postulate
X : Set
_! : X -> X
right : X -> X
right x = x !
wrong : X -> X
wrong x = ! x
|
module Text.Greek.SBLGNT.Gal where
open import Data.List
open import Text.Greek.Bible
open import Text.Greek.Script
open import Text.Greek.Script.Unicode
ΠΡΟΣ-ΓΑΛΑΤΑΣ : List (Word)
ΠΡΟΣ-ΓΑΛΑΤΑΣ =
word (Π ∷ α ∷ ῦ ∷ ∙λ ∷ ο ∷ ς ∷ []) "Gal.1.1"
∷ word (ἀ ∷ π ∷ ό ∷ σ ∷ τ ∷ ο ∷ ∙λ ∷ ο ∷ ς ∷ []) "Gal.1.1"
∷ word (ο ... |
{-# OPTIONS --cubical --safe #-}
module Cubical.Modalities.Modality where
{-
translated from
https://github.com/HoTT/HoTT-Agda/blob/master/core/lib/types/Modality.agda
-}
open import Cubical.Core.Everything
open import Cubical.Foundations.Everything
record Modality ℓ : Type (ℓ-suc ℓ) where
field
isModal : ... |
{- MJ where variable declarations have been hoisted to the top of a block -}
module CF.Transform.Hoist where
open import Level
open import Function using (_∘_)
open import Data.List
open import Data.List.Properties
open import Data.Unit
open import Data.Product
open import Relation.Unary hiding (_⊢_)
open import Relat... |
{-# OPTIONS --cubical --safe #-}
module Cardinality.Infinite.Split where
open import Prelude
open import Data.List.Kleene
open import Data.Fin
import Data.Nat as ℕ
open import Data.Nat using (_+_)
open import Cubical.Data.Sigma.Properties
open import Cubical.Foundations.Prelude using (J)
import Data.List.Kleene.Membe... |
{-# OPTIONS --enable-prop #-}
True : Prop
True = {P : Prop} → P → P
|
module Issue784.Transformer where
open import Data.List using (List; []; _∷_; _++_; [_]; filter) renaming (map to mapL)
import Level
open import Issue784.Values
open import Issue784.Context
Transformer : ∀ {ℓ} → NonRepetitiveTypes ℓ → NonRepetitiveTypes ℓ → Set (Level.suc ℓ)
Transformer {ℓ} (t-in , nr-in) (t-out , n... |
------------------------------------------------------------------------
-- Nested applications of the defined function can be handled
------------------------------------------------------------------------
module Nested where
open import Codata.Musical.Notation
open import Codata.Musical.Stream
open import Function... |
{-# OPTIONS --cubical --safe #-}
module Cubical.Homotopy.Connected where
open import Cubical.Core.Everything
open import Cubical.Foundations.Everything
open import Cubical.Foundations.Function
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open... |
module cry.ec where
open import Level
open import Relation.Nullary
open import Agda.Builtin.Bool
open import Agda.Builtin.Nat using () renaming (Nat to ℕ)
open import Agda.Builtin.List
open import cry.gfp
infixr 4 _,_
infixr 2 _×_
record _×_ {a b} (A : Set a) (B : Set b) : Set (a ⊔ b) where
constructor _,_
fiel... |
module io where
open import bool
open import char
open import list
open import string
open import unit
----------------------------------------------------------------------
-- datatypes
----------------------------------------------------------------------
postulate
IO : Set → Set
{-# COMPILE GHC IO = type IO #-... |
{-# OPTIONS --without-K #-}
open import lib.Basics -- hiding (_=⟨_⟩_ ; _∎)
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.PathGroupoid... |
-- self-contained notes following https://www.cs.bham.ac.uk/~mhe/HoTT-UF-in-Agda-Lecture-Notes/HoTT-UF-Agda.html and relevant parts of HoTT book
open import Agda.Primitive public
using (Level ; _⊔_)
renaming (Set to Type ; lzero to 𝓾₀ ; lsuc to _⁺)
variable
𝓁 𝓂 𝓃 : Level
Π : {X : Type 𝓁} (A : X → Type 𝓂)... |
module Numeral.Natural.Relation.Properties where
import Lvl
open import Data.Tuple as Tuple using (_⨯_ ; _,_)
open import Functional
open import Logic.Propositional
open import Logic.Propositional.Theorems
open import Logic.Predicate
open import Numeral.Natural
open import Numeral.Natural.Oper
open import Numeral.Natu... |
{-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Weakening {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.LogicalRelation
open import Definition.Logical... |
module Data.Finitude where
open import Data.Fin as Fin
open import Data.Nat as ℕ
open import Level
open import Function as Fun hiding (id; _∘_)
open import Function.Equality as F using (_⟨$⟩_)
open import Function.Injection as Inj hiding (id; _∘_)
open import Function.Bijection as Bij hiding (id; _∘_)
open import Fun... |
{-# OPTIONS --cubical --safe #-}
module Container.List.Syntax where
open import Prelude
open import Container
open import Container.List
open import Data.Fin
record ListSyntax {a b} (A : Type a) (B : Type b) : Type (a ℓ⊔ b) where
field [_] : B → List A
open ListSyntax ⦃ ... ⦄ public
instance
cons : ⦃ _ : ListS... |
open import Formalization.PredicateLogic.Signature
module Formalization.PredicateLogic.Syntax.Substitution (𝔏 : Signature) where
open Signature(𝔏)
open import Data.Boolean
open import Data.ListSized
import Data.ListSized.Functions as List
open import Formalization.PredicateLogic.Syntax(𝔏)
open import Function... |
{-# OPTIONS --rewriting #-}
module Properties.Subtyping where
open import Agda.Builtin.Equality using (_≡_; refl)
open import FFI.Data.Either using (Either; Left; Right; mapLR; swapLR; cond)
open import FFI.Data.Maybe using (Maybe; just; nothing)
open import Luau.Subtyping using (_<:_; _≮:_; Tree; Language; ¬Language... |
module Issue100 where
-- hiding (Nat) goes on the 'open' not on the 'import'.
open import Nat hiding (Nat)
one : Nat.Nat
one = suc zero
|
-- Andreas, 2014-01-08, following Maxime Denes 2014-01-06
-- This file demonstrates then incompatibility of the untyped
-- structural termination ordering with HoTT.
open import Common.Equality
data Empty : Set where
data Box : Set where
wrap : (Empty → Box) → Box
-- Box is inhabited:
gift : Empty → Box
gift ()... |
{-# OPTIONS --cubical-compatible #-}
module _ where
module M where
data D : Set where
record R₁ : Set where
field
x : let module M′ = M in M′.D
variable
A : Set
record R₂ (A : Set) : Set where
_ : (r : R₂ A) → let open R₂ r in Set₁
_ = λ _ → Set
|
------------------------------------------------------------------------
-- Properties relating All to various list functions
------------------------------------------------------------------------
module Data.List.All.Properties where
open import Data.Bool
open import Data.Bool.Properties
open import Data.Function
... |
module _ where
open import Agda.Builtin.Equality
open import Agda.Builtin.Nat
module Vars (A : Set) where
variable
x : A
data It {A : Set} : A → Set where
it : ∀ x → It x
module Fixed where
open Vars Nat
ret : It x
ret {x = x} = it x
module Param (A : Set) where
open Vars A
ret : It x
ret {x =... |
------------------------------------------------------------------------
-- Embeddings with erased "proofs"
------------------------------------------------------------------------
-- Partially following the HoTT book.
{-# OPTIONS --without-K --safe #-}
open import Equality
module Embedding.Erased
{reflexive} (eq... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Closure of a unary relation with respect to a preorder
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
module Relation.Un... |
-- Module shadowing using generated modules for records and datatypes
module Issue260d where
data D : Set where
module D where
|
module PLRTree.Complete.Properties {A : Set} where
open import Data.Empty
open import Data.Sum renaming (_⊎_ to _∨_)
open import PLRTree {A}
open import PLRTree.Complete {A}
open import PLRTree.Equality {A}
open import PLRTree.Equality.Properties {A}
lemma-⋗-≃ : {t t' t'' : PLRTree} → t ⋗ t' → t' ≃ t'' → t ⋗ t''
le... |
-- Basic intuitionistic modal logic S4, without ∨, ⊥, or ◇.
-- Gentzen-style formalisation of syntax with context pairs, after Pfenning-Davies.
-- Normal forms, neutrals, and spines.
module BasicIS4.Syntax.DyadicGentzenSpinalNormalForm where
open import BasicIS4.Syntax.DyadicGentzen public
-- Commuting propositions... |
module Common.Context where
import Level
open import Data.Nat as Nat
open import Data.List as List
import Level
open import Relation.Binary.PropositionalEquality as PE hiding ([_])
open import Relation.Binary -- using (Setoid; Rel; IsEquivalence)
open ≡-Reasoning
open import Function as Fun hiding (_∘′_)
open import ... |
-- Andreas, 2017-01-24, issue #2429
-- ..-annotation in lambdas should be taken seriously
-- A ≤ ..A ≤ .A
-- (.A → B) ≤ (..A → B) ≤ A → B
should-fail : ∀{A B : Set} → (.A → B) → (.A → B)
should-fail f = λ ..a → f a
-- Expected error:
-- Found a non-strict lambda where a irrelevant lambda was expected
-- when checkin... |
{- Name: Bowornmet (Ben) Hudson
--Preorders in Agda!--
-}
open import Preliminaries
module Preorder where
{- definition: a Preorder on a set A is a binary relation
that is reflexive and transitive.
-}
record Preorder-str (A : Set) : Set1 where
constructor preorder
field
≤ : A → A → Set
... |
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.Colimit.Examples where
open import Cubical.Core.Glue
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.SumFin
open import Cubic... |
module Luau.OpSem where
open import Agda.Builtin.Equality using (_≡_)
open import Agda.Builtin.Float using (Float; primFloatPlus; primFloatMinus; primFloatTimes; primFloatDiv)
open import FFI.Data.Maybe using (just)
open import Luau.Heap using (Heap; _≡_⊕_↦_; _[_]; function_is_end)
open import Luau.Substitution using ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Arguments used in the reflection machinery
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Reflection.Argument where
open import Data.List.Bas... |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 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.Base.Types
open import LibraBFT.Concrete.Records
open im... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Data.Fin where
open import Cubical.Data.Fin.Base public
open import Cubical.Data.Fin.Properties public
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Indexed containers aka interaction structures aka polynomial
-- functors. The notation and presentation here is closest to that of
-- Hancock and Hyvernat in "Programming interfaces and basic topology"
-- (2006/9... |
module Monads.ExceptT where
open import Class.Monad
open import Class.Monad.Except
open import Class.Monad.State
open import Class.MonadTrans
open import Data.Sum
open import Function
open import Level
private
variable
a : Level
ExceptT : (M : Set a -> Set a) -> Set a -> Set a -> Set a
ExceptT M E A = M (E ⊎ A... |
-- Andreas, 2020-06-17, issue #4135
-- Constructor disambiguation on should only instantiate metas
-- in a unique way.
-- {-# OPTIONS -v tc.lhs:10 #-}
-- {-# OPTIONS -v tc.lhs.split:40 #-}
-- {-# OPTIONS -v tc.lhs.disamb:40 #-}
data Bool : Set where
true false : Bool
module Foo (b : Bool) where
data D : Set whe... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Indexed binary relations
------------------------------------------------------------------------
-- This file contains some core definitions which are re-exported by
-- Relation.Binary.Indexed.Heterogeneous.
{... |
module System.File where
open import System.FilePath
open import Prelude.IO
open import Prelude.String
open import Prelude.Unit
open import Prelude.Function
open import Prelude.Bytes
{-# FOREIGN GHC import qualified Data.Text as Text #-}
{-# FOREIGN GHC import qualified Data.Text.IO as Text #-}
{-# FOREIGN GHC import... |
{-# OPTIONS --prop --rewriting #-}
module Examples.Gcd.Refine where
open import Calf.CostMonoid
import Calf.CostMonoids as CM
open import Calf CM.ℕ-CostMonoid
open import Calf.Types.Nat
open import Calf.Types.Bounded CM.ℕ-CostMonoid
open import Examples.Gcd.Euclid
open import Examples.Gcd.Clocked as Clocked
open i... |
-- Andreas, 2016-05-03 issue #1950
-- testcases from issue #679
-- {-# OPTIONS --show-implicit #-}
-- {-# OPTIONS -v reify.display:100 #-}
-- {-# OPTIONS -v tc.display.top:100 #-}
postulate anything : ∀{A : Set} → A
postulate Anything : ∀{A : Set1} → A
record ⊤ : Set where
data ty : Set where
♭ : ty
_`→_ : ty →... |
module sv20.compiler where
open import Data.Nat using (ℕ; zero; suc; _+_; _*_; _∸_)
--open import Data.Nat.DivMod using (_/_)
open import Data.List using (List; _++_; []; _∷_; head)
open import Data.Maybe as DM
open DM using (Maybe; just; nothing; maybe; _>>=_; from-just; From-just)
import Relation.Binary.Propositiona... |
-- Andreas, 2016-05-06, issue 1967
postulate
D : {{A : Set}} → Set
test : (A : Set) → D A
-- Expected error:
-- Set should be a function type, but it isn't
-- when checking that A is a valid argument to a function of type
-- {{A = A₁ : Set}} → Set
|
{-# OPTIONS --safe #-}
module Cubical.Algebra.DirectSum.DirectSumHIT.PseudoNormalForm where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Data.Nat renaming (_+_ to _+n_ ; _·_ to _·n_)
open import Cubical.Data.Sigma
open import Cubical.Data.List
open import Cubical... |
{-# OPTIONS --without-K #-}
{- This module defines our notion of connectedness not requiring HITs.
We define the generic n-connected version of a type, show that it is
n-connected, and that it behaves like the original type above level n.
We conclude by shoing this notion coincides with the usual notion.
o... |
{-# OPTIONS --rewriting #-}
open import Agda.Builtin.Equality
open import Agda.Builtin.Bool
open import Agda.Builtin.Nat
{-# BUILTIN REWRITE _≡_ #-}
not : Bool → Bool
not true = false
not false = true
postulate rew : Nat ≡ Bool
{-# REWRITE rew #-}
0' : Bool
0' = 0
test : not 0' ≡ true
test = refl
|
module Data.SimpleMap where
open import Class.Equality
open import Class.Map
open import Data.Bool
open import Data.Maybe
open import Data.List hiding (lookup)
open import Data.Product
open import Relation.Nullary
open import Relation.Nullary.Negation
SimpleMap : Set -> Set -> Set
SimpleMap A B = List (A × B)
privat... |
{-# OPTIONS --without-K --safe #-}
-- Bundled version of a Cocartesian Category
module Categories.Category.Cocartesian.Bundle where
open import Level
open import Categories.Category.Core using (Category)
open import Categories.Category.Cocartesian using (Cocartesian)
record CocartesianCategory o ℓ e : Set (suc (o ⊔... |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2020 Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
{-# OPTIONS --allow-unsolved-metas #-}
open import LibraBFT.Prelude
open import... |
interleaved mutual
data Foo : Set → Set
data Foo_Bar : Set
constructor
foobar : Foo Bar
|
{-# OPTIONS --rewriting #-}
module MessageClosureProperties where
open import Data.Nat using (ℕ; zero ; suc)
open import Data.Fin using (Fin; zero; suc)
open import Function using (_∘_)
open import Relation.Binary.PropositionalEquality using (_≡_; cong; cong₂; sym; refl)
open import Auxiliary.Extensionality
open impo... |
module Logic.Structure.Monoid where
import Logic.Equivalence
import Logic.Operations as Operations
open Logic.Equivalence using (Equivalence; module Equivalence)
open Operations.Param
data Monoid (A : Set)(Eq : Equivalence A) : Set where
monoid :
(z : A)
(_+_ : A -> A -> A)
(leftId : LeftIdentity Eq... |
open import Relation.Binary.Core
module InsertSort.Impl2.Correctness.Permutation.Alternative {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_) where
open import Bound.Lower A
open import Bound.Lower.Order _≤_
open import Data.List
open import Data.Sum
open import Function
open impor... |
-- Currently open declarations are not allowed in mutual blocks.
-- This might change.
module OpenInMutual where
module A where
mutual
open A
T : Set -> Set
T A = A
|
{-# OPTIONS --allow-unsolved-metas #-}
module TemporalOps.Linear where
open import CategoryTheory.Instances.Reactive
open import CategoryTheory.Functor
open import CategoryTheory.CartesianStrength
open import CategoryTheory.NatTrans
open import CategoryTheory.Monad
open import CategoryTheory.Linear
open import Tempo... |
------------------------------------------------------------------------
-- Do the parser combinators form a Kleene algebra?
------------------------------------------------------------------------
module TotalParserCombinators.Laws.KleeneAlgebra where
open import Algebra
open import Data.List
open import Data.List.P... |
module Issue282 where
module Works where
record R : Set where
constructor c
foo = R.c
module Doesn't_work where
private
record R : Set where
constructor c
foo = R.c
-- Bug.agda:17,9-12
-- Not in scope:
-- R.c at Bug.agda:17,9-12
-- when scope checking R.c
module Doesn't_work_either wher... |
module AllStdLib where
-- Ensure that the entire standard library is compiled.
import README
open import Data.Unit.Polymorphic using (⊤)
open import Data.String
open import IO hiding (_>>_)
import IO.Primitive as Prim
import DivMod
import HelloWorld
import HelloWorldPrim
import ShowNat
import TrustMe
import Vec
imp... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Groups.Definition
open import Groups.Lemmas
open import Groups.Abelian.Definition
open import Setoids.Setoids
open import Sets.EquivalenceRelations
open import Rings.Definition
open import Modules.Definition
module Modules.Lemmas {a b : _} {A : Set a} {S... |
module Extensions.Nat where
open import Prelude
open import Data.Nat.Base
open import Data.Nat.Properties.Simple
open import Data.Nat.Properties
m+1+n≡1+m+n : ∀ m n → m + suc n ≡ suc (m + n)
m+1+n≡1+m+n zero n = refl
m+1+n≡1+m+n (suc m) n = cong suc (m+1+n≡1+m+n m n)
<-+ : ∀ {m n m' n'} → m ≤ m' → n ≤ n' → m + n... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Consequences of a monomorphism between binary relations
------------------------------------------------------------------------
-- See Data.Nat.Binary.Properties for examples of how this and similar
-- modules ... |
open import HoTT
module cohomology.Exactness where
module _ {i j k} {X : Ptd i} {Y : Ptd j} {Z : Ptd k}
(F : fst (X ⊙→ Y)) (G : fst (Y ⊙→ Z)) where
private
f = fst F
g = fst G
{- in image of F ⇒ in kernel of G -}
is-exact-itok : Type (lmax k (lmax j i))
is-exact-itok = (y : fst Y) → Trunc ⟨-1⟩ (Σ ... |
module Sigma.Renaming.Properties where
open import Data.Nat using (ℕ; _+_; zero; suc)
open import Data.Fin using (Fin; zero; suc)
open import Sigma.Subst.Core
open import Sigma.Renaming.Base
open import Sigma.Subst.Properties using (extensionality)
open import Function using (_∘_)
open import Relation.Binary.Propo... |
-- Minimal implicational logic, PHOAS approach, initial encoding
module STLC where
-- Types
infixr 0 _=>_
data Ty : Set where
UNIT : Ty
_=>_ : Ty -> Ty -> Ty
-- Context
Cx : Set1
Cx = Ty -> Set
-- Terms
infixl 1 _$_
data Tm (tc : Cx) : Ty -> Set
where
var : forall {a} -> tc a
... |
{-# OPTIONS --cubical --rewriting #-}
open import Agda.Builtin.Cubical.Path
open import Agda.Primitive.Cubical
data A : Set where
a : A
eq : a ≡ a
bad : ∀ i → eq i ≡ a
bad i j = eq (primIMin i (primINeg j))
{-# BUILTIN REWRITE _≡_ #-}
{-# REWRITE bad #-}
|
-- Allow holes in modules to import, by introducing a single general postulate.
module UNDEFINED where
postulate
UNDEFINED : ∀ {ℓ} → {T : Set ℓ} → T
|
-- Andreas, 2017-01-18, issue #819, reported by stevana
-- Underscores should be preserved when case-splitting
data List (A : Set) : Set where
_∷_ : (x : A)(xs : List A) → List A
data ⊥ : Set where
-- Case-splitting on x:
test : List ⊥ → ⊥
test (x ∷ _) = {!x!} -- split on x
-- I think the underscore should be kep... |
module Class.Map where
open import Class.Equality
open import Data.Maybe using (Maybe; just; nothing)
open import Data.List using (List; []; _∷_; [_])
record MapClass (K : Set) {{_ : EqB K}} (M : Set -> Set) : Set₁ where
field
insert : ∀ {V} -> K -> V -> M V -> M V
remove : ∀ {V} -> K -> M V -> M V
look... |
{-# OPTIONS --without-K #-}
open import M-types.Base
module M-types.Coalg.M {ℓ : Level} (A : Ty ℓ) (B : A → Ty ℓ) where
open import M-types.Coalg.Core A B
open import M-types.Coalg.Bisim A B
IsFinM : ∏[ M ∈ Coalg ] ∏[ coiter ∈ (∏[ X ∈ Coalg ] CoalgMor X M) ]
Ty (ℓ-suc ℓ)
IsFinM M coiter = ... |
{-# OPTIONS --without-K #-}
module PermutationProperties where
open import Data.Nat using (ℕ; _+_)
open import Data.Fin using (Fin)
open import Relation.Binary.PropositionalEquality
using (_≡_; refl; sym; trans; cong; module ≡-Reasoning; proof-irrelevance; setoid)
open import Function.Equality using (_⟨$⟩_)
op... |
module Logic.IntroInstances where
import Data.Tuple as Tuple
import Lvl
open import Logic.Predicate
open import Logic.Propositional
open import Type
private variable ℓ : Lvl.Level
private variable A B Obj : Type{ℓ}
private variable P : Obj → Type{ℓ}
private variable x : Obj
instance
[∧]-intro-instance : ... |
------------------------------------------------------------------------
-- A container for finite binary trees with information in internal
-- nodes
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
module Container.Tree
{c⁺} (eq : ∀ {... |
module Text.Greek.SBLGNT.1John where
open import Data.List
open import Text.Greek.Bible
open import Text.Greek.Script
open import Text.Greek.Script.Unicode
ΙΩΑΝΝΟΥ-Α : List (Word)
ΙΩΑΝΝΟΥ-Α =
word (Ὃ ∷ []) "1John.1.1"
∷ word (ἦ ∷ ν ∷ []) "1John.1.1"
∷ word (ἀ ∷ π ∷ []) "1John.1.1"
∷ word (ἀ ∷ ρ ∷ χ ∷ ῆ ∷ ς ... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category using (Category)
open import Categories.Category.Monoidal using (Monoidal)
module Categories.Category.Monoidal.Reasoning {o ℓ e} {C : Category o ℓ e} (M : Monoidal C) where
open import Data.Product using (_,_)
open import Categories.Functor using (F... |
module Issue254 where
data Unit : Set where
* : Unit
data Nat : Set where
zero : Nat
suc : Nat → Nat
data Vec : Nat → Set where
cons : ∀ n → Vec (suc n)
remove : ∀ n → Nat → Vec (suc n) → Unit
remove n x (cons .n) with *
remove n x (cons .n) | * = {!!}
|
{-
This file contains:
- Definition of functions of the equivalence between FreeGroup and the FundamentalGroup
- Definition of encode decode functions
- Proof that for all x : Bouquet A → p : base ≡ x → decode x (encode x p) ≡ p (no truncations)
- Proof of the truncated versions of encodeDecode and of right-homotopy
... |
open import Agda.Builtin.Reflection
open import Agda.Builtin.Unit
open import Agda.Builtin.List
open import Agda.Builtin.Equality
infixl 4 _>>=_
_>>=_ = bindTC
data Tm : Set where
[_] : Term → Tm
macro
qType : Term → Term → TC ⊤
qType t hole = inferType t >>= quoteTC >>= unify hole
qTerm : Term → Term → TC... |
{-# OPTIONS --without-K --rewriting --allow-unsolved-metas #-}
open import HoTT renaming (pt to pt⊙)
open import homotopy.DisjointlyPointedSet
open import lib.types.Nat
open import lib.types.Vec
module simplicial.SCequivCW where
open import cw.CW public
open import cw.examples.Sphere public
open import simplicial.Ba... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.ZCohomology.KcompPrelims where
open import Cubical.ZCohomology.Base
open import Cubical.Homotopy.Connected
open import Cubical.HITs.Hopf
open import Cubical.Homotopy.Freudenthal hiding (encode)
open import Cubical.HITs.Sn
open import Cubical.HITs.S1
ope... |
module Simple where
open import Data.Nat renaming (_≟_ to _≟ℕ_)
open import Data.Fin hiding (_+_; inject)
open import Data.String hiding (_++_) renaming (_≟_ to _≟S_)
open import Relation.Nullary using (¬_; yes; no)
open import Relation.Binary.PropositionalEquality using (refl; _≡_)
open import Data.List
open import... |
{-# OPTIONS --cubical --safe --postfix-projections #-}
module Data.Fin.Properties where
open import Prelude
open import Data.Fin.Base
import Data.Nat.Properties as ℕ
open import Data.Nat.Properties using (+-comm)
open import Data.Nat
open import Function.Injective
open import Agda.Builtin.Nat renaming (_<_ to _<ᵇ_)
... |
module Data.MoreNatProp where
open import Relation.Binary.PropositionalEquality
using (_≡_ ; refl ; cong)
open import Data.Nat as Nat
using (ℕ ; suc ; zero ; _≤′_ ; _≤_ ; _+_ ; s≤s ; z≤n ; ≤′-refl ;
≤′-step ; _⊔_)
open import Data.Nat.Properties as NatP
using (≤⇒≤′ ; ≤′⇒≤ ; m≤m+n ; s≤′s ; ≤-stepsˡ ; ≤⇒... |
-- {-# OPTIONS -v extendedlambda:100 -v int2abs.reifyterm.def:100 #-}
module Issue435 where
data Bool : Set where
true false : Bool
record Unit : Set where
postulate
Dh : ({ x : Bool } → Bool) → Set
Di : ({{x : Bool}} → Bool) → Set
noth : Set
noth = Dh (\ { {true} → false ; {false} → true})
noti : Set
noti ... |
{-# OPTIONS --allow-unsolved-metas #-}
open import Agda.Builtin.Equality
postulate
cong₂ : ∀ {a b c} {A : Set a} {B : Set b} {C : Set c} {x y : A} {u v : B}
→ (f : A → B → C) → x ≡ y → u ≡ v → f x u ≡ f y v
test = cong₂ (λ A B → A → B)
|
module Ex6App where -- git indicates that only commenting out of imports has happened 0/15 + 0/5 gives 0/20
open import CS410-Prelude
open import CS410-Nat
open import CS410-Vec
open import CS410-Indexed
open import CS410-Monoid
open import Ex6AgdaSetup
-- open import Ex5Sol
-- open import Ex5
--open MonadIx TilingM... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
module lib.types.Empty where
Empty-rec : ∀ {i} {A : Type i} → (Empty → A)
Empty-rec = Empty-elim
⊥-rec : ∀ {i} {A : Type i} → (⊥ → A)
⊥-rec = Empty-rec
abstract
Empty-is-prop : is-prop Empty
Empty-is-prop = Empty-elim
Empty-is-set : is-set Empty... |
{-# OPTIONS --without-K #-}
open import library.Basics hiding (Type ; Σ)
open import library.types.Sigma
open import library.NType2
open import Sec2preliminaries
open import Sec3hedberg
open import Sec4hasConstToSplit
module Sec5factorConst where
-- Definition 5.1
factors-through : {X Y : Type} → Type → (X → Y) → ... |
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (Rel; Setoid; IsEquivalence)
module Magma.Structures
{a ℓ} {A : Set a} -- The underlying set
(_≈_ : Rel A ℓ) -- The underlying equality relation
where
open import Algebra.Core
open import Level using (_⊔_)
open import Data.Product using (_... |
{-# OPTIONS --without-K #-}
open import HoTT
open import homotopy.RibbonCover
module homotopy.CoverClassification {i} (A∙ : Ptd i)
(A-conn : is-connected 0 (fst A∙)) where
open Cover
private
A : Type i
A = fst A∙
a₁ : A
a₁ = snd A∙
π1A = fundamental-group A∙
-- A covering space construc... |
module Agda.Builtin.Coinduction where
infix 1000 ♯_
postulate
∞ : ∀ {a} (A : Set a) → Set a
♯_ : ∀ {a} {A : Set a} → A → ∞ A
♭ : ∀ {a} {A : Set a} → ∞ A → A
{-# BUILTIN INFINITY ∞ #-}
{-# BUILTIN SHARP ♯_ #-}
{-# BUILTIN FLAT ♭ #-}
|
-- Andreas, 2013-02-27
module Issue653 where
postulate
P : {A : Set} → (A → Set) → Set
mutual
A : Set
A = P B -- note A = P {A} B is non-terminating
data B : A → Set where
c : (a : A) → B a
-- This caused a stack overflow due to infinite reduction
-- in the positivity checker.
-- Now functions that do n... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Ints.QuoInt.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Equiv
open import Cubical.Rela... |
{-# OPTIONS --without-K #-}
module Model.Type where
open import Model.Exponential public
open import Model.Nat public
open import Model.Product public
open import Model.Terminal public
open import Model.Type.Core public
open import Model.Stream public
open import Model.Quantification public
open import Model.Size as ... |
open import Function using ( _∘_ )
open import Data.Product using ( ∃ ; _×_ ; _,_ )
open import Data.Sum using ( _⊎_ ; inj₁ ; inj₂ )
open import Data.Empty using ( ⊥ ; ⊥-elim )
open import Data.Nat using ( ℕ ; zero ; suc ) renaming ( _+_ to _+ℕ_ ; _≤_ to _≤ℕ_ )
open import Relation.Binary.PropositionalEquality using
... |
open import MLib.Algebra.PropertyCode
open import MLib.Algebra.PropertyCode.Structures
module MLib.Matrix.Equality {c ℓ} (struct : Struct bimonoidCode c ℓ) where
open import MLib.Prelude
open import MLib.Matrix.Core
import Relation.Binary.Indexed as I
module S = Struct struct renaming (Carrier to S; _≈_ to _≈′_)
op... |
module Type.Identity.Heterogenous where
import Lvl
open import Type
data HId {ℓ} : ∀{A : Type{ℓ}}{B : Type{ℓ}} → A → B → Type{Lvl.𝐒(ℓ)} where
instance intro : ∀{T : Type{ℓ}}{x : T} → HId x x
|
{-# OPTIONS --cubical --safe #-}
module Data.Sigma.Properties where
open import Prelude hiding (B; C)
open import Cubical.Foundations.HLevels using (isOfHLevelΣ) public
open import Cubical.Data.Sigma.Properties using (Σ≡Prop) public
private
variable
B : A → Type b
C : Σ A B → Type c
reassoc : Σ (Σ A B) C ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.