text stringlengths 4 690k |
|---|
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.Application {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import ... |
open import Agda.Builtin.Char
open import Agda.Builtin.Sigma
CC = Σ Char λ _ → Char
Test : (c : Char) → Set
Test 'a' = CC
Test _ = CC
test : (c : Char) → Test c
test 'a' .fst = 'a'
|
-- Andreas, 2011-04-07
module IrrelevantFin where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
data Fin : Nat -> Set where
zero : .(n : Nat) -> Fin (suc n)
suc : .(n : Nat) -> Fin n -> Fin (suc n)
-- this should not type check, since irrelevant n cannot appear in Fin n
-- or Fin (suc c)
-- note: this i... |
{-# OPTIONS --without-K #-}
module Proofs where
-- Various general lemmas
open import Level using (Level)
open import Relation.Binary.PropositionalEquality using (_≡_; refl; subst; cong)
open import Data.Sum using (inj₁; inj₂)
open import Data.Empty
open import Data.Nat.Properties.Simple using ()
----------------... |
{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-}
module Agda.Builtin.Reflection where
open import Agda.Builtin.Unit
open import Agda.Builtin.Bool
open import Agda.Builtin.Nat
open import Agda.Builtin.Word
open import Agda.Builtin.List
open import Agda.Builtin.String
open import Agda.Builtin.Char
o... |
module Where where
{-
id : Set -> Set
id a = a
-}
-- x : (_ : _) -> _
x = id Set3000
where id = \x -> x
y = False
where data False : Set where
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.CircleHSpace
open import homotopy.JoinAssocCubical
open import homotopy.JoinSusp
module homotopy.Hopf where
import homotopy.HopfConstruction
module Hopf = homotopy.HopfConstruction S¹-conn ⊙S¹-hSpace
Hopf : S² → Type₀
Hopf = Hopf.H.f
Hop... |
module Relations where
open import Agda.Builtin.Equality
open import Natural
data _≤_ : ℕ → ℕ → Set where
z≤n : ∀ {n : ℕ} →
zero ≤ n
s≤s : ∀ {m n : ℕ} →
m ≤ n →
(suc m) ≤ (suc n)
infix 4 _≤_
-- example : finished by auto mode
_ : 3 ≤ 5
_ = s≤s {2} {4} (s≤s {1} {3} (s≤s {0} {2} (z≤n {... |
-- cj-xu and fredriknordvallforsberg, 2018-04-30
open import Common.IO
data Bool : Set where
true false : Bool
data MyUnit : Set where
tt : MyUnit -- no eta!
HiddenFunType : MyUnit -> Set
HiddenFunType tt = Bool -> Bool
notTooManyArgs : (x : MyUnit) -> HiddenFunType x
notTooManyArgs tt b = b
{- This should no... |
module Data.Num.Nat where
open import Data.Num.Core renaming
( carry to carry'
; carry-lower-bound to carry-lower-bound'
; carry-upper-bound to carry-upper-bound'
)
open import Data.Num.Maximum
open import Data.Num.Bounded
open import Data.Num.Next
open import Data.Num.Increment
open import Data.... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.List.Relation.Binary.BagAndSetEquality directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module ... |
open import Categories
open import Monads
module Monads.EM.Functors {a b}{C : Cat {a}{b}}(M : Monad C) where
open import Library
open import Functors
open import Monads.EM M
open Cat C
open Fun
open Monad M
open Alg
open AlgMorph
EML : Fun C EM
EML = record {
OMap = λ X → record {
acar = T X;
astr = λ... |
{-# OPTIONS --no-positivity-check #-}
open import Prelude
module Implicits.Resolution.Undecidable.Resolution where
open import Data.Fin.Substitution
open import Implicits.Syntax
open import Implicits.Syntax.MetaType
open import Implicits.Substitutions
open import Extensions.ListFirst
infixl 4 _⊢ᵣ_ _⊢_↓_ _⟨_⟩=_
mutu... |
{-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Library.Data.Natural where
open import Light.Level using (Level ; Setω)
open import Light.Library.Arithmetic using (Arithmetic)
open import Light.Package using (Package)
open import Light.Library.Relation.Binary
using (... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- An either-or-both data type
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.These where
open import Level
open import Data.Maybe.Base usi... |
module Formalization.ClassicalPropositionalLogic.NaturalDeduction where
open import Data.Either as Either using (Left ; Right)
open import Formalization.ClassicalPropositionalLogic.Syntax
open import Functional
import Lvl
import Logic.Propositional as Meta
open import Logic
open import Relator.Equals
open im... |
{-# OPTIONS --without-K #-}
open import Base
module Homotopy.Skeleton where
private
module Graveyard {i} {A B : Set i} {f : A → B} where
private
data #skeleton₁ : Set i where
#point : A → #skeleton₁
skeleton₁ : Set i
skeleton₁ = #skeleton₁
point : A → skeleton₁
point = #point
... |
{-# OPTIONS --cubical-compatible --rewriting --local-confluence-check #-}
open import Agda.Primitive using (Level; _⊔_; Setω; lzero; lsuc)
infix 4 _≡_
data _≡_ {ℓ : Level} {A : Set ℓ} (a : A) : A → Set ℓ where
refl : a ≡ a
{-# BUILTIN REWRITE _≡_ #-}
run : ∀ {ℓ} {A B : Set ℓ} → A ≡ B → A → B
run refl x = x
ap :... |
module conversion where
open import lib
open import cedille-types
open import ctxt
open import is-free
open import lift
open import rename
open import subst
open import syntax-util
open import general-util
open import to-string
{- Some notes:
-- hnf{TERM} implements erasure as well as normalization.
-- hnf{T... |
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Paths
open import lib.types.Sigma
open import lib.types.Span
open import lib.types.Pointed
open import lib.types.Pushout
module lib.types.Join where
module _ {i j} (A : Type i) (B : Type j) where
*-span : Span
*-span = span A B (A × B) fs... |
module plfa.part1.Induction where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong; sym)
open Eq.≡-Reasoning
open import Data.Nat using (ℕ; zero; suc; _+_; _*_; _∸_)
+-assoc : ∀ (m n p : ℕ) → (m + n) + p ≡ m + (n + p)
+-assoc zero n p =
begin
(zero + n) + p
≡⟨⟩
n + p
≡⟨... |
module ProjectingRecordMeta where
data _==_ {A : Set}(a : A) : A -> Set where
refl : a == a
-- Andreas, Feb/Apr 2011
record Prod (A B : Set) : Set where
constructor _,_
field
fst : A
snd : B
open Prod public
testProj : {A B : Set}(y z : Prod A B) ->
let X : Prod A B
X = _ -- Solution: ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- "Finite" sets indexed on coinductive "natural" numbers
------------------------------------------------------------------------
module Data.Cofin where
open import Coinduction
open import Data.Conat as Conat us... |
module Pi1r where
open import Data.Empty
open import Data.Unit
open import Data.Sum
open import Data.Product
open import Relation.Binary.PropositionalEquality
open ≡-Reasoning
open import Groupoid
-- infix 2 _∎ -- equational reasoning for paths
-- infixr 2 _≡⟨_⟩_ -- equational reasoning for paths
infixr 1... |
{-# OPTIONS --without-K --safe #-}
-- A Categorical WeakInverse induces an Adjoint Equivalence
module Categories.Category.Equivalence.Properties where
open import Level
open import Data.Product using (Σ-syntax; _,_; proj₁)
open import Categories.Adjoint.Equivalence using (⊣Equivalence)
open import Categories.Adjoi... |
-- Andreas, 2019-08-08, issue #3972 (and #3967)
-- In the presence of an unreachable clause, the serializer crashed on a unsolve meta.
-- It seems this issue was fixed along #3966: only the ranges of unreachable clauses
-- are now serialized.
open import Agda.Builtin.Equality public
postulate
List : Set → Set
da... |
{-# OPTIONS --type-in-type #-}
module functors where
open import prelude
record Category {O : Set} (𝒞[_,_] : O → O → Set) : Set where
constructor 𝒾:_▸:_𝒾▸:_▸𝒾:
infixl 8 _▸_
field
𝒾 : ∀ {x} → 𝒞[ x , x ]
_▸_ : ∀ {x y z} → 𝒞[ x , y ] → 𝒞[ y , z ] → 𝒞[ x , z ]
𝒾▸ : ∀ {x y} (f : 𝒞[ x , y ]) → (... |
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Properties.Neutral {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Properties
open import Definition.Typed.Weake... |
{-# OPTIONS --without-K #-}
-- Define all the permutations that occur in Pi
-- These are defined by transport, using univalence
module Permutation where
open import Relation.Binary.PropositionalEquality
using (_≡_; refl)
open import Data.Nat using (_+_;_*_)
open import Data.Fin using ... |
module PreludeShow where
import RTP -- magic module
import AlonzoPrelude as Prelude
open import PreludeNat
open import PreludeString
import PreludeList
open import PreludeBool
open Prelude
-- open Data.Integer, using (Int, pos, neg)
open PreludeList hiding (_++_)
showInt : Int -> String
showInt = RTP.primShowInt
... |
-- | Trailing inductive copattern matches on the LHS can be savely
-- translated to record expressions on RHS, without jeopardizing
-- termination.
--
{-# LANGUAGE CPP #-}
module Agda.TypeChecking.CompiledClause.ToRHS where
-- import Control.Applicative
import Data.Monoid
import qualified Data.Map as Map
import Da... |
module _ where
open import Agda.Builtin.Bool
module M (b : Bool) where
module Inner where
some-boolean : Bool
some-boolean = b
postulate
@0 a-postulate : Bool
@0 A : @0 Bool → Set
A b = Bool
module A where
module M′ = M b
bad : @0 Bool → Bool
bad = A.M′.Inner.some-boolean
|
-- MIT License
-- Copyright (c) 2021 Luca Ciccone and Luca Padovani
-- Permission is hereby granted, free of charge, to any person
-- obtaining a copy of this software and associated documentation
-- files (the "Software"), to deal in the Software without
-- restriction, including without limitation the rights to use... |
-- Andreas, 2016-10-11, AIM XXIV
-- We cannot bind NATURAL to an abstract version of Nat.
abstract
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
{-# BUILTIN NATURAL ℕ #-}
|
-- Jesper, 2018-10-29 (comment on #3332): Besides for rewrite, builtin
-- equality is also used for primErase and primForceLemma. But I don't
-- see how it would hurt to have these use a Prop instead of a Set for
-- equality.
{-# OPTIONS --prop #-}
data _≡_ {A : Set} (a : A) : A → Prop where
refl : a ≡ a
{-# BUILTI... |
open import Agda.Builtin.Nat
open import Agda.Builtin.Reflection
open import Agda.Builtin.Unit
macro
five : Term → TC ⊤
five hole = unify hole (lit (nat 5))
-- Here you get hole = _X (λ {n} → y {_n})
-- and fail to solve _n.
yellow : ({n : Nat} → Set) → Nat
yellow y = five
-- Here you get hole = _X ⦃ n ⦄ (λ ⦃ n... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Category.Monoidal.Core using (Monoidal)
open import Categories.Category.Monoidal.Symmetric
open import Data.Sum
module Categories.Category.Monoidal.CompactClosed {o ℓ e} {C : Category o ℓ e} (M : Monoidal C) where
open import L... |
{-# OPTIONS --rewriting #-}
data Unit : Set where
unit : Unit
_+_ : Unit → Unit → Unit
unit + x = x
data _≡_ (x : Unit) : Unit → Set where
refl : x ≡ x
{-# BUILTIN REWRITE _≡_ #-}
postulate
f : Unit → Unit
fu : f unit ≡ unit
{-# REWRITE fu #-}
g : Unit → Unit
g unit = unit
data D (h : Unit → Unit) (x :... |
module Yoneda where
open import Level
open import Data.Product
open import Relation.Binary
import Relation.Binary.SetoidReasoning as SetR
open Setoid renaming (_≈_ to eqSetoid)
open import Basic
open import Category
import Functor
import Nat
open Category.Category
open Functor.Functor
open Nat.Nat
open Nat.Export
y... |
------------------------------------------------------------------------
-- "Equational" reasoning combinator setup
------------------------------------------------------------------------
{-# OPTIONS --sized-types #-}
open import Prelude
open import Labelled-transition-system
module Similarity.Weak.Equational-reas... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Numbers.Naturals.Semiring
open import Functions
open import LogicalFormulae
open import Groups.Definition
open import Rings.Definition
open import Rings.IntegralDomains.Definition
open import Setoids.Setoids
open import Sets.EquivalenceRelations
open impor... |
------------------------------------------------------------------------
-- Vectors parameterised on types in Set₁
------------------------------------------------------------------------
-- I want universe polymorphism.
module Data.Vec1 where
infixr 5 _∷_
open import Data.Nat
open import Data.Vec using (Vec; []; _... |
open import Common.Prelude
open import Common.Reflection
open import Common.Equality
postulate
trustme : ∀ {a} {A : Set a} {x y : A} → x ≡ y
magic : List (Arg Type) → Term → Tactic
magic _ _ = give (def (quote trustme) [])
id : ∀ {a} {A : Set a} → A → A
id x = x
science : List (Arg Type) → Term → Tactic
science ... |
module Issue274 where
-- data ⊥ : Set where
record U : Set where
constructor roll
field ap : U → U
-- lemma : U → ⊥
-- lemma (roll u) = lemma (u (roll u))
-- bottom : ⊥
-- bottom = lemma (roll λ x → x)
|
{-# OPTIONS --without-K #-}
open import HoTT
module cohomology.Choice where
unchoose : ∀ {i j} {n : ℕ₋₂} {A : Type i} {B : A → Type j}
→ Trunc n (Π A B) → Π A (Trunc n ∘ B)
unchoose = Trunc-rec (Π-level (λ _ → Trunc-level)) (λ f → [_] ∘ f)
has-choice : ∀ {i j} (n : ℕ₋₂) (A : Type i) (B : A → Type j) → Type (lmax ... |
{-# OPTIONS --without-K #-}
module Data.Tuple where
open import Data.Tuple.Base public
import Data.Product as P
Pair→× : ∀ {a b A B} → Pair {a} {b} A B → A P.× B
Pair→× (fst , snd) = fst P., snd
×→Pair : ∀ {a b A B} → P._×_ {a} {b} A B → Pair A B
×→Pair (fst P., snd) = fst , snd
|
module Type.NbE where
open import Context
open import Type.Core
open import Function
open import Data.Empty
open import Data.Sum.Base
infix 3 _⊢ᵗⁿᵉ_ _⊢ᵗⁿᶠ_ _⊨ᵗ_
infixl 9 _[_]ᵗ
mutual
Starⁿᵉ : Conᵏ -> Set
Starⁿᵉ Θ = Θ ⊢ᵗⁿᵉ ⋆
Starⁿᶠ : Conᵏ -> Set
Starⁿᶠ Θ = Θ ⊢ᵗⁿᶠ ⋆
data _⊢ᵗⁿᵉ_ Θ : Kind -> Set where
... |
postulate
_→_ : Set
|
{-# OPTIONS --safe --no-termination-check #-}
module Issue2442-conflicting where
|
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NType2
open import lib.Function2
open import lib.types.Group
open import lib.types.Sigma
open import lib.types.Truncation
open import lib.groups.Homomorphism
open import lib.groups.Isomorphism
open import lib.groups.SubgroupProp
module lib... |
module Lemmachine.Resource.Configure where
open import Lemmachine.Request
open import Lemmachine.Response
open import Lemmachine.Resource
open import Lemmachine.Resource.Universe
open import Data.Bool
open import Data.Maybe
open import Data.Product
open import Data.List
open import Data.Function using (const)
private
... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Finite sets, based on AVL trees
------------------------------------------------------------------------
open import Relation.Binary
open import Relation.Binary.PropositionalEquality using (_≡_)
module Data.AVL... |
module VecAppend where
open import Prelude
add : Nat -> Nat -> Nat
add zero y = y
add (suc x) y = suc (add x y)
append : forall {A m n} -> Vec A m -> Vec A n -> Vec A (add m n)
append xs ys = {!!}
|
{-# OPTIONS --without-K --overlapping-instances #-}
open import lib.Basics
open import lib.types.Coproduct
open import lib.types.Truncation
open import lib.types.Sigma
open import lib.types.Empty
open import lib.types.Bool
open import lib.NConnected
open import lib.NType2
module Util.Misc where
transp-↓' : ∀ {k j} {... |
------------------------------------------------------------------------
-- An alternative but equivalent definition of the partiality monad
-- (but only for sets), based on the lifting construction in Lifting
------------------------------------------------------------------------
-- The code in this module is based ... |
module container.w where
open import container.w.core public
open import container.w.algebra public
open import container.w.fibration public
|
module Preduploid where
open import Relation.Unary using (Pred)
open import Relation.Binary using (REL)
open import Relation.Binary.PropositionalEquality using (_≡_; refl; sym)
open import Level
data Polarity : Set where
+ : Polarity
⊝ : Polarity
private
variable p q r s : Polarity
record Preduploid o ℓ : Se... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.Field.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
open import Cubical.Foundations.SIP
open import Cub... |
module Data.Vec.Any {a} {A : Set a} where
open import Level using (_⊔_)
open import Relation.Nullary
open import Data.Fin
open import Data.Nat as ℕ hiding (_⊔_)
open import Data.Vec as Vec using (Vec; _∷_; [])
open import Relation.Unary renaming (_⊆_ to _⋐_) using (Decidable)
open import Function.Inverse ... |
------------------------------------------------------------------------
-- Well-typed substitutions
------------------------------------------------------------------------
module Data.Fin.Substitution.Typed where
open import Data.Fin using (Fin; zero; suc)
open import Data.Fin.Substitution
open import Data.Fin.Subs... |
{-# OPTIONS --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.Idlemmas {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped
open import Definition.Untyped.Properties
open import Definition.Typed
open import Definition.Type... |
module Numeral.Natural where
import Lvl
open import Type
-- The set of natural numbers (0,..).
-- Positive integers including zero.
data ℕ : Type{Lvl.𝟎} where
𝟎 : ℕ -- Zero
𝐒 : ℕ → ℕ -- Successor function (Intuitively: 𝐒(n) = n+1)
{-# BUILTIN NATURAL ℕ #-}
pattern 𝟏 = ℕ.𝐒(𝟎)
{-# DISPLAY ℕ.𝐒(𝟎)... |
------------------------------------------------------------------------
-- Abstract typing contexts
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module Data.Context where
open import Data.Fin using (Fin)
open import Data.Fin.Substitution
open import Dat... |
{-# OPTIONS --prop --without-K --rewriting #-}
module Data.Nat.PredExp2 where
open import Data.Nat
open import Data.Nat.Properties
open import Relation.Nullary
open import Relation.Nullary.Negation
open import Relation.Binary
open import Relation.Binary.PropositionalEquality as Eq using (_≡_; refl; _≢_; module ≡-Rea... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Some properties of reflexive closures which rely on the K rule
------------------------------------------------------------------------
{-# OPTIONS --safe --with-K #-}
module Relation.Binary.Construct.Closure.R... |
module Setoids where
open import Eq
open import Prelude
record Setoid : Set1 where
field
carrier : Set
_≈_ : carrier -> carrier -> Set
equiv : Equiv _≈_
record Datoid : Set1 where
field
setoid : Setoid
_≟_ : forall x y -> Dec (Setoid._≈_ setoid x y)
Setoid-≡ : Set -> Setoid
Setoid-≡... |
head : #$\forall$# {A n} → Vec A (1 + n) → A
zip : #$\forall$# {A B n} → Vec A n → Vec B n → Vec (A × B) n
take : #$\forall$# {A} m {n} → Vec A (m + n) → Vec A m
|
-- Andreas, 2013-02-18 problem with 'with'-display, see also issue 295
-- {-# OPTIONS -v tc.with:50 #-}
module Issue800 where
data ⊤ : Set where
tt : ⊤
data I⊤ : ⊤ → Set where
itt : ∀ r → I⊤ r
bug : ∀ l → ∀ k → I⊤ l → ⊤
bug .l k (itt l) with itt k
... | foo = {! foo!}
{-
Current rewriting:
bug .... |
{-# OPTIONS --type-in-type #-}
Ty : Set
Ty =
(Ty : Set)
(nat top bot : Ty)
(arr prod sum : Ty → Ty → Ty)
→ Ty
nat : Ty; nat = λ _ nat _ _ _ _ _ → nat
top : Ty; top = λ _ _ top _ _ _ _ → top
bot : Ty; bot = λ _ _ _ bot _ _ _ → bot
arr : Ty → Ty → Ty; arr
= λ A B Ty nat top bot arr prod sum →
... |
module Structure.Operator.IntegralDomain where
open import Functional
import Lvl
open import Logic
open import Logic.Propositional
open import Logic.Predicate
open import Structure.Setoid
open import Structure.Operator.Properties
open import Structure.Operator.Ring
open import Type
-- Rng with no non-zero zero d... |
-- Andreas, 2019-03-17, issue #3638
-- Making rewriting in interactive goals work in parametrized modules.
{-# OPTIONS --rewriting #-}
-- {-# OPTIONS -v rewriting:100 #-}
-- {-# OPTIONS -v tc.sig.param:60 #-}
-- {-# OPTIONS -v interactive.meta:10 #-}
open import Agda.Builtin.Equality
{-# BUILTIN REWRITE _≡_ #-}
mo... |
module Common.Sum where
open import Common.Level
data _⊎_ {a b} (A : Set a) (B : Set b) : Set (a ⊔ b) where
inj₁ : (x : A) → A ⊎ B
inj₂ : (y : B) → A ⊎ B
|
module Sessions.Semantics.Runtime {E : Set} (delay : E) where
open import Prelude
open import Relation.Unary hiding (Empty; _∈_)
open import Relation.Unary.PredicateTransformer using (Pt)
open import Relation.Ternary.Separation.Construct.Market
open import Relation.Ternary.Separation.Construct.Product
open import Rel... |
module Issue22 where
postulate
D : Set
_≡_ : D → D → Set
d e : D
foo : ∀ x → x ≡ x
foo x = bar
where
postulate
d≡e : d ≡ e
postulate
bar : x ≡ x
{-# ATP prove bar d≡e #-}
-- $ apia Bug.agda
-- An internal error has occurred. Please report this as a bug.
-- Location of the error: src/Apia/Uti... |
module Terminal where
open import Agda.Builtin.Word
open import BasicIO
open import Data.Bool
open import Data.Char hiding (show)
open import Data.List hiding (_++_)
open import Data.String hiding (show)
open import Data.Unit
open import ByteCount
open import Int
open import Function
open import Pair
open import Show
... |
-- Deriving TreeEncoding. Note: only for non-dependent datatypes.
module Tactic.Deriving.TreeEncoding where
open import Prelude
open import Tactic.Reflection
open import Tactic.Deriving
open import Tactic.Reflection
open import Tactic.Reflection.Quote
open import Data.TreeRep
open import Container.Traversable
priva... |
{-# OPTIONS --without-K --safe #-}
module Math.Combinatorics.IntegerFunction.Properties.Lemma where
open import Data.Integer
open import Data.Integer.Solver
open import Relation.Binary.PropositionalEquality
lemma₁ : ∀ a b c d → a * b * (c * d) ≡ (a * c) * (b * d)
lemma₁ = solve 4 (λ a b c d → a :* b :* (c :* d) := (... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.CommRing where
open import Cubical.Algebra.CommRing.Base public
|
{-
A parameterized family of structures S can be combined into a single structure:
X ↦ (a : A) → S a X
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Structures.Relational.Parameterized where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Found... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Some code related to the W type that relies on the K rule
------------------------------------------------------------------------
{-# OPTIONS --with-K --safe #-}
module Data.W.WithK where
open import Data.Pro... |
{-# OPTIONS --cubical --safe #-}
module Cubical.Data.Strict2Group.Explicit where
|
{- 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 Util.PKCS
open import Util.Prelude
import Yasm.Base as YB
i... |
-- There was a bug where Confuse and confusing were considered
-- projection-like even though they have absurd clauses.
module _ (A : Set) where
data D : Set where
d : D
data P : D → Set where
Confuse : (d : D) (p : P d) → Set
Confuse x ()
confusing : (d : D) (p : P d) → Confuse d p
confusing x ()
test : (x : P ... |
open import Oscar.Prelude
open import Oscar.Class
open import Oscar.Class.Unit
module Oscar.Class.Leftunit where
module Leftunit
{𝔞 𝔟} {𝔄 : Ø 𝔞} {𝔅 : Ø 𝔟}
{𝔢} {𝔈 : Ø 𝔢}
{𝔞𝔟}
(_↤_ : 𝔅 → 𝔄 → Ø 𝔞𝔟) (let _↤_ = _↤_; infix 4 _↤_)
(ε : 𝔈)
(_◃_ : 𝔈 → 𝔄 → 𝔅) (let _◃_ = _◃_; infix 16 _◃_)
(x :... |
-- There was a problem with module instantiation if a definition
-- was in scope under more than one name. For instance, constructors
-- or non-private local modules being open publicly. In this case
-- the module instantiation incorrectly generated two separate names
-- for this definition.
module Issue263 where
modu... |
-- Basic intuitionistic propositional calculus, without ∨ or ⊥.
-- Kripke-style semantics with contexts as concrete worlds, and glueing for α and ▻.
-- Implicit syntax.
module BasicIPC.Semantics.KripkeConcreteGluedImplicit where
open import BasicIPC.Syntax.Common public
open import Common.Semantics public
open Concr... |
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Group
open import lib.types.Pi
open import lib.types.Sigma
open import lib.types.Truncation
open import lib.groups.GroupProduct
open import lib.groups.Homomorphisms
module lib.groups.TruncationGroup where
module _ {i} {El : Type i} (GS : GroupS... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use the
-- Relation.Binary.Reasoning.MultiSetoid module directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
mo... |
module Prelude.Bool where
data Bool : Set where
true : Bool
false : Bool
{-# BUILTIN BOOL Bool #-}
{-# BUILTIN TRUE true #-}
{-# BUILTIN FALSE false #-}
not : Bool -> Bool
not true = false
not false = true
notnot : Bool -> Bool
notnot true = not (not true)
notnot false = not (not false)
infix 90 if_then... |
------------------------------------------------------------------------
-- Many properties which hold for _∼_ also hold for _∼_ on₁ f
------------------------------------------------------------------------
open import Relation.Binary
module Relation.Binary.On {A B : Set} (f : B → A) where
open import Data.Function... |
{-# OPTIONS --cubical --omega-in-omega #-}
open import Agda.Primitive.Cubical
open import Agda.Builtin.Bool
-- With --omega-in-omega we are allowed to split on Setω datatypes.
-- Andrea 22/05/2020: in the future we might be allowed even without --omega-in-omega.
-- This test makes sure the interval I is still specia... |
{-# OPTIONS --without-K #-}
module sets.fin.properties where
open import sum
open import decidable
open import equality
open import function.core
open import function.extensionality
open import function.isomorphism
open import function.overloading
open import sets.core
open import sets.nat.core
hiding (_≟_; pred)
o... |
module StateSizedIO.IOObject where
open import Data.Product
open import Size
open import SizedIO.Base
open import StateSizedIO.Object
-- ---
-- ---
-- --- FILE IS DELETED !!!
-- ---
-- ---
-- An IO object is like a simple object,
-- but the method returns IO applied to the result type of a simple object
-- whi... |
module A.B where
{-# NON_TERMINATING #-}
easy : (A : Set) → A
easy = easy
|
data D : Set where
zero : D
suc : D → D
postulate
f : D → D
{-# COMPILE GHC f = \ x -> x #-}
|
{-# OPTIONS --cubical --safe #-}
module Algebra.Construct.Free.Semilattice.Eliminators where
open import Algebra.Construct.Free.Semilattice.Definition
open import Prelude
open import Algebra
record _⇘_ {a p} (A : Type a) (P : 𝒦 A → Type p) : Type (a ℓ⊔ p) where
no-eta-equality
constructor elim
field
⟦_⟧-s... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Instantiates the ring solver, using the natural numbers as the
-- coefficient "ring"
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Algeb... |
module BBHeap.Complete.Alternative {A : Set}(_≤_ : A → A → Set) where
open import BBHeap _≤_
open import Bound.Lower A
open import BTree.Equality {A} renaming (_≃_ to _≃'_)
open import BTree.Complete.Alternative {A} renaming (_⋘_ to _⋘'_ ; _⋙_ to _⋙'_ ; _⋗_ to _⋗'_)
lemma-forget≃ : {b b' : Bound}{l : BBHeap b}{r : ... |
------------------------------------------------------------------------------
-- Existential quantifier on the inductive PA universe
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-uni... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties related to setoid list membership
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Membership.Setoid.Properties where
open... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.