text stringlengths 4 690k |
|---|
module Data.Fin.Subset.Cardinality where
open import Data.Fin.Subset
_∖_ : ∀ {n} → Subset n → Subset n → Subset n
_∖_ {n} a b = a ∩ ∁ b
|
------------------------------------------------------------------------------
-- Properties related with lists
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}... |
module Issue3188.Issue3188a where
postulate String : Set
{-# BUILTIN STRING String #-}
|
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Reducibility {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Lo... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.DunceCap where
open import Cubical.HITs.DunceCap.Base public
open import Cubical.HITs.DunceCap.Properties public
|
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.Snd {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped as U hiding (wk)
open import Definition.Untyped.Properties
open import Definition.Typed
ope... |
{-# OPTIONS --universe-polymorphism #-}
module Issue333 where
open import Common.Level
data Σ a b (A : Set a) (B : A → Set b) : Set (a ⊔ b) where
_,_ : (x : A) → B x → Σ a b A B
P : ∀ a b (A : Set a) (B : Set b) → Set (a ⊔ b)
P a b A B = Σ a b A (λ _ → B)
postulate
A B : Set
foo : Σ lzero lzero A λ (y : A) →... |
{-# OPTIONS --rewriting #-}
open import Common.Prelude
open import Common.Equality
{-# BUILTIN REWRITE _≡_ #-}
postulate
f : Bool → Bool
boolTrivial : ∀ (b c : Bool) → f b ≡ c
{-# REWRITE boolTrivial #-}
-- Should trigger an error that c is not bound on the lhs.
|
module L.Base.Nat where
-- Reexport definitions
open import L.Base.Nat.Core public
-- Functions on Nats
pred : Nat → Nat
pred = ind (λ _ → Nat) zero (λ x _ → x)
infixl 6 _+_
infixl 7 _*_
_+_ : Nat → Nat → Nat
zero + y = y
succ x + y = succ (x + y)
{-# BUILTIN NATPLUS _+_ #-}
_*_ : Nat → Nat → Nat
zero * y = z... |
{-# OPTIONS --without-K #-}
module sets.nat.solver where
open import decidable
open import equality
open import function.core
hiding (const)
open import sets.nat.core
open import sets.nat.properties
open import sets.nat.ordering
open import sets.fin.core
hiding (_≟_)
open import sets.vec.core
open import sets.vec... |
{-
This module defines the basic opens of the Zariski lattice and proves that they're a basis of the lattice.
It also contains the construction of the structure presheaf and a proof of the sheaf property on basic opens,
using the theory developed in the module PreSheafFromUniversalProp and its toSheaf.lemma.
... |
{-# OPTIONS --erased-cubical #-}
open import Agda.Builtin.Cubical.Path
-- Higher constructors must be erased when --erased-cubical is used.
data ∥_∥ (A : Set) : Set where
∣_∣ : A → ∥ A ∥
trivial : (x y : ∥ A ∥) → x ≡ y
|
------------------------------------------------------------------------
-- Lemmas related to application of substitutions
------------------------------------------------------------------------
-- The record below allows the application operation to be
-- "heterogeneous", applying substitutions containing one kind o... |
module Abstract where
data Bool : Set where
true false : Bool
not : Bool → Bool
not true = false
not false = true
abstract
Answer : Set
Answer = Bool
yes : Answer
yes = true
no : Answer
no = false
contradict : Answer → Answer
contradict x = not x
counter-contradict : Answer → Answer
counter-c... |
------------------------------------------------------------------------
-- Excluded middle
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
module Excluded-middle
{e⁺} (eq : ∀ {a p} → Equality-with-J a p e⁺) where
open Derived-defini... |
------------------------------------------------------------------------------
-- Lists examples
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --... |
{-# OPTIONS --cubical --no-import-sorts #-}
open import Cubical.Foundations.Everything renaming (_⁻¹ to _⁻¹ᵖ; assoc to ∙-assoc)
import Cubical.Algebra.Semigroup as Std
open import MorePropAlgebra.Bundles
module MorePropAlgebra.Properties.Semigroup {ℓ} (assumptions : Semigroup {ℓ}) where
open Semigroup assumptions re... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Lexicographic ordering of lists
------------------------------------------------------------------------
-- The definition of lexicographic ordering used here is suitable if
-- the argument order is a (non-stric... |
------------------------------------------------------------------------
-- Some definitions related to and properties of the Maybe type
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
module Maybe
{reflexive} (eq : ∀ {a p} → Equality... |
{-# OPTIONS --without-K --safe #-}
open import Level
module Categories.Category.Instance.SimplicialSet.Properties (o ℓ : Level) where
open import Function using (_$_)
open import Data.Empty.Polymorphic using (⊥; ⊥-elim)
open import Data.Nat using (ℕ)
open import Data.Fin using (Fin)
open import Data.Product using (... |
module PLRTree.Equality.Correctness {A : Set} where
open import BTree.Equality {A}
open import PLRTree {A}
open import PLRTree.Equality {A} renaming (_≃_ to _≃'_)
lemma-≃'-≃ : {l r : PLRTree} → l ≃' r → forget l ≃ forget r
lemma-≃'-≃ ≃lf = ≃lf
lemma-≃'-≃ (≃nd x x' l≃'r l'≃'r' l≃'l') = ≃nd x x' (lemma-≃'-≃ l≃'r) (lem... |
-- Andreas, 2019-07-15, issue #3901, requested by msuperdock
--
-- Allow function spaces {A} → B and {{A}} → B.
postulate
A B : Set
foo : {{A}} → B
bar : {A} → B
-- Original feature request:
open import Agda.Builtin.Unit using (⊤; tt)
data ⊥ : Set where
data Nat : Set where
zero : Nat
suc : Nat → Nat... |
-- Jesper, 2018-11-23: Unsolved metas are turned into postulates
-- when --allow-unsolved-metas is enabled, but there was no internal
-- representation of postulated sorts.
module Issue3256 where
open import Issue3256.B
-- WAS:
-- An internal error has occurred. Please report this as a bug.
-- Location of the error:... |
{-# OPTIONS --universe-polymorphism #-}
module Categories.Graphs where
open import Categories.Category
hiding (module Heterogeneous)
open import Data.Product
open import Level
open import Relation.Binary
renaming (_⇒_ to _⊆_)
open import Relation.Binary.PropositionalEquality
using ()
renaming (_≡_ to _≣_; refl... |
{-# OPTIONS --cubical-compatible #-}
module WithoutK1 where
-- Equality defined with one index.
data _≡_ {A : Set} (x : A) : A → Set where
refl : x ≡ x
K : {A : Set} (P : {x : A} → x ≡ x → Set) →
(∀ x → P (refl {x = x})) →
∀ {x} (x≡x : x ≡ x) → P x≡x
K P p refl = p _
|
postulate
U V W X Y Z : Set
u : U
v : V
w : W
x : X
y : Y
z : Z
module Top (u : U) where
module A (v : V) where
module M (w : W) where
module O (x : X) where
postulate O : X
postulate O : X
module B (y : Y) where
open A public
module Test0 where
module C = Top.B u y
modu... |
-- WARNING: This file was generated automatically by Vehicle
-- and should not be modified manually!
-- Metadata
-- - Agda version: 2.6.2
-- - AISEC version: 0.1.0.1
-- - Time generated: ???
{-# OPTIONS --allow-exec #-}
open import Vehicle
open import Vehicle.Data.Tensor
open import Data.Rational as ℚ using (ℚ)
op... |
module Data.List.Kleene.Relation.Unary.All where
open import Data.List.Kleene.Base
open import Relation.Unary
open import Relation.Nullary
open import Level using (_⊔_)
open import Function
mutual
record All⁺ {a p} {A : Set a} (P : Pred A p) (xs : A ⁺) : Set (a ⊔ p) where
constructor P⟨_&_⟩
inductive
f... |
open import Data.List using (List; _∷_; [])
open import Data.Product using (_×_; _,_; Σ)
open import Data.Unit using (⊤; tt)
open import Relation.Binary.PropositionalEquality using (_≡_)
module SystemT where
{- de Bruijn indices are represented as proofs that
an element is in a list -}
data _∈_ {A : Se... |
{-# OPTIONS --universe-polymorphism #-}
open import Categories.Category
open import Categories.Object.BinaryProducts
open import Categories.Object.Exponentiating
module Categories.Object.Exponentiating.Functor {o ℓ e}
(C : Category o ℓ e)
(binary : BinaryProducts C)
(Σ : Category.Obj C)
(exponentiating... |
-- Module shadowing using generated modules for records and datatypes
module Issue260c where
record R : Set where
module R where
|
open import Structure.Setoid
open import Structure.Category
open import Type
module Structure.Category.Monad.ExtensionSystem
{ℓₒ ℓₘ ℓₑ}
{cat : CategoryObject{ℓₒ}{ℓₘ}{ℓₑ}}
where
import Data.Tuple as Tuple
import Function.Equals
open Function.Equals.Dependent
open import Functional.Dependent usin... |
{-# OPTIONS --without-K --safe #-}
open import Level
open import Categories.Category
open import Categories.Monad
module Categories.Monad.Idempotent {o ℓ e} {C : Category o ℓ e} (M : Monad C) where
open import Categories.NaturalTransformation
open import Categories.NaturalTransformation.Equivalence
open import Categ... |
{- Formal verification of authenticated append-only skiplists in Agda, version 1.0.
Copyright (c) 2021 Victor C Miraldo and 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 Data.Unit.NonEta
open import Data.E... |
-- | Examples for SDE.
module SDE-Example where
open import Size
import Level
open import Function
open import Relation.Binary
open import Relation.Binary.PropositionalEquality as P hiding ([_])
open ≡-Reasoning
open import Data.Product as Prod renaming (Σ to ⨿)
open import Data.Nat as Nat
open import Data.Sum as Su... |
-- Basic intuitionistic modal logic S4, without ∨, ⊥, or ◇.
-- Tarski-style semantics with contexts as concrete worlds, and glueing for α, ▻, and □.
-- Gentzen-style syntax.
module BasicIS4.Semantics.TarskiOvergluedGentzen where
open import BasicIS4.Syntax.Common public
open import Common.Semantics public
-- Intuit... |
{-# OPTIONS --cubical --without-K --safe #-}
module Cubical.Relation.Binary.Converse where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Data.Prod hiding (map)
open import Cubical.HITs.PropositionalTruncation
open import Cu... |
module 4-the-natural-numbers where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong; sym)
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_; step-≡; _∎)
open import Data.Nat using (ℕ; zero; suc; _+_; _*_; ⌊_/2⌋)
-- 4)
--sum-to-n : ℕ → ℕ
--sum-to-n n = sum (upTo (suc n))
open import Data.Nat.Pr... |
-- Source: https://raw.githubusercontent.com/gallais/potpourri/master/agda/poc/dimensions/dimensions.agda
-- Author: Original by gallais, modified for test suite by P. Hausmann
-- (Later edited by others.)
{-# OPTIONS --guardedness #-}
module dimensions where
open import Data.Nat as ℕ using (ℕ; NonZero)
open imp... |
{-# OPTIONS --experimental-irrelevance #-}
-- {-# OPTIONS -v tc.univ:100 -v tc.meta:100 #-}
-- {-# OPTIONS -v tc.rec:100 #-}
-- Andreas, 2011-04-27 universe levels can be made irrelevant
-- Ulf 2011-10-03. No they can't. How is that even consistent?
-- Andreas, 2011-10-03. Yes, they can!
-- .(i : Level)(A : Set i) ... |
{-# OPTIONS --copatterns --sized-types #-}
open import Level as Level using (zero)
open import Size
open import Function
open import Relation.Binary
open import Relation.Binary.PropositionalEquality as P
open ≡-Reasoning
open import Data.List using (List; module List; []; _∷_; _++_; length)
open import Data.Nat using... |
module instances where
open import lib public renaming (return to returnᵢₒ; _>>_ to _>>ᵢₒ_; _>>=_ to _>>=ᵢₒ_)
open import functions public
record functor {ℓ ℓ'} (F : Set ℓ → Set ℓ') : Set (lsuc (ℓ ⊔ ℓ')) where
infixl 2 _<$>_ _<$_
field
fmap : ∀ {A B : Set ℓ} → (A → B) → F A → F B
{-functor-identity-law :
... |
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (Rel; Setoid; IsEquivalence)
module 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 (_,_; pr... |
------------------------------------------------------------------------
-- Code related to the paper "Logical properties of a modality for
-- erasure"
--
-- Nils Anders Danielsson
------------------------------------------------------------------------
-- Note that the code does not follow the paper exactly. For inst... |
module Prelude.Nat where
open import Prelude.Bool
data Nat : Set where
Z : Nat
S : Nat -> Nat
{-# BUILTIN NATURAL Nat #-}
infixl 30 _+_
_+_ : Nat -> Nat -> Nat
Z + m = m
S n + m = S (n + m)
{-# BUILTIN NATPLUS _+_ #-}
_*_ : Nat -> Nat -> Nat
Z * m = Z
S n * m = (n * m) + m
{-# BUILTIN NATTIMES _*_ #-}
... |
{-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Functions.Definition
open import Setoids.Setoids
open import Setoids.Subset
open import Graphs.Definition
open import Sets.FinSet.Definition
open import Sets.FinSet.Lemm... |
{-# OPTIONS --without-K --safe #-}
module Data.Fin.Indexed where
open import Data.Fin.Indexed.Base public
|
{-# OPTIONS --copatterns #-}
open import Common.Nat
open import Common.IO
open import Common.Unit
record Test : Set where
field
a b c : Nat
f : Test -> Nat
f r = a + b + c
where open Test r
open Test
r1 : Test
a r1 = 100
b r1 = 120
c r1 = 140
r2 : Test
c r2 = 400
a r2 = 200
b r2 = 300
g : Nat
g = f r1 + ... |
------------------------------------------------------------------------
-- Lists parameterised on things in Set₁
------------------------------------------------------------------------
-- I want universe polymorphism.
module Data.List1 where
open import Data.List as List using (List; []; _∷_)
open import Data.Nat
... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Extensive where
-- https://ncatlab.org/nlab/show/extensive+category
open import Level
open import Categories.Category.Core
open import Categories.Diagram.Pullback
open import Categories.Category.Cocartesian
open import Categories.Object.Coproduct
open im... |
{-# OPTIONS --without-K --exact-split --safe #-}
module Fragment.Equational.Structures where
import Fragment.Equational.Theory.Laws as L
open import Fragment.Equational.Theory
open import Fragment.Equational.Theory.Bundles
open import Fragment.Equational.Model
open import Fragment.Algebra.Algebra
open import Level ... |
{-# OPTIONS --without-K --safe #-}
module Util.HoTT.Equiv where
open import Util.HoTT.Equiv.Core public
open import Relation.Binary using (Setoid ; IsEquivalence)
open import Util.Data.Product using (map₂)
open import Util.HoTT.HLevel.Core using (IsContr ; IsProp)
open import Util.HoTT.Section
open import Util.HoTT.... |
------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Postulate extensionality of functions.
--
-- Justification on Agda mailing list:
-- http://permalink.gmane.org/gmane.comp.lang.agda/2343
------------------------------------------------------------------------
modu... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
open import Cubical.Algebra.Group
module Cubical.Algebra.Group.Construct.Opposite {ℓ} (G : Group ℓ) where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Prod using (_,_)
open Group G
import Cubical.Algebra.Mono... |
module Issue2224 where
-- This is a placeholder to ensure that the test case is run.
-- The file of interest is `Issue2224.sh`, and the associated file
-- Issue2224WrongExtension.agda.tex
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.RingSolver.IntAsRawRing where
open import Cubical.Data.Nat hiding (_+_; _·_)
open import Cubical.Data.Int
open import Cubical.Data.Int.Base renaming (Int to ℤ) public
open import Cubical.Foundations.Prelude
open import Cubical.Algebra.RingSolve... |
open import Type
-- The relation (_⟶_) should be interpreted as "a term reduces/rewritten to another term".
-- Also called: Abstract reduction system, abstract rewriting system, rewriting system.
module ReductionSystem {ℓ₁ ℓ₂} {Term : Type{ℓ₁}} (_⟶_ : Term → Term → Type{ℓ₂}) where
open import Functional
open import G... |
-- Andreas, 2016-07-01 issue #2078
-- Holes in postponed type-checking problems cannot be worked on.
-- {-# OPTIONS -v interaction:30 #-}
-- {-# OPTIONS -v tc.term.exlam:30 -v tc:5 #-}
test : Set → Set
test A = (λ{ B → {!B!}}) A
-- splitting on B gives
-- No type nor action available for hole ?0
|
module Issue475 where
data Box (A : Set) : Set where
box : A → Box A
postulate
T : {A : Set} → A → Set
unbox : {A : Set} → Box A → A
data BoxT {A : Set}(b : Box A) : Set where
boxT : T (unbox b) → BoxT b
-- Can't be projection-like since we've already used it in BoxT
unbox (box x) = x
postulate
A : Set
... |
{- 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 Haskell.Modules.RWS
open import LibraBFT.ImplShared.Consensus.Typ... |
{-# OPTIONS --without-K --safe #-}
-- The category of Cats is Monoidal
module Categories.Category.Monoidal.Instance.StrictCats where
open import Level
open import Data.Product using (Σ; _×_; _,_; proj₁; proj₂; uncurry)
open import Relation.Binary.PropositionalEquality as ≡
using (_≡_; refl; cong₂; sym; module ≡-Re... |
module Inductive.Examples.List where
open import Inductive
open import Tuple hiding (_++_)
open import Data.Fin
open import Data.Product hiding (map)
open import Data.List hiding (List; map; foldr; _++_)
open import Data.Vec hiding (map; foldr; _++_)
List : Set → Set
List A = Inductive (([] , []) ∷ (((A ∷ []) , ([] ... |
{-# OPTIONS --without-K #-}
module function.isomorphism.remove where
open import sum
open import equality
open import function.isomorphism.core
open import function.isomorphism.utils
open import function.isomorphism.properties
open import function.overloading
open import sets.empty
_minus_ : ∀ {i}(A : Set i) → A → S... |
{-# OPTIONS --without-K #-}
module container.w where
open import container.w.core public
open import container.w.algebra public
open import container.w.fibration public
|
module Issue604 where
f : (y : Set1) → (x : Set) → Set1
f x = ?
|
open import Nat
open import Prelude
open import contexts
open import dynamics-core
open import lemmas-matching
open import synth-unicity
module elaboration-unicity where
mutual
elaboration-unicity-synth : {Γ : tctx} {e : hexp} {τ1 τ2 : htyp} {d1 d2 : ihexp} {Δ1 Δ2 : hctx} →
Γ ⊢ e ⇒ τ1... |
-- Should fail with S i != i
module Issue216 where
open import Common.Level
Foo : {i : Level} → Set i
Foo {i} = (R : Set i) → R
|
module relations where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong)
open import Data.Nat using (ℕ; zero; suc; _+_)
open import Data.Nat.Properties using (+-comm; +-identityʳ)
data _≤_ : ℕ → ℕ → Set where
z≤n : ∀ {n : ℕ} → zero ≤ n
s≤s : ∀ {m n : ℕ} → m ≤ n → suc m ≤ suc n
in... |
module Crash where
data N : Set where
zero : N
suc : N -> N
data B : Set where
true : B
false : B
F : B -> Set
F true = N
F false = B
not : B -> B
not true = false
not false = true
h : ((x : F _) -> F (not x)) -> N
h g = g zero
|
{-# OPTIONS --without-K #-}
open import HoTT
open import lib.cubical.elims.SuspSmash
module homotopy.SuspProduct where
module SuspProduct {i} {j} (X : Ptd i) (Y : Ptd j) where
private
{- into -}
into-glue : fst (X ⊙× Y) → winl (north _) == winr (winr (north _))
into-glue (x , y) =
ap winl (σlo... |
-- Adapted from an example reported by John Leon
-- It seems that the change reported in the issue was caused by the
-- commit 344296cf06cedd13736e50bb53e63217d9f19ecf.
-- Using `C-c C-,` in the first goal, master and 2.4.2.5 have different
-- behaviours. In master, the type of `a` is not normalised
-- Goal: n ≡ n +... |
{-
Interactive Programming with Dependent Types
Ulf Norell
ICFP 2013, Boston
-}
module ICFP where
open import ICFPPrelude
data Type : Set where
nat : Type
_⇒_ : (a b : Type) → Type
infixr 7 _⇒_
data Raw : Set where
var : (n : Nat) → Raw
app : (e₁ e₂ : Raw) →... |
------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Simply-typed changes with the Nehemiah plugin.
------------------------------------------------------------------------
module Nehemiah.Change.Type where
open import Nehemiah.Syntax.Type
import Parametric.Change.... |
module Class.Functor where
open import Category.Functor using () renaming (RawFunctor to Functor) public
open Functor {{...}} public
|
-- Andreas, 2019-06-18, LAIM 2019, issue #3855:
-- Successful tests for the erasure (@0) modality.
module _ where
open import Agda.Builtin.Bool
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
open import Agda.Builtin.Coinduction
open import Common.IO
module WhereInErasedDeclaration where
@0 n : Na... |
module PiQ.Interp where
open import Data.Empty
open import Data.Unit hiding (_≟_)
open import Data.Sum
open import Data.Product
open import Data.Maybe
open import Data.Nat hiding (_≟_)
open import Data.List as L hiding (_∷_)
open import Relation.Binary.Core
open import Relation.Binary
open import Relation.Nullary
open ... |
import cedille-options
module interactive-cmds (options : cedille-options.options) where
open import functions
open import cedille-types
open import conversion
open import constants
open import ctxt
open import general-util
open import spans options {Id}
open import subst
open import syntax-util
open import type-util... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.List.Relation.Binary.Permutation.Propositional directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
... |
open import Agda.Primitive
open import Agda.Builtin.Equality renaming (_≡_ to _==_) --(( If I want to rename the built-in equality ))
module AlgebraFormalization where
-- Here is an attempt to translate (part of) the Coq formalization. I did not translate the definition of the free algebra, the proof, and the part... |
module 100-natural where
open import 010-false-true
open import 020-equivalence
record Natural
{N : Set}
(zero : N)
(suc : N -> N)
(_==_ : N -> N -> Set)
: Set1 where
-- axioms
field
equiv : Equivalence _==_
sucn!=zero : ∀ {r} -> suc r == zero -> False
sucinjective : ∀ {r s} -> suc r == suc... |
module Formalization.LambdaCalculus.Semantics.Reduction where
import Lvl
open import Data
open import Formalization.LambdaCalculus
open import Formalization.LambdaCalculus.SyntaxTransformation
open import Numeral.Natural
open import Numeral.Finite
open import Relator.ReflexiveTransitiveClosure
open import Syntax.... |
{-# OPTIONS --cubical --no-import-sorts --no-exact-split --safe #-}
module Cubical.Data.Queue.Base where
open import Cubical.Data.Queue.1List public
open import Cubical.Data.Queue.Truncated2List public
open import Cubical.Data.Queue.Untruncated2List public
|
module dynamic where
open import LSsyntax
open import static
open import Relation.Nullary
open import Data.Nat using (ℕ ; _+_)
open import Data.Fin using (Fin; toℕ)
open import Data.Vec using (Vec ; lookup; _∷_; [])
open import Data.Product
open import Relation.Binary.PropositionalEquality
open import Relation.Nullar... |
module Numeral.Natural.Sequence where
import Lvl
open import Data
open import Data.Either as Either using (_‖_)
open import Data.Tuple as Tuple using (_⨯_ ; _,_)
import Data.Tuple.Raise as Tuple
open import Functional
open import Numeral.Natural
open import Numeral.Natural.Oper
open import Numeral.Natural.Op... |
module Utils.Exception where
{-# IMPORT Utils.Exception #-}
open import Utils.HaskellTypes
data Either (A : Set) (B : Set) : Set where
Left : A → Either A B
Right : B → Either A B
{-# COMPILED_DATA Either Either Left Right #-}
right : ∀{X A : Set} → A → Either X A
right x = Right x
error : ∀{X A : Set} → X → ... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Categories.Category.Base where
open import Cubical.Core.Glue
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Equiv
private
variable
ℓ ℓ' : Level
-- Precategories
record Precatego... |
-- Partly based on code due to Andrea Vezzosi.
open import Common.Prelude
data D : Set where
run-time : Bool → D
@0 compile-time : Bool → D
f : D → @0 D → Bool
f (run-time x) _ = x
f (compile-time x) (run-time y) = x
f (compile-time x) (compile-time y) = y
main : IO Unit
main =
p... |
module Structure.Type.Identity where
import Lvl
open import Lang.Instance
open import Logic.Propositional
open import Logic
open import Structure.Relator.Properties
open import Structure.Setoid
open import Type
open import Type.Properties.MereProposition
open import Type.Size
module _ {ℓ ℓₑ ℓₚ} {T : Type{ℓ}} (_≡... |
module PLRTree.Complete.Correctness.Base {A : Set} where
open import BTree.Complete.Base {A}
open import BTree.Complete.Alternative.Correctness {A} renaming (lemma-complete'-complete to lemma-complete''-complete)
open import Function using (_∘_)
open import PLRTree {A}
open import PLRTree.Complete {A} renaming (Compl... |
module Example where
open import Logic.Identity
open import Base
open import Category
open import Product
open import Terminal
open import Unique
import Iso
infixr 30 _─→_
infixr 90 _∘_
data Name : Set where
Zero : Name
One : Name
Half : Name
data Obj : Set1 where
obj : Name -> Obj
mutual
_─→'_ : Name ... |
{-# OPTIONS --experimental-irrelevance #-}
module ShapeIrrelevantParameterNoBecauseOfRecursion where
data ⊥ : Set where
record ⊤ : Set where
data Bool : Set where
true false : Bool
True : Bool → Set
True false = ⊥
True true = ⊤
data D ..(b : Bool) : Set where
c : True b → D b -- should fail
fromD : {b : Bool... |
{-# OPTIONS --allow-unsolved-metas #-}
module Thesis.ANormalUntyped where
open import Agda.Primitive
open import Data.Empty
open import Data.Unit using (⊤)
open import Data.Product
open import Data.Nat
import Data.Integer.Base as I
open I using (ℤ)
open import Data.Integer.Base using (ℤ)
open import Relation.Binary.Pr... |
-----------------------------------------------------------------------------
-- Existential elimination
-----------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPT... |
{-# OPTIONS --show-implicit #-}
module _ where
postulate
R : Set
module ModuleB where
module NotRecordB (r : R) where
postulate notfieldB : Set
open module NotRecBI {{r : R}} = NotRecordB r public
record RecordB : Set₁ where
field
fieldB : Set
open module RecBI {{r : RecordB}} = RecordB r... |
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Reduction {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.LogicalRelation.Properties
open import Definition.LogicalRelation.Substitution
open import Definition.Untyp... |
{-# OPTIONS --no-termination-check #-}
module PragmasApplyOnlyToCurrentModule where
import Imports.NonTerminating
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.2GroupoidTruncation where
open import Cubical.HITs.2GroupoidTruncation.Base public
open import Cubical.HITs.2GroupoidTruncation.Properties public
|
{-# OPTIONS --cubical --no-import-sorts --no-exact-split --safe #-}
module Cubical.Structures.Queue where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Functions.FunExtEquiv
open import Cubical.Foundations.Equiv
open import ... |
{-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.Castlemmas {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Ty... |
------------------------------------------------------------------------
-- Universe levels
------------------------------------------------------------------------
module Imports.Level where
open import Agda.Primitive using (Level; _⊔_) renaming (lzero to zero; lsuc to suc)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.