text stringlengths 4 690k |
|---|
-- Common imports and other auxiliary operations used in the library
module SOAS.Common where
open import Categories.Category.Instance.Sets public
open import Axiom.Extensionality.Propositional
using (Extensionality; ExtensionalityImplicit)
open import Relation.Binary.PropositionalEquality public
hiding (Extensio... |
{-
Joseph Eremondi
Utrecht University Capita Selecta
UU# 4229924
July 22, 2015
-}
module SemiLin where
open import Data.Vec
open import Data.Nat
import Data.Fin as Fin
open import Data.List
import Data.List.All
open import Data.Bool
open import Data.Char
open import Data.Maybe
open import Data.Product
open import ... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.elims.SuspSmash
open import homotopy.elims.CofPushoutSection
-- Σ(X∧Y) ≃ X * Y
module homotopy.SuspSmash {i j} (X : Ptd i) (Y : Ptd j) where
private
{- path lemmas -}
private
reduce-x : ∀ {i} {A : Type i} {x y z : A} (p : x == y)... |
{-# OPTIONS --without-K --safe #-}
module Algebra.Linear.Structures.Bundles.FiniteDimensional where
open import Algebra
open import Algebra.FunctionProperties
open import Relation.Binary using (Rel)
open import Level using (Level; suc; _⊔_)
open import Algebra.Structures.Bundles.Field
open import Algebra.Linear.Stru... |
module Data.Word64.Exts where
open import Agda.Builtin.Nat
open import Agda.Builtin.Word
open import Data.Nat
open import Data.Word
addWord : Word64 → Word64 → Word64
addWord a b = primWord64FromNat (primWord64ToNat a + primWord64ToNat b)
subWord : Word64 → Word64 → Word64
subWord a b = primWord64FromNat (primWord64... |
open import Level hiding ( suc ; zero )
open import Algebra
module sym5 where
open import Symmetric
open import Data.Unit using (⊤ ; tt )
open import Function.Inverse as Inverse using (_↔_; Inverse; _InverseOf_)
open import Function hiding (flip)
open import Data.Nat hiding (_⊔_) -- using (ℕ; suc; zero)
open import D... |
module Sandbox.PrimitiveRecursion where
open import Data.Nat
open import Data.Fin using (Fin)
open import Data.Vec
data PR : ℕ → Set where
-- Constant function: The 0-ary constant function 0 is primitive recursive.
K : PR 0
-- Successor function: The 1-ary successor function S, which returns the
-- s... |
open import Agda.Builtin.Nat
data List (A : Set) : Set where
lnil : List A
lcons : A → List A → List A
data Vec (A : Set) : Nat → Set where
vnil : Vec A 0
vcons : ∀ {n} → A → Vec A n → Vec A (suc n)
pattern [] = lnil
pattern [] = vnil
pattern _∷_ x xs = lcons x xs
pattern _∷_ y ys = vcons y ys
lmap : ∀ {... |
{-# OPTIONS --rewriting --prop #-}
open import Agda.Builtin.Equality
open import Agda.Builtin.Equality.Rewrite
postulate
P : Prop
p : P
f : P -> P
g : {A : Set} -> P -> A -> A
eq : ∀{A} {x : A} -> g p x ≡ x
{-# REWRITE eq #-}
module _ {A : Set} {x : A} {y : P} where
foo : g p x ≡ x
foo = refl
bar... |
-- 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... |
module Numeral.Natural.Relation.Divisibility.Proofs.Modulo where
import Lvl
open import Data
open import Functional
open import Logic.Predicate
open import Logic.Propositional
open import Numeral.Natural
open import Numeral.Natural.Oper
open import Numeral.Natural.Oper.DivMod.Proofs
open import Numeral.Natural.Oper.Fl... |
module Inductive where
open import Level using (_⊔_)
open import Data.Nat hiding (_⊔_)
open import Data.Fin
open import Data.List hiding (map)
import Data.List as List
open import Data.Vec hiding (_++_)
open import Data.Product hiding (map)
open import Tuple using (Tuple; []; _∷_; unfoldToFunc; apply; proof₁; proof₂)
... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Results concerning function extensionality for propositional equality
------------------------------------------------------------------------
{-# OPTIONS --with-K --safe #-}
module Axiom.Extensionality.Heterog... |
module Tactic.Nat.Less.Lemmas where
open import Prelude
open import Tactic.Nat.Exp
open import Tactic.Nat.NF
open import Tactic.Nat.Subtract.Exp
open import Tactic.Nat.Auto.Lemmas
open import Tactic.Nat.Simpl.Lemmas
open import Tactic.Nat.Subtract.Lemmas
liftNFSubLess : ∀ e₁ e₂ ρ → ⟦ normSub e₁ ⟧sn ρ < ⟦ normSub e₂... |
{- 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.Prelude
open import LibraBFT.Base.PKCS
-- This mod... |
open import FRP.JS.Level using ()
module FRP.JS.Primitive where
-- We define the primitive types here, to avoid cyclic module dependencies
data Bool : Set where
true : Bool
false : Bool
{-# BUILTIN BOOL Bool #-}
{-# BUILTIN TRUE true #-}
{-# BUILTIN FALSE false #-}
{-# COMPILED_JS Bool function(x,v) { if ... |
module Data.List.Relation.Pairwise.Proofs where
open import Data.List
import Data.List.Functions as List
open import Data.List.Relation.Pairwise
open import Logic
import Lvl
open import Type
private variable ℓ ℓₗ : Lvl.Level
private variable T A B : Type{ℓ}
private variable x : T
private variable f : A → B
... |
{-# OPTIONS --rewriting #-}
module JVM.Transform.Assemble where
open import Agda.Builtin.Equality.Rewrite
open import Data.Nat using (ℕ)
open import Data.List as List
open import Data.List.Properties
open import Data.List.Relation.Unary.All as All
open import Data.List.Membership.Propositional
open import Data.List.M... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Subsets of finite sets
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Fin.Subset where
open import Algebra
open import Algebra.FunctionP... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Operations on nullary relations (like negation and decidability)
------------------------------------------------------------------------
-- Some operations on/properties of nullary relations, i.e. sets.
module... |
module Issue2858-Fresh {A : Set} (_#_ : A → A → Set) where
interleaved mutual
data Fresh : Set
data IsFresh (a : A) : Fresh → Set
-- nil is a fresh list
constructor
[] : Fresh
#[] : IsFresh a []
-- cons is fresh as long as the new value is fresh
constructor
cons : (x : ... |
-- Andreas, 2017-11-01, issue #2824
-- Don't allow built-ins defined in parametrized modules
module _ (A : Set) where
data Nat : Set where
zero : Nat
suc : Nat → Nat
{-# BUILTIN NATURAL Nat #-} -- Should fail
test = 5
|
module Issue231 where
postulate
A : Set
data List : Set where
_∷_ : A → List → List
data Any : List → Set where
there : ∀ {x xs} → Any xs → Any (x ∷ xs)
postulate
id : (A : Set) → A → A
lemma : (xs : List) → Set → (p : Any xs) → Set
lemma (x ∷ xs) A (there p) with id (Any xs) p
lemma (x ∷ xs) A (there p) |... |
-- Andreas, 2016-11-02, issue #2289
-- Meta should be acceptable as sort of record type.
postulate
F : Set → Set
mutual
data ⊥ : _ where -- works
FBot = F ⊥
mutual
record ⊤ : _ where -- should work
FTop = F ⊤
|
{-# OPTIONS --without-K #-}
module Search.Searchable.Fun where
open import Type hiding (★)
open import Data.Product
open import Data.Sum
open import Data.One
open import Data.Bits
open import Function.NP
open import Search.Type
open import Search.Searchable
open import Search.Searchable.Product
open import Search.Sear... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.Vec.Relation.Binary.Equality.DecSetoid directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open im... |
module Human.JS where
open import Human.Unit
open import Human.String
open import Human.IO
infixl 1 _>>=_
postulate
return : ∀ {a} {A : Set a} → A → IO A
_>>=_ : ∀ {a b} {A : Set a} {B : Set b} → IO A → (A → IO B) → IO B
_>>_ : ∀ {a b} {A : Set a} {B : Set b} → IO A → IO B → IO B
print : String → IO Unit... |
----------------------------------------------------------------------------------
-- Types for parse trees
----------------------------------------------------------------------------------
module cedille-types where
open import lib
-- open import parse-tree
open import general-util
{-# FOREIGN GHC import qualified... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Pointwise lifting of relations over Vector
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Vec.Functional.Relation.Binary.Pointwise where
... |
module Zipper where
import Derivative
import Functor
import Sets
open Functor
open Derivative
open Semantics
open Recursive
open Sets
Zipper : U -> Set
Zipper F = List (⟦ ∂ F ⟧ (μ F))
-- Plugging a zipper
unzip : {F : U} -> Zipper F -> μ F -> μ F
unzip [] t = t
unzip {F} (c :: ... |
open import Data.Product using ( _×_ ; _,_ )
open import Relation.Unary using ( _∈_ )
open import Web.Semantic.DL.ABox.Interp using ( ⌊_⌋ ; ind )
open import Web.Semantic.DL.ABox.Skolemization using ( askolem ; askolem-sound )
open import Web.Semantic.DL.FOL using ( Formula ; _∧_ )
open import Web.Semantic.DL.FOL.Mod... |
module Issue643 where
module M₁ (A : Set) where
record R : Set₁ where
field
P : A → Set
module M₂ (A : Set) where
open M₁ A
postulate
r : R
T : R → Set
open R r
p : ∀ x → P x
p x = {!!} -- The goal was printed as "P" rather than "P x".
q : T r
q = {!!} -- This goal w... |
open import Agda.Builtin.Bool
open import Agda.Builtin.Nat
open import Agda.Builtin.Char renaming (primCharEquality to _==ᶜ_)
open import Agda.Builtin.List
open import Agda.Builtin.Equality
open import Agda.Builtin.String renaming (primStringAppend to _++_)
open import Agda.Builtin.IO
open import Agda.Builtin.Unit
va... |
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Sigma
open import Preliminaries
open import Truncation_Level_Criteria
open import Anonymous_Existence_CollSplit
open wtrunc
open with-weak-trunc
module Anonymous_Existence_Populatedness where
-- Definition 4.2.1
⟪_⟫ : ∀ {i} → Type i → Type... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- The Cowriter type and some operations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --sized-types #-}
-- Disabled to prevent warnings from BoundedVec
{-... |
------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Change evaluation (Def 3.6 and Fig. 4h).
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Denota... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- W-types
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.W where
open import Level
open import Function
open import Data.Product hiding (m... |
{-# OPTIONS --show-implicit #-}
-- {-# OPTIONS -v tc.meta:20 #-}
module UnifyWithIrrelevantArgument where
data _≡_ {A : Set}(a : A) : A -> Set where
refl : a ≡ a
data Bool : Set where true false : Bool
-- irrelevant arguments are ignored in unification
-- e.g. non linearity
test : let X : Bool -> .Bool -> Bool
... |
module ArrowIsCCC where
open import Categories.Category.CartesianClosed.Canonical
open import Categories.Category.Cartesian.Bundle
open import Categories.Category.Core
open import Categories.Category.Construction.Arrow
open import Data.Product
open import Function using (const)
open import Level
open import Relation.B... |
{-# OPTIONS --sized-types #-} -- --no-coverage-check #-}
module DeBruijnExSubstSized where
open import Data.Function -- using (_∘_) -- composition, identity
open import Data.Nat
open import Data.Maybe
open import Relation.Binary.PropositionalEquality
open ≡-Reasoning
open import Size
open import DeBruijn
-- ... |
------------------------------------------------------------------------------
-- The mirror function: A function with higher-order recursion
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS ... |
module Cats.Util.Conv where
open import Level
open import Cats.Category.Base
module _ {x} (X : Set x) where
record HasObj lo la l≈ : Set (x ⊔ suc (lo ⊔ la ⊔ l≈))
where
infix 90 _ᴼ
field
Cat : Category lo la l≈
open Category Cat
field
_ᴼ : X → Obj
open HasObj {{...}} public us... |
{- Byzantine Fault Tolerant Consensus Verification in Agda, version 0.9.
Copyright (c) 2021, Oracle and/or its affiliates.
Licensed under the Universal Permissive License v 1.0 as shown at https://opensource.oracle.com/licenses/upl
-}
open import LibraBFT.Base.Types
import LibraBFT.Impl.Crypto.Crypto.Hash ... |
module Dave.Logic.Theorems where
K : {A B : Set} → A → B → A
K a b = a
S : {A B C : Set} → (A → B → C) → (A → B) → A → C
S = λ f → λ g → λ a → f a (g a)
|
open import Agda.Primitive using (lzero; lsuc; _⊔_)
open import Relation.Binary.PropositionalEquality
open import Relation.Binary using (Setoid)
import SecondOrder.Arity
import SecondOrder.Signature
import SecondOrder.Metavariable
module SecondOrder.Term
{ℓ}
{𝔸 : SecondOrder.Arity.Arity}
(Σ : SecondOrder.Signa... |
module Ix where
_-:>_ : {I : Set} -> (I -> Set) -> (I -> Set) -> (I -> Set)
(S -:> T) i = S i -> T i
infixr 4 _-:>_
[_] : {I : Set} -> (I -> Set) -> Set
[ P ] = forall i -> P i
Algebra : {I : Set}(F : (I -> Set) -> (I -> Set)) -> (I -> Set) -> Set
Algebra F X = [ F X -:> X ]
|
module AnonymousImport where
open import Common.IO as _
open import Common.Unit as _
main : IO Unit
main = putStrLn ""
|
{-# OPTIONS --safe --without-K #-}
module Data.Fin.Relation.Binary.Closure where
open import Data.Fin
open import Data.Fin.Subset
open import Data.Fin.Subset.Dec
open import Data.Fin.Subset.Properties
open import Data.Fin.Subset.Properties.Dec
open import Data.Nat as ℕ using (ℕ)
open import Relation.Binary.Construct... |
{-# OPTIONS --cubical --safe #-}
module Data.Binary.Order where
open import Prelude
open import Data.Binary.Definition
open import Data.Bits.Order.Reverse public
-- weaken : ∀ xs ys → T (xs ≲ᴮ ys & false) → T (xs ≲ᴮ ys & true)
-- weaken 0ᵇ ys xs≲ys = tt
-- weaken (1ᵇ x) 0ᵇ xs≲ys = xs≲ys
-- weaken (1ᵇ x) (1ᵇ x₁) xs≲y... |
------------------------------------------------------------------------------
-- Agda-Prop Library.
-- Theorems of ¬ connective.
------------------------------------------------------------------------------
open import Data.Nat using ( ℕ )
module Data.PropFormula.Theorems.Negation ( n : ℕ ) where
-----------------... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
-- Lifting Properties
module Categories.Morphism.Lifts {o ℓ e} (𝒞 : Category o ℓ e) where
open import Level
open Category 𝒞
open Definitions 𝒞
-- A pair of morphisms has the lifting property if every commutative
-- square admits a diagonal fille... |
open import Data.Nat using (ℕ; _+_; _≤?_)
open import Data.Bool using (Bool; true; false; not; _∧_)
open import Data.String using (String; _≟_)
open import Relation.Nullary using (¬_; yes; no)
open import Relation.Nullary.Negation using (contradiction)
open import Relation.Binary.PropositionalEquality using (_≡_; ... |
module Oscar.Data.Term.AlphaConversion {𝔣} (FunctionName : Set 𝔣) where
open import Oscar.Data.Term FunctionName
open import Oscar.Class.AlphaConversion
open import Oscar.Data.Equality
open import Oscar.Data.Fin
open import Oscar.Data.Vec
open import Oscar.Function
open import Oscar.Relation
import Oscar.Data.Ter... |
postulate A : Set
variable a : A
postulate B : A → Set
variable b : B a
postulate C : B a → Set
variable c : C b
postulate
_==_ : {b b' : B a} → C b → C b' → Set
_=='_ : {b : B a} → C b → C b → Set
postulate
f : (b : B a) (b' : B {!a!}) → Set
g : (c : C b) (c' : C {!b!}) → c == c' → Set
module _ (X : ... |
{- Copyright © 2015 Benjamin Barenblat
Licensed under the Apache License, Version 2.0 (the ‘License’); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, so... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.Bouquet
open import homotopy.SphereEndomorphism
open import groups.SphereEndomorphism
open import groups.CoefficientExtensionality
open import cw.CW
open import cw.FinCW
open import cw.WedgeOfCells
open import cw.DegreeByProjection {lzero}
... |
{-# OPTIONS --without-K --exact-split --allow-unsolved-metas #-}
module 17-groups where
import 16-sets
open 16-sets public
-- Section 12.3 Groups in univalent mathematics
{- We first introduce semi-groups, and then groups. We do this because the
category of groups is a full subcategory of the category of semi-gr... |
-- Andreas Abel, 2022-06-06, issue #5944 reported by Mike Shulman
-- Support rewriting with 2ltt (match SSet).
{-# OPTIONS --type-in-type --rewriting --two-level #-}
open import Agda.Primitive public
postulate
Tel : SSet
ε : Tel
_≡_ : {A : SSet} (a : A) → A → SSet
cong : (A B : SSet) (f : A → B) {x ... |
module ASN1.Util where
open import Data.Word8 using (Word8) renaming (primWord8fromNat to to𝕎; primWord8toNat to from𝕎)
open import Data.Nat using (ℕ; _+_; _*_; _≤?_)
open import Data.Nat.DivMod using (_divMod_; result)
open import Data.Fin using (toℕ)
open import Data.List using (List; []; _∷_)
open import Relation... |
-- Andreas, 2014-11-08
-- This used to be a failed test case, but works now.
open import Common.Prelude
postulate
some : Nat
data D : Nat → Set where
d₀ : D some
d₁ : D (suc some)
f : (n : Nat) → D n → Nat
f .some d₀ = zero
f .(suc some) d₁ = f some d₀
-- Since x < suc x for all x in the structural o... |
{- 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 Optics.All
open import LibraBFT.Prelude
open import LibraBFT... |
------------------------------------------------------------------------------
-- The Booleans properties
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# O... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommSemiring.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.SIP using (TypeWithStr)
open import Cubical.Algebra.CommMonoid
open import Cubical.Algebra.Monoid
private
variable
ℓ ℓ' : Level
record IsCommSemiring {R : Type ℓ}
... |
{-# OPTIONS --without-K #-}
open import Base
open import Homotopy.Pushout
module Homotopy.VanKampen {i} (d : pushout-diag i) where
open pushout-diag d
open import Homotopy.Truncation
open import Homotopy.PathTruncation
open import Homotopy.VanKampen.Guide
module _ (l : legend i C) where
open legend l
open impo... |
{-
This second-order equational theory was created from the following second-order syntax description:
syntax Inception | IA
type
L : 0-ary
P : 0-ary
A : 0-ary
term
rec : L P -> A
inc : L.A P.A -> A
theory
(S) p : P a : P.A |> inc (l. rec (l, p[]), x. a[x]) = a[p[]]
(E) a : L.A |> k : L |- in... |
{-# OPTIONS --cubical --no-import-sorts #-}
module MoreLogic.Properties where -- hProp logic
open import Agda.Primitive renaming (_⊔_ to ℓ-max; lsuc to ℓ-suc; lzero to ℓ-zero)
private
variable
ℓ ℓ' ℓ'' : Level
open import Cubical.Foundations.Everything renaming (_⁻¹ to _⁻¹ᵖ; assoc to ∙-assoc)
open import Cubi... |
-----------------------------------------------------------------------------------
-- This file contains facts about equational reasoning pertaining to categories. --
-----------------------------------------------------------------------------------
module Category.CatEq where
open import Level
open import Category... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Groups.Definition
open import Setoids.Setoids
open import Sets.EquivalenceRelations
open import Rings.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
module Rings.Subrings.Definition {a b : _} {A : Set a}... |
module JuiceMaker where
open import Human.Nat hiding (_==_)
open import Human.List hiding (remove-last)
open import Human.Equality
open import Human.Maybe
open import Human.Empty
Not : (P : Set) -> Set
Not P = P -> Empty
-- Different from Bool, shows an evidence of why the value is "yes" or "nop"
data Dec (P : Set) ... |
{-# OPTIONS --without-K #-}
open import HoTT
module homotopy.SuspensionJoin {i} (A : Type i) where
{- To -}
false, : A → Bool × A
false, a = false , a
true, : A → Bool × A
true, a = true , a
module To = SuspensionRec {i} (left false :> Bool * A) (left true) (λ a → glue (false, a) ∙ ! (glue (true, a)))
to : Suspe... |
postulate
A : Set₁
barb : Set₁
barb = {!(x y : A) → ?!}
|
open import Functors
open import Categories
open import RMonads
module RMonads.REM.Functors {a b c d}{C : Cat {a}{b}}{D : Cat {c}{d}}
(J : Fun C D)(M : RMonad J) where
open import Library
open import RMonads.REM M
open Cat
open Fun
open RAlg
open RAlgMorph
open RMonad M
REML : Fun C EM
R... |
module Sessions.Syntax.Types where
open import Level
open import Function
open import Data.Bool
open import Data.List
open import Data.List.All
open import Data.List.Membership.Propositional
open import Data.List.Relation.Binary.Permutation.Inductive
open import Data.List.Relation.Ternary.Interleaving.Propositional a... |
----------------------------------------------------------------------------------
-- Types for parse trees
----------------------------------------------------------------------------------
module cedille-types where
open import lib
-- open import parse-tree
posinfo = string
alpha = string
alpha-bar-3 = string
alph... |
------------------------------------------------------------------------
-- A solver for certain natural number equalities
------------------------------------------------------------------------
-- The standard library's solver is used.
{-# OPTIONS --without-K --safe #-}
open import Equality
module Nat.Solver
{r... |
{-
This second-order equational theory was created from the following second-order syntax description:
syntax CommMonoid | CM
type
* : 0-ary
term
unit : * | ε
add : * * -> * | _⊕_ l20
theory
(εU⊕ᴸ) a |> add (unit, a) = a
(εU⊕ᴿ) a |> add (a, unit) = a
(⊕A) a b c |> add (add(a, b), c) = add (a, add(b,... |
module fizzbuzz where
import Data.Nat as N
import Data.Nat.DivMod as N
import Data.Nat.Show as N
import Data.Bool as B
import Data.Fin as F
import Data.Unit as U
import Data.String as S
open import Data.Product using (_,_ ; _×_)
open import IO
open import Agda.Builtin.Coinduction
open i... |
module Ag12 where
import Relation.Binary.PropositionalEquality as Eq
open Eq
open import Data.Nat using (ℕ; zero; suc; _+_; _*_)
open import Relation.Nullary using (¬_)
open import Data.Product using (_×_; proj₁; proj₂) renaming (_,_ to ⟨_,_⟩)
open import Data.Sum using (_⊎_; inj₁; inj₂)
open import Function
open impo... |
open import IO
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
seven = suc (suc (suc (suc (suc (suc (suc zero))))))
main = run (putStrLn "Hello, world!")
|
-- Andreas, 2016-09-19, issue #2168, reported by Nisse
-- {-# OPTIONS -v tc.cover:10 #-}
-- {-# OPTIONS -v tc.cover.splittree:30 -v tc.cc:40 -v tc.cover.split.con:30 #-}
open import Common.Equality
data Three : Set where
one two three : Three
data Bool : Set where
true false : Bool
P : Bool → Bool → Three
P z ... |
{-# OPTIONS --without-K --safe #-}
module Quasigroup.Bundles where
open import Algebra.Core
open import Quasigroup.Structures
open import Relation.Binary
open import Level
open import Algebra.Bundles
open import Algebra.Structures
record Pique c ℓ : Set (suc (c ⊔ ℓ)) where
infixl 7 _∙_
infixl 7 _\\_
infixl 7 ... |
module Issue413 where
data Bool : Set where
data ℕ : Set where
zero : ℕ
data Type : (A : Set) → Set where
isBool : Type Bool
isℕ : Type ℕ
g : (A : Set) → Type A → Type A → ℕ
g .Bool isBool isBool = zero
|
module Text.Greek.SBLGNT.2Tim where
open import Data.List
open import Text.Greek.Bible
open import Text.Greek.Script
open import Text.Greek.Script.Unicode
ΠΡΟΣ-ΤΙΜΟΘΕΟΝ-Β : List (Word)
ΠΡΟΣ-ΤΙΜΟΘΕΟΝ-Β =
word (Π ∷ α ∷ ῦ ∷ ∙λ ∷ ο ∷ ς ∷ []) "2Tim.1.1"
∷ word (ἀ ∷ π ∷ ό ∷ σ ∷ τ ∷ ο ∷ ∙λ ∷ ο ∷ ς ∷ []) "2Tim.1.1"
∷... |
-- There was a bug with module application in a let in a
-- parameterised module.
module Issue155 (A : Set) where
module M (Y : Set) where
postulate F : Set → Set
Foo : Set₁
Foo = let module M′ = M A in (B : Set) → M′.F B
record R : Set₁ where
open M A
field
B : Set
C : F A
|
------------------------------------------------------------------------
-- Validity of declarative typing and kinding of Fω with interval kinds
------------------------------------------------------------------------
{-# OPTIONS --safe --without-K #-}
module FOmegaInt.Typing.Validity where
open import Data.Fin usin... |
module Foundation.Semigroup where
open import Foundation.Primitive
open import Foundation.Equivalence
open import Agda.Primitive
record IsAssociative {a} {A : Set a} {ℓ} ⦃ _ : Equivalence A ℓ ⦄ (_∙_ : A → A → A) : ℞ a ⊔ ℓ where
field
associativity : ∀ x y z → ((x ∙ y) ∙ z) ≈ (x ∙ (y ∙ z))
open IsAssociative ⦃... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Data.List.Base where
open import Agda.Builtin.List public
open import Cubical.Core.Everything
open import Cubical.Data.Maybe.Base
open import Cubical.Data.Nat.Base
module _ {ℓ} {A : Type ℓ} where
infixr 5 _++_
infixl 5 _∷ʳ_
[_] : A → Lis... |
module Instances where
open import Level using () renaming (zero to ℓ₀)
open import Category.Functor using (RawFunctor)
open import Data.Maybe as M using (Maybe)
open import Data.Nat using (ℕ)
open import Data.Product using (_×_ ; _,_ ; proj₁ ; proj₂)
open import Data.Vec using (Vec)
import Data.Vec.Equality
open Data... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Rationals.HITQ where
open import Cubical.HITs.Rationals.HITQ.Base public
-- open import Cubical.HITs.Rationals.HITQ.Properties public
|
{-# OPTIONS --without-K --safe #-}
module Data.Fin.Base where
open import Data.Maybe.Base
open import Data.Nat.Base using (ℕ; suc; zero)
open import Level
open import Data.Empty
Fin : ℕ → Type
Fin zero = ⊥
Fin (suc n) = Maybe (Fin n)
pattern f0 = nothing
pattern fs n = just n
|
------------------------------------------------------------------------
-- This file contains the definition of a preorder as a category with --
-- additional properties. --
------------------------------------------------------------------------
module Category.Preorder whe... |
module BasicIS4.Metatheory.Hilbert-TarskiGluedHilbert where
open import BasicIS4.Syntax.Hilbert public
open import BasicIS4.Semantics.TarskiGluedHilbert public
-- Internalisation of syntax as syntax representation in a particular model.
module _ {{_ : Model}} where
[_] : ∀ {A Γ} → Γ ⊢ A → Γ [⊢] A
[ var i ] = ... |
module HelloWorldPrim where
open import IO.Primitive.Infinite
open import Codata.Musical.Costring
main = putStrLn (toCostring "Hello World!")
|
postulate
A B : Set
C : .{{_ : B}} → Set
instance
f : {{_ : A}} → B
test : {{x : A}} → C
|
------------------------------------------------------------------------
-- Properties relating Any to various list functions
------------------------------------------------------------------------
module Data.List.Any.Properties where
open import Category.Monad
open import Data.Bool
open import Data.Bool.Properties... |
-- Andreas, 2021-08-18, issue #5506 reported by alexarice
-- A crash in the forcing methodology introduced in 2.6.1
-- that surfaced with the removal of auto-inlining in 2.6.2.
-- {-# OPTIONS --no-forcing #-} -- fixes
-- {-# OPTIONS --auto-inline #-} -- fixes
{-# OPTIONS -v tc.lhs.unify.force:100 #-}
open import... |
{-# OPTIONS --omega-in-omega --no-termination-check --overlapping-instances #-}
module Light.Library.Data.Either where
open import Light.Level using (Level ; Setω ; _⊔_)
open import Light.Variable.Sets
open import Light.Variable.Levels
record Dependencies : Setω where
record Library (dependencies : Dependencies) : ... |
f : Set → Set
module _ (A : Set) where
mutual
g : Set
g = h
h : Set
h = A
f = g
|
{-# OPTIONS --without-K --safe #-}
-- The One Category is also a -2-Category
module Categories.Minus2-Category.Instance.One where
open import Categories.Minus2-Category
open import Categories.Category.Instance.One
-- Proof is trivial
⊤-is-2-Category : ∀ {o ℓ e} → -2-Category {o} {ℓ} {e}
⊤-is-2-Category = record { c... |
module Oscar.Data.Term {𝔣} (FunctionName : Set 𝔣) where
open import Oscar.Data.Equality
open import Oscar.Data.Fin
open import Oscar.Data.Nat
open import Oscar.Data.Vec
open import Oscar.Function
open import Oscar.Relation
mutual
Terms : Nat → Nat → Set 𝔣
Terms N m = Vec (Term m) N
data Term (m : Nat) : S... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.