text stringlengths 4 690k |
|---|
open import Relation.Binary.Core
module TreeSort.Impl2.Correctness.Order {A : Set}
(_≤_ : A → A → Set)
(tot≤ : Total _≤_)
(trans≤ : Transitive _≤_) where
open import BBSTree _≤_
open import BBSTree.Properties _≤_ trans≤
open import Data.List
open import Functi... |
module Issue637 where
data Nat : Set where
zero : Nat
suc : Nat → Nat
infixl 60 _+_
_+_ : Nat → Nat → Nat
zero + n = n
suc m + n = suc (n + m)
data _≡_ {A : Set}(x : A) : A → Set where
refl : x ≡ x
`1 = suc zero
`2 = suc `1
`3 = suc `2
`4 = `2 + `2
`8 = `4 + `4
`16 = `8 + `8
`32 = `16 + `16
`50 = `32 + `16 +... |
module plfa-exercises.Practice3 where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; sym; trans; cong)
open Eq.≡-Reasoning using (_≡⟨⟩_; _≡⟨_⟩_; begin_; _∎)
open import Data.Bool using (Bool; true; false; T; _∧_; _∨_; not)
open import Data.Nat using (ℕ; zero; suc; _+_; _*_; _∸_; _≤_; s≤s;... |
{-# OPTIONS --without-K --safe #-}
-- The 'Trivial' instance, with a single arrow between objects
module Categories.Theory.Lawvere.Instance.Triv where
open import Data.Nat using (_*_)
open import Data.Unit.Polymorphic using (⊤; tt)
open import Relation.Binary.PropositionalEquality
using (_≡_; refl; isEquivalence)
... |
{- 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.Prelude
open import LibraBFT.Lemmas
-- TODO-2: The follow... |
module Agda.Builtin.Float where
open import Agda.Builtin.Bool
open import Agda.Builtin.Nat
open import Agda.Builtin.Int
open import Agda.Builtin.String
postulate Float : Set
{-# BUILTIN FLOAT Float #-}
primitive
primFloatEquality : Float → Float → Bool
primFloatLess : Float → Float → Bool
primNatToFloat ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Coinductive "natural" numbers
------------------------------------------------------------------------
{-# OPTIONS --without-K --guardedness --sized-types #-}
module Codata.Musical.Conat where
open import Coda... |
module index where
-- A formalisation of Haskell B. Curry’s thesis Grundlagen der Kombinatorischen
-- Logik. See <https://www.jstor.org/stable/2370619> (part 1) and
-- <https://www.jstor.org/stable/2370716> (part 2).
import CombinatoryLogic.Equality
import CombinatoryLogic.Forest
import CombinatoryLogic.Semantics
impo... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Membership predicate for fresh lists
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
module Data.List.Fresh.Membership.Se... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Bijections on finite sets (i.e. permutations).
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Fin.Permutation where
open import Data.Emp... |
-- Andreas, 2016-01-27
-- After complaints of Wolfram Kahl and Aaron Stump
-- we decided it is imported to keep the rewrite behavior
-- that does not rewrite in rewrite terms.
open import Common.Equality
test : ∀{A : Set}{a : A}{f : A → A} (p : f a ≡ a) → f (f a) ≡ a
test p rewrite p = p
-- rewrite should not happen... |
module Morphism where
open import Data.Nat
open import Data.Unit
open import Data.Product
open import Relation.Binary.PropositionalEquality
open import Prelude
open import Structure
module _ {A B : Set} (σᴬ : Struct A) (σᴮ : Struct B) where
open Struct σᴬ renaming (ℜ to ℜᴬ ; 𝔉 to 𝔉ᴬ)
open Struct σᴮ renaming (ℜ... |
{-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Order
open import Numbers.Naturals.Order.Lemmas
open import Numbers.Naturals.Order.WellFounded
open import Numbers.Primes.PrimeNumbers
open import Semirings.Definition
open ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Streams
------------------------------------------------------------------------
module Data.Stream where
open import Coinduction
open import Data.Colist using (Colist; []; _∷_)
open import Data.Vec using (V... |
{-# OPTIONS --cubical --safe #-}
module Cubical.Data.BinNat where
open import Cubical.Data.BinNat.BinNat public
|
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Functor hiding (id)
-- Limit of a Cone over a Functor F : J → C
module Categories.Diagram.Limit
{o ℓ e} {o′ ℓ′ e′} {C : Category o ℓ e} {J : Category o′ ℓ′ e′} (F : Functor J C) where
private
module C = Category C
module ... |
open import Data.Product using ( _,_ )
open import Data.Empty using ( ⊥ )
open import FRP.LTL.ISet.Core using ( ISet ; [_] ; _,_ )
module FRP.LTL.ISet.Empty where
F : ISet
F = [ (λ i → ⊥) , (λ i j i~j → λ ()) , (λ i j i⊑j → λ ()) ]
|
module ReducingConstructorsInWith where
data ⊤ : Set where
tt : ⊤
module RegExps where
data RegExp : Set where
_│_ : RegExp -> RegExp -> RegExp
open module R = RegExps
bypassable : (re : RegExp) -> ⊤
bypassable (re₁ │ re₂) with bypassable re₁
bypassable (re₁ │ re₂) | m = m
|
module MonoidalCat where
open import Library hiding (_×_)
open import Categories
open import Categories.Products
open import Functors
open import Naturals
record Monoidal {l}{m} : Set (lsuc (l ⊔ m)) where
field C : Cat {l}{m}
open Cat C
open Fun
open NatI
field ⊗ : Fun (C × C) C
I : Obj
I... |
module stateDependentObjects where
open import Size renaming (Size to AgdaSize)
open import Agda.Builtin.Equality
open import Data.Nat.Base as N hiding (_⊔_)
open import Data.Product
open import Data.Vec as Vec using (Vec; []; _∷_; head; tail)
open import Function
open import NativeIO
open import Relation.Binary.Propo... |
{-# OPTIONS --without-K #-}
open import Data.Nat.Base using (ℕ)
open import Data.Product
open import HoTT
open import Function.Extensionality
open import Algebra.Group
open import Algebra.Group.Homomorphism
open import Algebra.Group.Isomorphism
open import Function using (id; _∘_ ; flip)
open import Relation.Binary.Pro... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- The universe polymorphic unit type and the total relation on unit
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Unit.Polymorphic where
... |
open import Relation.Binary using (Decidable; DecSetoid)
open import Level
module CP.Session2 {a} (ChanSetoid : DecSetoid zero a) (Type : Set) where
Chan : Set
Chan = DecSetoid.Carrier ChanSetoid
_≟Chan_ = DecSetoid._≟_ ChanSetoid
_≈Chan_ = DecSetoid._≈_ ChanSetoid
_≉Chan_ = DecSetoid._≉_ ChanSetoid
infixl 5 _,_... |
{-# OPTIONS --safe --without-K #-}
open import Relation.Binary.PropositionalEquality using (_≡_; refl; cong; sym)
open import Relation.Nullary using (Dec; yes; no)
open import Relation.Nullary.Decidable using (fromWitness; toWitness)
open import Function using (_∘_)
open import Data.Empty using (⊥-elim)
import Data.F... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Conversion of _≤_ to _<_
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary
module Relation.Binary.Construct.NonStrictToStri... |
-- Andreas 2012-09-27, reported by Fredrik Forsberg
{-# OPTIONS --sized-types #-}
module Issue701-c where
open import Common.Size
{- If I understand correctly, unconstrained sizes should be resolved to \infty.
If I define -}
data U : {i : Size} -> Set where
c : {i : Size} -> U {↑ i}
data V : {i : Size} ->... |
open import Relation.Binary.Core using (Decidable ; _≡_)
module Precond (Carrier : Set) (deq : Decidable {A = Carrier} _≡_) where
open import Data.Nat using (ℕ)
open import Data.Fin using (Fin ; zero ; suc)
open import Data.Fin.Properties using (_≟_)
open import Data.List using (List ; [] ; _∷_)
open import Level usi... |
module Data.Real.Properties where
open import Data.Real.Base as ℝ
open import Data.Real.Order
open import Data.Real.Abstract.Structures
using (IsOrderedHeytingField; IsArchimedanHeytingField)
open import Assume
open import Algebra using (IsCommutativeRing; CommutativeRing)
open import Algebra.Module using (Module)
o... |
module MalformedModuleNameInIMPORT where
{-# IMPORT m #-}
|
module Numeral.Natural.TotalOper where
import Lvl
open import Logic.Propositional
open import Logic.Predicate
open import Numeral.Natural hiding (𝐏)
open import Numeral.Natural.Relation.Divisibility
open import Numeral.Natural.Relation.Divisibility.Proofs
open import Numeral.Natural.Relation
open import Numeral.Natur... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category.Groupoid
module Categories.Category.Groupoid.Properties {o ℓ e} (G : Groupoid o ℓ e) where
import Categories.Morphism as Morphism
import Categories.Morphism.Properties as MorphismProps
import Categories.Morphism.Reasoning as MR
open Groupoid G
open M... |
module examplesPaperJFP.Coalgebra where
open import Size
F : Set → Set
mapF : ∀{A B} (f : A → B) → (F A → F B)
--- Dummy implementation to satisfy Agda's positivity checker.
F X = X
mapF f x = f x
S : Set
t : S → F S
data S′ : Set where
S = S′
t x = x
record νF : Set where
coinductive
fie... |
------------------------------------------------------------------------
-- Semantics
------------------------------------------------------------------------
module RecursiveTypes.Semantics where
open import Codata.Musical.Notation
open import RecursiveTypes.Syntax
open import RecursiveTypes.Substitution
-- The se... |
module iff-erasure where
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
open import Data.Empty using (⊥-elim)
-- open import plfa.part1.Isomorphism using (_⇔_)
open import decidable using (Dec; yes; no; Bool; true; false; ⌊_⌋)
-- 同値 (equivalence)
record _⇔_ (A B : Set) : Set where
field
to ... |
{-
The Inductive Version of James Construction
This file contains:
- An inductive family 𝕁, and its direct colimit is equivalence to James;
(KANG Rongji, Feb. 2022)
- The family 𝕁 can be iteratively constructed as pushouts;
- Special cases of 𝕁 n for n = 0, 1 and 2;
- Connectivity of inclusion maps.
T... |
{-# OPTIONS --cubical #-}
open import Agda.Builtin.Cubical.Path
open import Agda.Primitive
open import Agda.Primitive.Cubical
variable
a p : Level
A : Set a
P : A → Set p
eq₁ u v x y : A
refl : x ≡ x
refl {x = x} = λ _ → x
subst : (P : A → Set p) → x ≡ y → P x → P y
subst P x≡y p... |
module _ where
postulate
C : Set → Set
A : Set
i : C A
foo : {X : Set} {{_ : C X}} → X
bar : A
bar = let instance z = i in foo
|
-- By default both sized types and constructor-based guardedness are
-- available.
open import Agda.Builtin.Size
record Stream (A : Set) : Set where
coinductive
field
head : A
tail : Stream A
open Stream
repeat : ∀ {A} → A → Stream A
repeat x .head = x
repeat x .tail = repeat x
record Sized-stream (A :... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.Polynomials.Multivariate.Equiv.Poly0-A where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Nat renaming (_+_ to _+n_; _·_ to _·n_)
open import Cubical.Data.Vec
open import Cub... |
{-# OPTIONS --cubical --safe #-}
module Cubical.Relation.Everything where
open import Cubical.Relation.Nullary public
open import Cubical.Relation.Nullary.DecidableEq public
open import Cubical.Relation.Binary public
|
open import Issue2229Base public
|
-- Andreas, 2019-08-08, issue #3962 reported (+ test case) by guillaumebrunerie
-- Don't lex "{{" as instance braces if followed by "-", as this will confuse Emacs.
-- Rather lex "{{-" as "{" "{-".
postulate
A : Set
f : {{_ : A}} → Set
-x : A
B : Set
B = f {{-x}}
C : Set
C = ?
-- WAS: passes parser but confu... |
module Numeral.Finite.Oper.Comparisons where
import Lvl
open import Data.Boolean
import Data.Boolean.Operators
open Data.Boolean.Operators.Programming
open import Functional
open import Numeral.Finite
open import Numeral.Sign
-- Compare
_⋚?_ : ∀{a b} → 𝕟(a) → 𝕟(b) → (−|0|+)
𝟎 ⋚? 𝟎 = 𝟎
𝟎 ... |
{-# OPTIONS --without-K #-}
module Universe.Utility.General where
open import lib.Basics
open import lib.NType2
open import lib.types.Nat hiding (_+_)
open import lib.types.Pi
open import lib.types.Sigma
open import lib.types.Unit
-- A readable notation for the join of universe levels.
infixr 8 _⊔_
_⊔_ : ULevel →... |
module Data.ByteString.Utf8 where
open import Data.ByteString.Primitive
open import Data.String using (String)
{-# FOREIGN GHC import qualified Data.ByteString #-}
{-# FOREIGN GHC import qualified Data.Text.Encoding #-}
postulate
packStrict : String → ByteStringStrict
unpackStrict : ByteStringStrict → String
{-# ... |
--------------------------------------------------------------------------------
-- This is part of Agda Inference Systems
{-# OPTIONS --sized-types --guardedness #-}
open import Agda.Builtin.Equality
open import Data.Product
open import Data.Sum
open import Data.Empty
open import Data.Unit
open import Level
open imp... |
?bug : Set
?bug = ?
-- Andreas, 2014-04-16
-- Issue 1104 reported by Fabien Renaud.
-- Emacs mode got confused by identifiers containing --
-- Problem: {!!} is not turned into hole
bug-- : Set
bug-- = ?
another : Set
another = (-- Senfgurke ?
{!!})-- Noch eine Senfgurke ?
_:--_ : Set → Set → Set
_:--_ =... |
{-# OPTIONS --without-K #-}
module hott.topology.loopspace where
open import hott.core
open import hott.types
open import hott.functions
-- The pointed loop space
Ω∙ : ∀{ℓ} → Type● ℓ → Type● ℓ
Ω∙ (A , a) = (a ≡ a , refl)
-- The loops space. It is obtained by suppressing the base point of
-- the corresponding poin... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
open import Cubical.Foundations.HLevels
module Cubical.Algebra.Group.Construct.Free {ℓ} (Aˢ : hSet ℓ) where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Unival... |
{-# OPTIONS --cubical #-}
module n2o.Network.Http where
|
{-
This second-order term syntax was created from the following second-order syntax description:
syntax PDiff | PD
type
* : 0-ary
term
zero : * | 𝟘
add : * * -> * | _⊕_ l20
one : * | 𝟙
mult : * * -> * | _⊗_ l20
neg : * -> * | ⊖_ r50
pd : *.* * -> * | ∂_∣_
theory
(𝟘U⊕ᴸ) a |> add... |
module TruthValue where
open import OscarPrelude
record TruthValue : Set
where
constructor ⟨_⟩
field
truthValue : Bool
open TruthValue public
|
module Base.Free.Instance.Identity.Properties where
open import Relation.Binary.PropositionalEquality using (refl; cong)
open import Base.Free using (Free; pure; impure)
open import Base.Free.Instance.Identity renaming (Identity to IdentityF)
open impo... |
module Nats.Multiply.Comm where
open import Nats
open import Equality
open import Function
open import Nats.Add.Comm
open import Nats.Add.Assoc
------------------------------------------------------------------------
-- internal stuffs
private
a*0=0*a : ∀ a → a * 0 ≡ 0
a*0=0*a zero = refl
a*0=0*a (suc a) ... |
postulate
A : →.B
|
{-# OPTIONS --without-K --exact-split #-}
module 13-propositional-truncation where
import 12-function-extensionality
open 12-function-extensionality public
-- Section 13 Propositional truncations, the image of a map, and the replacement axiom
-------------------------------------------------------------------------... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Categories.Structures where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.HLevels using (isSetΣ)
open import Cubical.Data.Sigma
open import Cubical.Categories.Category
_∋_ : ∀ {ℓ} ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- The reader monad
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Level
module Category.Monad.Reader {r} (R : Set r) (a : Level) where
op... |
module Data.Real.Diff where
open import Level using (0ℓ)
import Data.Real as ℝ
open ℝ using (ℝ)
open import Data.Real.Properties
import Data.Nat as ℕ
open ℕ using (ℕ; suc; zero; _⊓_; _⊔_)
open import Data.Unit.Polymorphic using (tt; ⊤)
open import Data.Product using (_×_; _,_; proj₁; proj₂)
open import Function usi... |
------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Sets of variables
------------------------------------------------------------------------
module Base.Syntax.Vars
(Type : Set)
where
-- The notion of sets of variables
--
-- This module is calculus-indepen... |
{-# OPTIONS --cubical --safe #-}
module Inspect where
open import Level
open import Path
record Reveal_·_is_ {A : Type a} {B : A → Type b} (f : (x : A) → B x) (x : A) (y : B x) : Type b where
constructor 〖_〗
field eq : f x ≡ y
inspect : {A : Type a} {B : A → Type b} (f : (x : A) → B x) (x : A) → Reveal f · x is... |
open import Prelude
module Implicits.Resolution.Deterministic.Expressiveness where
open import Data.Fin.Substitution
open import Implicits.Syntax
open import Implicits.Syntax.Type.Unification
open import Implicits.Resolution.Ambiguous.Resolution as A
open import Implicits.Resolution.Deterministic.Resolution as D
open... |
{-# OPTIONS --universe-polymorphism #-}
open import Common.Prelude
renaming (Nat to ℕ; module Nat to ℕ)
using (zero; suc; _+_; _∸_; List; []; _∷_; Bool; true; false)
open import Common.Level
open import Common.Reflect
module TermSplicing where
module Library where
data Box {a} (A : Set a) : Set a where
box... |
module BHeap {A : Set}(_≤_ : A → A → Set) where
open import Bound.Lower A
open import Bound.Lower.Order _≤_
open import BTree {A} hiding (flatten)
open import Data.Nat hiding (_≤_)
open import Data.List
open import Data.Sum renaming (_⊎_ to _∨_)
open import Relation.Binary
open import Relation.Binary.Core
open import ... |
open import SingleSorted.AlgebraicTheory
import SingleSorted.Interpretation as Interpretation
import SingleSorted.SyntacticCategory as SyntacticCategory
import SingleSorted.Substitution as Substitution
module SingleSorted.UniversalInterpretation
{ℓt}
{Σ : Signature}
(T : Theory ℓt Σ) where
open Theory T
o... |
open import Agda.Builtin.Unit
open import Agda.Builtin.Nat
open import Agda.Builtin.List
open import Agda.Builtin.Reflection renaming (bindTC to _>>=_)
open import Agda.Builtin.Equality
macro
macro₁ : Term -> TC ⊤
macro₁ goal = do
u ← quoteTC ((1 + 2) - 3)
u' ← onlyReduceDefs (quote _+_ ∷ []) (normalise... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Homomorphism proofs for variables and constants over polynomials
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Tactic.RingSolver.Core.Po... |
{-
Holey congruence for propositional equality.
-}
module Holes.Cong.Propositional where
open import Holes.Prelude
open PropEq using (_≡_; refl; cong; sym; trans)
import Holes.Cong.General as Cong
open Cong (quote cong) (quote sym) public
using (cong!)
|
data N : Set where
suc : N → N
data Val : N → Set where
valSuc : ∀ n → Val (suc n)
record R : Set where
constructor wrap
field unwrap : N
data W (ft : R) : Set where
immed : (v : Val (R.unwrap ft)) → W ft
test : (fa : R) → W fa → R
test fa (immed (valSuc a)) = fa
postulate
Evaluate : ∀ (ft : R) (P : (... |
module Operations.Combinatorial where
open import Data.Bool using (true; false)
import Data.Bool as B
import Data.Fin as F
open import Data.Nat using (ℕ; suc)
open import Data.Vec using ([]; _∷_)
import Data.Vec as V
open import Relation.Binary.PropositionalEquality
open import Types
open import Ev... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Homotopy.Group.Base where
open import Cubical.Homotopy.Loopspace
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed
open import Cubical.Foundations.Pointed.Homogeneous
open import Cubical.Foundations.HLevels
open impor... |
{-# OPTIONS --show-implicit #-}
-- {-# OPTIONS --sized-types #-} -- no longer necessary
-- {-# OPTIONS --termination-depth=2 #-} -- no longer necessary
-- {-# OPTIONS -v term:10 #-}
module SizedBTree where
open import Common.Size
module Old where
data BTree (A : Set) : {size : Size} → Set where
leaf :... |
{-# OPTIONS --safe #-}
open import Relation.Ternary.Separation
module Relation.Ternary.Separation.Allstar
{i} {I : Set i}
{c} {C : Set c} {{rc : RawSep C}} {u} {{sc : IsUnitalSep rc u}}
where
open import Level
open import Data.Product
open import Data.List hiding (concat)
open import Relation.Unary
{- Inductiv... |
------------------------------------------------------------------------------
-- Testing the translation of 11-ary predicates symbols
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-un... |
-- The bug documented below was exposed by the fix to issue 274.
{-# OPTIONS --universe-polymorphism #-}
module Issue274 where
postulate
Level : Set
zero : Level
suc : Level → Level
_⊔_ : Level → Level → Level
{-# BUILTIN LEVEL Level #-}
{-# BUILTIN LEVELZERO zero #-}
{-# BUILTIN LEVELSUC suc #-}
{... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import cohomology.ChainComplex
open import cohomology.Theory
open import groups.KernelImage
open import cw.CW
module cw.cohomology.ReconstructedFirstCohomologyGroup {i : ULevel} (OT : OrdinaryTheory i) where
open OrdinaryTheory OT
import cw.cohomology... |
{-# OPTIONS --without-K #-}
open import Base
open import Homotopy.Pointed
open import Homotopy.Connected
module Homotopy.Cover.HomotopyGroupSetIsomorphism {i}
(A⋆ : pType i) (A⋆-is-conn : is-connected⋆ ⟨0⟩ A⋆) where
open pType A⋆ renaming (∣_∣ to A ; ⋆ to a)
open import Algebra.Groups
open import Homotopy.Tr... |
{-# OPTIONS --safe #-}
module Cubical.HITs.Susp.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Path
open import Cubical.Foundations.Pointed
open import Cub... |
-- With functions are now inlined before termination checking.
module Issue59 where
open import Common.Prelude
open import Common.Equality
module Order (A : Set) (_≤_ : A → A → Bool) where
-- This now termination checks.
merge : List A → List A → List A
merge [] ys = ys
merge xs [] = xs
merge (x ∷ xs) (y ∷... |
{-# OPTIONS --without-K #-}
{-
Favonia: I was trying to generalize OneSkeleton but failed
to achieve what I wanted. Nicolai then told me this HIT
which is suitable for the constancy lemma I was looking for.
This construction should be attributed to Paolo Capriotti
and Nicolai Kraus. [1]
[1] Eliminating ... |
{-# OPTIONS --cubical --safe #-}
module Cubical.Data.Strict2Group.Explicit.Interface where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Group.Base
open import Cubical.Data.Sigma
open import Cubical.Data.Strict2Group.Explicit.Base
open import Cubical.Data.Strict2Group.Explicit.Notation
module S2G... |
open import FRP.LTL.ISet.Core using ( ISet ; ⌈_⌉ ; ⌊_⌋ )
open import FRP.LTL.RSet using ( RSet )
open import FRP.LTL.Time using ( Time ; _≤_ )
module FRP.LTL.ISet.Future where
data Future (A : RSet) (t : Time) : Set where
_,_ : ∀ {u} .(t≤u : t ≤ u) → A u → Future A t
◇ : ISet → ISet
◇ A = ⌈ Future ⌊ A ⌋ ⌉ |
module WarningOnUsage2 where
open import WarningOnUsage
λx→x₂ = λx→x
|
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NConnected
open import lib.NType2
open import lib.types.FunctionSeq
open import lib.types.Span
open import lib.types.Pointed
open import lib.types.Pushout
open import lib.types.PushoutFlip
open import lib.types.PushoutFmap
open import lib.t... |
-- Type interpretation and soundness of typing.
-- Proof of strong normalization for well-typed terms.
module Soundness where
open import Library
open import Terms
open import Substitution
open import SN
open import SN.AntiRename
open import DeclSN using (sn; fromSN)
open import SAT3
-- Type interpretation
⟦_⟧ : (... |
{-# OPTIONS --safe #-}
module Cubical.Homotopy.Hopf where
open import Cubical.Homotopy.HSpace
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Transport
open import Cubical.Foundations.Function
open import Cubical.Foundations.Pointed
open import Cubical.F... |
{- Voevodsky's proof that univalence implies funext -}
{-# OPTIONS --cubical --safe #-}
module Cubical.Experiments.FunExtFromUA where
open import Cubical.Core.Everything
open import Cubical.Foundations.Everything
variable
ℓ ℓ' : Level
_∼_ : {X : Type ℓ} {A : X → Type ℓ'} → (f g : (x : X) → A x) → Type (ℓ-max ℓ ℓ')... |
{-# OPTIONS --cubical #-}
module _ where
-- Test case by Ulf Norell, 16/09/2020
open import Agda.Primitive.Cubical renaming (primIMin to _∧_)
open import Agda.Builtin.Cubical.Path using (_≡_)
data Nat : Set where
zero : Nat
suc : Nat → Nat
record Pos : Set where
constructor 1+_
field unpos : Nat
open P... |
------------------------------------------------------------------------
-- Inductively defined beta-eta-equality
------------------------------------------------------------------------
import Level
open import Data.Universe
module README.DependentlyTyped.Beta-Eta
(Uni₀ : Universe Level.zero Level.zero)
where
o... |
-- Andreas, 2012-10-19 issue #719 blame correct module
-- Andreas, 2017-07-28 point to correct binding site ("as A")
module Issue719 where
import Common.Size as A
module M where
private open module A = M
-- WAS:
-- Duplicate definition of module A. Previous definition of module A
-- at .../Common/Size.agda:7,... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category.Core using (Category)
module Categories.Diagram.Coequalizer {o ℓ e} (𝒞 : Category o ℓ e) where
open Category 𝒞
open HomReasoning
open Equiv
open import Categories.Morphism 𝒞
open import Categories.Morphism.Reasoning 𝒞
open import Level
open imp... |
module Numeral.Natural.Relation.Order.Proofs where
import Lvl
open import Data.Tuple as Tuple using (_⨯_ ; _,_)
open import Functional
open import Logic
open import Logic.Propositional
open import Logic.Propositional.Theorems
open import Logic.Predicate
open import Numeral.Natural
open import Numeral.Natural.Oper
open... |
-- Andreas, 2014-05-17
open import Common.Prelude
open import Common.Equality
postulate
bla : ∀ x → x ≡ zero
P : Nat → Set
p : P zero
f : ∀ x → P x
f x rewrite bla {!!} = {!!}
-- Expected: two interaction points!
|
-- Andreas, 2018-11-03, issue #3364
-- Andreas, 2019-02-23, issue #3457
--
-- Better error when trying to import with new qualified module name.
open import Agda.Builtin.Nat as Builtin.Nat
-- WAS: Error:
-- Not in scope:
-- as at ...
-- when scope checking as
-- NOW: Warning
-- `as' must be followed by an identifi... |
module _ where
record Semiring (A : Set) : Set where
infixl 6 _+_
field _+_ : A → A → A
open Semiring {{...}} public
infix 4 _≡_
postulate
Nat Bool : Set
_≡_ : Nat → Nat → Set
refl : ∀ {x} → x ≡ x
to : ∀ {x} (y : Nat) → x ≡ y
trans : {x y z : Nat} → x ≡ y → y ≡ z → x ≡ z
instance _ : Semiri... |
module Text.Greek.SBLGNT.Col where
open import Data.List
open import Text.Greek.Bible
open import Text.Greek.Script
open import Text.Greek.Script.Unicode
ΠΡΟΣ-ΚΟΛΟΣΣΑΕΙΣ : List (Word)
ΠΡΟΣ-ΚΟΛΟΣΣΑΕΙΣ =
word (Π ∷ α ∷ ῦ ∷ ∙λ ∷ ο ∷ ς ∷ []) "Col.1.1"
∷ word (ἀ ∷ π ∷ ό ∷ σ ∷ τ ∷ ο ∷ ∙λ ∷ ο ∷ ς ∷ []) "Col.1.1"
∷ wo... |
module ExCoinduction where
open import Coinduction
open import Relation.Binary.PropositionalEquality
open import Data.Stream
open import Data.Nat
open import Data.Bool
data Loc : Set where
A : Loc
DONE : Loc
record Values : Set where
field
x : ℕ
δ : ℕ
k : ℕ
data _Π_ (A B : Set) : Set where
<_,_> ... |
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.Relation
module lib.types.SetQuotient where
module _ {i} {A : Type i} {j} where
private
data #SetQuotient-aux (R : Rel A j) : Type i where
#q[_] : A → #SetQuotient-aux R
data #SetQuotient (R : Rel A j) : Type i where
#setquot... |
-- Andreas, 2020-02-15
-- Test case by Jesper to prevent regressions when fixing #3541.
-- Jesper, 2019-09-12: The fix of #3541 introduced a regression: the
-- index of the equality type is treated as a positive argument.
postulate X : Set
module EqualityAsPredicate where
data _≡_ (A : Set) : Set → Set where
... |
{-# OPTIONS --cubical --no-import-sorts --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... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.