text stringlengths 4 690k |
|---|
-- Andreas, 2016-02-01, reported on 2014-12-08
module Issue1388 where
indented = Set
not-indented = Set -- This should be a parse error.
|
module Languages.ILL.AgdaInterface where
open import nat
open import Utils.HaskellTypes
open import Utils.HaskellFunctions
open import Utils.Exception
open import Languages.ILL.Intermediate
open import Languages.ILL.Syntax
open import Languages.ILL.TypeSyntax
open import Languages.ILL.TypeCheck
{-# TERMINATING #-}
t... |
open import Nat
open import Prelude
open import dynamics-core
open import contexts
open import binders-disjoint-checks
open import exchange
open import lemmas-consistency
open import lemmas-disjointness
open import lemmas-subst-ta
open import type-assignment-unicity
open import weakening
module preservation where
-... |
------------------------------------------------------------------------------
-- The relation of divisibility on partial natural numbers
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no... |
module Relation.Ternary.Separation.Monad where
open import Level
open import Data.Product
open import Function using (_∘_; case_of_)
open import Relation.Unary
open import Relation.Unary.PredicateTransformer hiding (_⊔_)
open import Relation.Binary.PropositionalEquality
open import Relation.Ternary.Separation
open imp... |
{-# OPTIONS --cumulativity #-}
open import Agda.Builtin.Equality
mutual
_X : (Set → Set) → Set₁ → Set
_X f x = _
test : (f : Set₁ → Set) (x : Set₁) → _X f x ≡ f x
test f x = refl
Set' : Set
Set' = _X (λ X → X) Set
|
{-# 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.PathGroupoid
open import nicolai.p... |
{- 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.Lemmas
open import LibraBFT.Prelude
open import Lib... |
{-# OPTIONS --without-K --safe #-}
module Dodo.Binary.Identity where
-- Stdlib imports
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; subst; sym)
open import Level using (Level; _⊔_)
open import Function.Base using (flip)
open import Data.Product using (_×_; _,_; ∃; ∃-syntax; proj₁; proj... |
primitive
primLevelZero : _
|
module Text.Printf where
open import Prelude hiding (parseNat)
open import Builtin.Float
private
data Padding : Set where
noPad : Padding
lPad rPad : Nat → Padding
record Flags : Set where
field
padding : Padding
padChar : Char
alternate : Bool
precision : Maybe Nat
... |
------------------------------------------------------------------------------
-- Arithmetic properties (using induction on the FOTC natural numbers type)
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}... |
{- This file exports the primitives of cubical Id types -}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Core.Id where
open import Cubical.Core.Primitives hiding ( _≡_ )
open import Agda.Builtin.Cubical.Id public
renaming ( conid to ⟨_,_⟩
-- TODO: should the user really be able to acc... |
open import Prelude
open import dynamics-core
module grounding where
grounding : ∀{τ1 τ2} →
τ1 ▸gnd τ2 →
((τ2 ground) × (τ1 ~ τ2) × (τ1 ≠ τ2))
grounding (MGArr x) = GArrHole , TCArr TCHole1 TCHole1 , x
grounding (MGSum x) = GSumHole , TCSum TCHole1 TCHole1 , x
grounding (MGProd x) =... |
module Selective.EnvironmentOperations where
open import Selective.ActorMonad
open import Selective.SimulationEnvironment
open import Prelude
open import Data.List.All.Properties using (++⁺ ; drop⁺)
open import Data.List.Properties using (map-++-commute)
open import Data.Nat.Properties using (≤-reflexive)
open import ... |
{-# OPTIONS --cubical --safe #-}
module Harmony where
open import Data.Bool using (Bool; true; false; if_then_else_; _∨_; not; _∧_)
open import Data.Fin using (#_; toℕ) renaming (zero to fz; suc to fs)
open import Data.List using (List; map; []; _∷_; concatMap; foldr; head; zip; null)
open import D... |
{-# OPTIONS --verbose=10 #-}
module lemmas where
open import Data.Nat
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; trans; sym; cong; cong-app; subst)
+-suc : (n₁ n₂ : ℕ) -> (n₁ + (1 + n₂)) ≡ (1 + (n₁ + n₂))
+-suc zero n2 = refl
+-suc (suc n1) n2 rewrite +-suc n1 n2 = ref... |
{-# OPTIONS --without-K #-}
open import HoTT
open import cohomology.FunctionOver
open import cohomology.Theory
{- Cohomology groups are independent of basepoint, and the action of
- the cohomology is independent of the basepoint-preservation path -}
module cohomology.BaseIndependence {i} (CT : CohomologyTheory i) w... |
module PatternSynonymOverapplied2 where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
pattern suc' x = suc x
f : Nat -> Nat
f zero = zero
f (suc' m n) = n |
module Structure.Function.Linear where
import Lvl
open import Logic
open import Logic.Propositional
open import Relator.Equals
open import Relator.Equals.Proofs
open import Type
-- TODO: Remove this
module _ {ℓ₁}{ℓ₂}{ℓ₃} {V₁ : Type{ℓ₁}} {V₂ : Type{ℓ₂}} {S : Type{ℓ₃}} where
record LinearMap (_+₁_ : V₁ → V₁ → V... |
module Relation.Ternary.Separation.Monad.Identity where
open import Level
open import Function
open import Function using (_∘_; case_of_)
open import Relation.Binary.PropositionalEquality
open import Relation.Unary
open import Relation.Unary.PredicateTransformer hiding (_⊔_)
open import Relation.Ternary.Separation
ope... |
module Data.Nat where
import Prelude
import Data.Bool as Bool
open Prelude
open Bool
data Nat : Set where
zero : Nat
suc : Nat -> Nat
{-# BUILTIN NATURAL Nat #-}
{-# BUILTIN SUC suc #-}
{-# BUILTIN ZERO zero #-}
infix 40 _==_ _<_ _≤_ _>_ _≥_
infixl 60 _+_ _-_
infixl 70 _*_
infixr 80 _^_
infix 100 _!
_+_ : N... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Lists with fast append
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.DifferenceList where
open import Data.List.Base as L using (List)
... |
module Issue665 where
postulate
A : Set
record I : Set where
constructor i
field
f : A
data Wrap : (j : I) → Set where
con : ∀ {j} → Wrap j
postulate
C : Set
anything : C
works1 : ∀ {X} -> Wrap X -> C
works1 (con {i _}) with anything
... | z = z
works2 : ∀ {X} -> Wrap X -> C
works2 (con {_}) with ... |
{-# OPTIONS --without-K #-}
module F1 where
open import Data.Unit
open import Data.Sum hiding (map)
open import Data.Product hiding (map)
open import Data.List
open import Data.Nat
open import Data.Bool
{--
infixr 90 _⊗_
infixr 80 _⊕_
infixr 60 _∘_
infix 30 _⟷_
--}
------------------------------------------------... |
module Generic.Reflection.ReadData where
open import Generic.Core
open import Generic.Function.FoldMono
‵π : ArgInfo -> String -> Term -> Term -> Term
‵π i s a b = sate π (reify i) (sate refl) ∘ sate coerce ∘ sate _,_ a $
appDef (quote appRel) (implRelArg (reify (relevance i)) ∷ explRelArg (explLam s b) ∷ [])
quot... |
-- Context extension of presheaves
module SOAS.Families.Delta {T : Set} where
open import SOAS.Common
open import SOAS.Context
open import SOAS.Variable
open import SOAS.Sorting
open import SOAS.Construction.Structure
open import SOAS.Families.Core {T}
-- | General context extension by a context Θ
module Unsorted ... |
module CombinatoryLogic.Syntax where
open import Data.String using (String; _++_)
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
-- Kapitel 1, Abschnitt C, §4 (Symbolische Festsetzungen), Def. 1
infixl 6 _∙_
data Combinator : Set where
-- Kapitel 1, Abschnitt C, §3 (Die formalen Grundbegriffe)... |
open import Sec4
data ℕ : Set where
Z : ℕ
S : ℕ → ℕ
-- Now ≥ relation
_≥_ : ∀ (m : ℕ) → ∀ (n : ℕ) → Prop
Z ≥ Z = ⊤
S m ≥ Z = ⊤
Z ≥ S n = ⊥
S m ≥ S n = m ≥ n
-- Example proof
-- eqqr : ((S (S (S Z))) ≥ (S (S Z))) → ((S (S Z)) ≥ (S (S (S Z))))
-- eqqr ()
-- -- Now is ≥ equivalence relation?
-- relfexivity
reflex... |
module Schedule where
open import Data.Bool
open import Data.Fin
open import Data.Empty
open import Data.List
open import Data.List.All
open import Data.Maybe
open import Data.Nat
open import Data.Product
open import Data.Sum
open import Data.Unit
open import Function using (_$_)
open import Relation.Nullary
open impo... |
{-# OPTIONS --without-K --safe #-}
module Dodo.Unary.Empty where
-- Stdlib imports
open import Level using (Level; _⊔_)
open import Data.Product using (∃-syntax)
open import Relation.Nullary using (¬_)
open import Relation.Unary using (Pred)
-- # Definitions
Empty₁ : ∀ {a ℓ : Level} {A : Set a} → Pred A ℓ → Set (a... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Ints.BiInvInt.Properties where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat hiding (_+_; +-comm)
open import Cubical.Data.Int
open import Cubical.Data.Bool
open import Cubical.HITs.Ints... |
-- Useless abstract
module Issue476b where
abstract
data A : Set
data A where
|
------------------------------------------------------------------------
-- Compiler correctness
------------------------------------------------------------------------
{-# OPTIONS --cubical --safe #-}
module Lambda.Simplified.Partiality-monad.Inductive.Compiler-correctness
where
open import Equality.Propositiona... |
{-# OPTIONS --without-K --safe #-}
-- In this module, we define F<:⁻, F<:ᵈ (F<: deterministic defined in Pierce92) and
-- show that F<:⁻ subtyping is undecidable.
module FsubMinus where
open import Data.List as List
open import Data.Nat
open import Data.Maybe as Maybe
open import Data.Product
open import Data.Vec as ... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
-- The core of a category.
-- See https://ncatlab.org/nlab/show/core
module Categories.Category.Construction.Core {o ℓ e} (𝒞 : Category o ℓ e) where
open import Level using (_⊔_)
open import Function using (flip)
open import Categories.Category.Gr... |
open import Issue2229Reexport2
B = A
|
{-# OPTIONS --safe #-}
module Cubical.Algebra.Algebra.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.GroupoidLaws
... |
{-# OPTIONS --rewriting --prop #-}
open import Agda.Primitive public
open import Agda.Builtin.Nat public renaming (Nat to ℕ) hiding (_==_; _+_)
open import Agda.Builtin.Bool public
{- Basic datatypes and propositions -}
record ⊤ : Prop where
instance constructor tt
record Unit : Set where
instance constructor t... |
{-# OPTIONS --without-K #-}
module Univalence where
open import Equivalence
open import Types
postulate
ua : ∀ {ℓ} {A : Set ℓ} {B : Set ℓ} → (A ≡ B) ≃ (A ≃ B)
|
{-# OPTIONS --without-K --rewriting #-}
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... |
------------------------------------------------------------------------
-- Normalization/simplification of kinding in Fω with interval kinds
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module FOmegaInt.Kinding.Simple.Normalization where
open import Dat... |
module Pat (BaseType : Set) where
data Ty : Set where
ι : BaseType -> Ty
_⟶_ : Ty -> Ty -> Ty
data Bwd (A : Set) : Set where
• : Bwd A
_◄_ : Bwd A -> A -> Bwd A
infixl 30 _◄_
Ctx = Bwd Ty
data Take {A : Set} : Bwd A -> A -> Bwd A -> Set where
hd : forall {x xs} -> Take (xs ◄ x) x xs
tl : forall {x... |
-- Andreas, 2012-03-08
module NoNoTerminationCheck where
{-# NON_TERMINATING #-}
f : Set
f = f
-- the pragma should not extend to the following definition
g : Set
g = g
-- error: non-termination
|
open import Common.Prelude
open import Common.Reflection
open import Common.Equality
data Dec {a} (A : Set a) : Set a where
yes : A → Dec A
no : Dec A
record Eq {a} (A : Set a) : Set a where
constructor eqDict
field
_==_ : (x y : A) → Dec (x ≡ y)
module M {a} {A : Set a} {{EqA : Eq A}} where
_==_ : (... |
{-# OPTIONS --without-K #-}
module well-typed-syntax-eq-dec where
open import well-typed-syntax
open import common
context-pick-if : ∀ {ℓ} {P : Context → Set ℓ}
{Γ : Context}
(dummy : P (ε ▻ ‘Σ’ ‘Context’ ‘Typ’))
(val : P Γ) →
... |
module Test.NFTest where
open import Data.Nat
open import Data.List
open import Data.Product
open import Test.Factorial
open import NF
open import NF.Nat
open import NF.List
open import NF.Product
l : List (ℕ × ℕ)
l = nf ((1 , factorial 1) ∷ (1 + 1 , factorial (1 + 1)) ∷ [] ++
(5 , factorial 5) ∷ []) |
module Naturals where
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
-- suc (suc (suc (suc (suc (suc (suc zero))))))
{-# BUILTIN NATURAL ℕ #-}
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl)
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_; _∎)
_+_ : ℕ → ℕ → ℕ
zero + n = n -- 0 + n ... |
------------------------------------------------------------------------------
-- Filter
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-... |
open import Oscar.Prelude
open import Oscar.Class
module Oscar.Class.Symmetry where
module Symmetry'
{𝔬} {𝔒 : Ø 𝔬}
{𝔯} (_∼_ : 𝔒 → 𝔒 → Ø 𝔯)
x y
= ℭLASS (x ,, y ,, _∼_) (x ∼ y → y ∼ x)
module Symmetry
{𝔬} {𝔒 : Ø 𝔬}
{𝔯} (_∼_ : 𝔒 → 𝔒 → Ø 𝔯)
where
class = ∀ {x y} → Symmetry'.class _∼_ x y
... |
module UniDB.Subst.Shifts where
open import UniDB.Subst.Core
open import UniDB.Morph.Shifts
module _ {T : STX} {{vrT : Vr T}} {{apTT : Ap T T}} {{apVrT : ApVr T}} where
instance
iLkCompApShifts : LkCompAp T Shifts
lk-⊙-ap {{iLkCompApShifts}} ξ₁ ξ₂ i = begin
vr (lk (ξ₁ ⊙ ξ₂) i) ≡⟨ cong vr (shiftI... |
{-# OPTIONS --without-K --safe #-}
module Categories.Functor.Profunctor where
open import Level
open import Data.Product
open import Relation.Binary.Bundles
open import Categories.Category
open import Categories.Category.Instance.Setoids
open import Categories.Functor hiding (id)
open import Categories.Functor.Bifun... |
{-# OPTIONS --cubical --safe #-}
open import Cubical.Core.Everything
open import Cubical.Foundations.Everything
open import Agda.Primitive using (lzero)
module Cubical.Data.DescendingList.Strict.Properties
(A : Type₀)
(_>_ : A → A → Type₀)
where
open import Cubical.Data.DescendingList.Strict A _>_
open import Cub... |
{-# OPTIONS --without-K --safe #-}
-- Various operations and proofs on morphisms between products
-- Perhaps a bit of overkill? There is so much here that it's impossible to remember
-- it all
open import Categories.Category
module Categories.Object.Product.Morphisms {o ℓ e} (𝒞 : Category o ℓ e) where
open import F... |
module LineEndings.Mac where
postulate ThisWorks : Set
|
{-# OPTIONS --type-in-type #-}
module TypeInTypeAndUnivPoly where
open import UniversePolymorphism
-- The level metas should be solved with 0 when we have --type-in-type
fst′ : ∀ {A B} → Σ A B → A
fst′ x = fst x
|
module Structure.Relator.Proofs where
import Data.Either as Either
import Data.Tuple as Tuple
open import Functional
open import Function.Proofs
open import Logic
open import Logic.Propositional.Proofs.Structures
open import Logic.Propositional
open import Logic.Predicate
import Lvl
open import Structur... |
module SecondOrder.VContext {ℓ} (sort : Set ℓ) where
-- a context is a binary tree whose leaves are labeled with sorts
data VContext : Set ℓ where
ctx-empty : VContext
ctx-slot : sort → VContext
_,,_ : VContext → VContext → VContext
infixl 5 _,,_
infix 4 _∈_
-- the variables of a given type i... |
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.NType2
open import lib.types.Sigma
open import lib.types.Pi
open import lib.types.Group
open import lib.types.Int
open import lib.types.List
open import lib.types.SetQuotient
module lib.groups.FormalSum {i} where
PreFormalSum : Type i → Type i
PreFor... |
-- Andreas, 2013-10-20 'with' only abstracts at base type
module WithOfFunctionType where
postulate
A B : Set
P : B → Set
mkP : (x : B) → P x
f : A → B
a : A
test : P (f a)
test with f
... | g = mkP (g a)
|
module _ where
open import Agda.Builtin.Nat
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
open import Agda.Builtin.TrustMe
record _×_ (A B : Set) : Set where
constructor _,_
field
fst : A
snd : B
open _×_
-- Nested pattern prevents record pattern translation.
f : Nat × Nat → Nat
f (ze... |
{-# OPTIONS --without-K #-}
open import HoTT
open import cohomology.CofiberSequence
open import cohomology.Exactness
open import cohomology.FunctionOver
open import cohomology.SplitExactRight
open import cohomology.Theory
module cohomology.Sigma {i} (CT : CohomologyTheory i) where
open CohomologyTheory CT
open impor... |
open import Data.Bool using (Bool; true; false; _∧_)
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; sym; subst)
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_; _≡⟨_⟩_; _∎)
open import Data.Unit using (⊤; tt)
open import Data.Nat using (ℕ; zero; suc; _≤_; _≥_; _>_)
open import Data.Product using ... |
module IrrelevantModuleParameter .(A : Set) where
postulate
a : A
-- cannot declare something of type A, since A is irrelevant |
{-# OPTIONS --rewriting --prop --confluence-check --cumulativity #-}
open import Agda.Primitive
open import Agda.Builtin.Bool
open import Agda.Builtin.Nat
open import Agda.Builtin.List
open import Agda.Builtin.Equality
open import Agda.Builtin.Equality.Rewrite
open import Agda.Builtin.Sigma
open import Agda.Builtin.U... |
module Issue293b where
module M₁ (_ : Set₁) where
postulate P : Set
module M₂ (_ : Set) where
open M₁ Set
p : P
p = {!!}
-- Previous agda2-goal-and-context:
-- ------------------------
-- Goal: M₁.P Set
-- Current agda2-goal-and-context:
-- ------------------------
-- Goal: P
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Order morphisms
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary.Core
module Relation.Binary.Morphism where
-------------... |
{-
This second-order term syntax was created from the following second-order syntax description:
syntax Monad | M
type
T : 1-ary
term
ret : α -> T α
bind : T α α.(T β) -> T β | _>>=_ r10
theory
(LU) a : α b : α.(T β) |> bind (ret(a), x. b[x]) = b[a]
(RU) t : T α |> bind (t, x. ret(x)) = t
(AS) ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- A type for expressions over a raw ring.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Tactic.RingSolver.Core.Expression where
open import Da... |
{-# OPTIONS --cubical #-}
module Exercises where
open import Part2
open import Part3
open import Part4
open import Part5
|
-- Some basic structures and operations for dealing
-- with non-deterministic values.
--
-- @author Sergio Antoy, Michael Hanus, Steven Libby
module nondet where
open import bool
open import nat
open import list
infixr 8 _??_
----------------------------------------------------------------------
-- A tree datatype ... |
open import Agda.Builtin.Equality
module _ (A : Set) where
data Wrap (X : Set) : Set where
wrap : X → Wrap X
data D (x : A) : ∀ y → Wrap (x ≡ y) → Set where
c : ∀ y (x≡y : x ≡ y) → D x y (wrap x≡y)
test : ∀ x y (x≡y x≡y' : Wrap (x ≡ y)) → D x y x≡y → D x y x≡y' → Set
test y .y (wrap refl) .(wrap refl) (c .y .re... |
------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Environments
--
-- This module defines the meaning of contexts, that is,
-- the type of environments that fit a context, together
-- with operations and properties of these operations.
--
-- This module is parametri... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Comonads
------------------------------------------------------------------------
-- Note that currently the monad laws are not included here.
{-# OPTIONS --without-K --safe #-}
module Category.Comonad where
... |
------------------------------------------------------------------------
-- Alternative definitions of weak bisimilarity
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
open import Prelude
module Delay-monad.Bisimilarity.Alternative {a} {A : Type a} where
open ... |
open import prelude
-- Copied pretty much verbatim
data Term : Set where
true : Term
false : Term
if_then_else_end : Term → Term → Term → Term
data Value : Term → Set where
true : Value true
false : Value false
data _⟶_ : Term → Term → Set where
E─IfTrue : ∀ {t₂ t₃} →
----------------------------... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.Polynomials.Multivariate.Base where
open import Cubical.Algebra.CommRing.Instances.Polynomials.MultivariatePoly public
{-
The Multivariate Polynomials of size n over a CommRing A is a CommRing.
This version is define as an instance of the more general constructions of gr... |
{-# OPTIONS --without-K #-}
open import HoTT
open import cohomology.Exactness
open import cohomology.Theory
module cohomology.Sn {i} (OT : OrdinaryTheory i) where
open OrdinaryTheory OT
C-Sphere-≠ : (n : ℤ) (m : ℕ) → (n ≠ ℕ-to-ℤ m)
→ C n (⊙Lift (⊙Sphere m)) == Lift-Unit-group
C-Sphere-≠ n O neq = C-dimension n ne... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Vectors
------------------------------------------------------------------------
module Data.Vec where
open import Category.Applicative
open import Data.Nat
open import Data.Fin using (Fin; zero; suc)
open impo... |
module Data.Union.Relation.Binary.Subtype where
open import Data.List using (List)
open import Data.List.Relation.Unary.Any using (here; there)
open import Data.List.Relation.Binary.Subset.Propositional using (_⊆_)
open import Data.Union using (Union; here; there; inj)
open import Function using (_∘_; id)
open impo... |
{-# OPTIONS --without-K --rewriting #-}
module lib.types.Suspension.Trunc where
open import lib.Basics
open import lib.NType2
open import lib.types.Paths
open import lib.types.Pointed
open import lib.types.Truncation
open import lib.types.Suspension.Core
module _ {i} (A : Type i) (m : ℕ₋₂) where
module SuspTrunc... |
{-# OPTIONS --without-K --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 Defini... |
{-# OPTIONS --without-K #-}
open import HoTT
{- Move (parts of) faces of a cube around -}
module lib.cubical.elims.CubeMove where
square-push-rb : ∀ {i} {A : Type i} {a₀₀ a₀₁ a₁₀ a₁₁ b : A}
{p₀₋ : a₀₀ == a₀₁} {p₋₀ : a₀₀ == a₁₀}
{p₋₁ : a₀₁ == a₁₁} (p₁₋ : a₁₀ == b) (q : b == a₁₁)
→ Square p₀₋ p₋₀ p₋₁ (p₁₋ ∙ q)
... |
-- test termination using structured orders
module TerminationTupledAckermann where
data Nat : Set where
zero : Nat
succ : Nat -> Nat
data _×_ (A B : Set) : Set where
_,_ : A -> B -> A × B
-- addition in tupled form
add : Nat × Nat -> Nat
add (zero , m) = m
add (succ n , m) = succ (add (n , m))
-- a... |
{-# OPTIONS --without-K #-}
open import HoTT
open import homotopy.HSpace renaming (HSpaceStructure to HSS)
open import homotopy.Freudenthal
open import homotopy.IterSuspensionStable
open import homotopy.Pi2HSusp
open import homotopy.EM1HSpace
module homotopy.EilenbergMacLane where
-- EM(G,n) when G is π₁(A,a₀)
modul... |
-- Andreas, 2015-07-13 Better parse errors for illegal type signatures
A : Set where B = C
|
-- Andreas, 2019-08-10, weird error for naked ellipsis
...
-- Error (weird):
-- Missing type signature for left hand side ...
-- when scope checking the declaration
-- ...
-- When following the suggestion to give a type signature,
--
-- ... : Set
--
-- Agda says:
-- The ellipsis ... cannot have a type signature
... |
{-# OPTIONS --safe #-}
module Cubical.Relation.Binary.Extensionality where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Transport
open import Cubical.Data.Sigma
open import Cubical.Relation.Binary.Base
module _ {... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Magma.Submagma where
open import Cubical.Core.Everything
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Algebra
open import Cubical.Algebra.Magma.Morphism
open import Cubical.Relation.Unary
... |
-- Andreas, 2016-09-09 issue #2168 reported by Nisse
-- {-# OPTIONS -v tc.cover.splittree:30 -v tc.cc:40 #-}
open import Common.Equality
data Unit : Set where
unit : Unit
data Bool : Set where
true false : Bool
f : Unit → Bool → Bool
f unit true = false
f = λ _ _ → true
-- Testing definitional equality:
f-1 :... |
{-# OPTIONS --without-K #-}
open import Relation.Binary.PropositionalEquality as P
data Phantom {i} {A : Set i} (a : A) : Set where
phantom : Phantom a
module _ where
private
data #Σ-aux (A : Set) (B : A → Set) : Set where
#pair : (x : A) → B x → #Σ-aux A B
Σ : (A : Set) → (A → Set) → Set
Σ A B = ... |
{-# OPTIONS --without-K --exact-split --safe #-}
open import Fragment.Equational.Theory
module Fragment.Equational.FreeExtension.Synthetic (Θ : Theory) where
open import Fragment.Algebra.Signature
open import Fragment.Algebra.Algebra (Σ Θ) using (Algebra)
open import Fragment.Equational.Model Θ
open import Fragment.... |
{-# OPTIONS -v tc.with.display:30 #-}
-- {-# OPTIONS -v tc.with.strip:30 #-}
open import Common.Product
open import Common.Prelude
open import Common.Equality
postulate
p : Nat → Nat
-- g : Nat → Nat × Nat
-- g x .proj₁ with p x
-- g x .proj₁ | 0 = 1
-- g x .proj₁ | suc y = 0
-- g x .proj₂ = suc x
-- h : Nat → Na... |
{-# OPTIONS --rewriting --without-K #-}
open import Prelude
open import GSeTT.Syntax
open import GSeTT.Rules
open import Sets ℕ eqdecℕ
{- PS-contexts -}
module CaTT.Ps-contexts where
{- Rules for PS-contexts -}
data _⊢ps_#_ : Pre-Ctx → ℕ → Pre-Ty → Set₁ where
pss : (nil :: (O , ∗)) ⊢ps O # ∗
psd : ∀ {Γ ... |
{-# OPTIONS --without-K --safe #-}
module Fragment.Tactic.Fragment where
open import Reflection hiding (name; Type; _≟_)
open import Reflection.Term using (_≟_)
open import Level using (_⊔_)
open import Relation.Binary using (Setoid)
open import Data.Bool using (Bool; _∨_; true; false; if_then_else_)
open import Da... |
module Issue580 where
record Bad : Set₁ where
private field A : Set
|
postulate
Wrap : Set → Set
instance wrap : {A : Set} → A → Wrap A
postulate
I : Set
P : I → Set
HO = ∀ {i} {{p : P i}} → P i
postulate
X : {{ho : HO}} → Set
Y : {{ho : Wrap HO}} → Set
Works : Set
Works = X
-- Debug output shows messed up deBruijn indices in unwrapped target: P p instead of P i
Fails :... |
------------------------------------------------------------------------
-- Most of a virtual machine
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
module Lambda.Virtual-machine where
open import Equality.Propositional
open import Prelude
open import Vec.Func... |
module Class.Equality where
open import Data.Bool using (Bool; if_then_else_)
open import Data.List
open import Data.Product
open import Relation.Nullary
open import Relation.Nullary.Decidable
open import Relation.Binary.PropositionalEquality
record Eq (A : Set) : Set where
field
_≟_ : (x y : A) -> Dec (x ≡ y)
... |
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.RPn where
open import Cubical.HITs.RPn.Base public
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.