text stringlengths 4 690k |
|---|
{-# OPTIONS --without-K --exact-split --safe #-}
open import Fragment.Algebra.Signature
module Fragment.Algebra.Free.Monad (Σ : Signature) where
open import Fragment.Algebra.Free.Base Σ
open import Fragment.Algebra.Algebra Σ
open import Fragment.Algebra.Homomorphism Σ using (_⟿_; Congruent; Homomorphic)
open import ... |
module Star where
open import Prelude
infixr 40 _•_ _++_
infixl 30 _on_
infixr 20 _==>_ _=[_]=>_
data Star {X : Set} (R : Rel X) : Rel X where
ε : {x : X} -> Star R x x
_•_ : {x y z : X} -> R x y -> Star R y z -> Star R x z
_++_ : {X : Set}{R : Rel X}{x y z : X} ->
Star R x y -> Star R y z -> Star R x... |
{-# OPTIONS --copatterns #-}
module MixingCoPatternsAndCoConstructors where
data ℕ : Set where
zero : ℕ
suc : (n : ℕ) → ℕ
module MStream where
record Stream (A : Set) : Set where
coinductive
constructor _∷_
field
head : A
tail : Stream A
open Stream
weird : (n : ℕ) → Stream ℕ
he... |
module cws where
open import lib
open import cws-types public
----------------------------------------------------------------------------------
-- Run-rewriting rules
----------------------------------------------------------------------------------
data gratr2-nt : Set where
_ws-plus-67 : gratr2-nt
_ws : gratr... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Groups.Definition
open import Groups.Abelian.Definition
open import Setoids.Setoids
open import Rings.Definition
open import Modules.Definition
open import Fields.Fields
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
module Vectors.VectorSpac... |
{-# OPTIONS --type-in-type #-}
open import Data.Product renaming (proj₁ to ₁; proj₂ to ₂)
open import Relation.Binary.PropositionalEquality
open import Function
test : Set
test = Set where
-- (Agda 2.6.1.3)
-- works
--------------------------------------------------------------------------------
-- elimina... |
{-# OPTIONS --without-K #-}
module sets.unit where
open import level
record ⊤ {i : Level} : Set i where
constructor tt
⊤-elim : ∀ {i j} (P : ⊤ {i} → Set j) → P tt → (x : ⊤) → P x
⊤-elim P ptt tt = ptt
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Ints.BiInvInt where
open import Cubical.HITs.Ints.BiInvInt.Base public
open import Cubical.HITs.Ints.BiInvInt.Properties public
|
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.NType2
open import lib.PathGroupoid
open import lib.types.Bool
open import lib.types.IteratedSuspension
open import lib.types.Lift
open import lib.types.LoopSpace
open import lib.types.Nat
open import lib.types.Paths
open import lib.types.Pi
open impo... |
module plfa.part1.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 ... |
module Main where
import PolyDepPrelude
import Homogenous.Base
import Homogenous.Equality
import Homogenous.Reflexivity
import Homogenous.Nat
import Tools
import Reflexivity
import EqBase
import TYPE
|
module Logic where
data True : Set where
tt : True
infix 10 _/\_
data _/\_ (P Q : Set) : Set where
<_,_> : P -> Q -> P /\ Q
|
open import Mockingbird.Forest using (Forest)
-- Craig’s Discovery
module Mockingbird.Problems.Chapter20 {ℓb ℓ} (forest : Forest {ℓb} {ℓ}) where
open import Data.Product using (_,_)
open import Data.Vec using ([]; _∷_)
open import Function using (_$_)
open import Relation.Unary using (Pred; _∈_; _⊆_; _⊇_)
open Fores... |
------------------------------------------------------------------------
-- Bi-invertibility
------------------------------------------------------------------------
-- The development is based on the presentation of bi-invertibility
-- (for types and functions) and related things in the HoTT book.
{-# OPTIONS --with... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties for distributive lattice
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary.Lattice
module Relation.Binary.Proper... |
{-# OPTIONS --allow-unsolved-metas #-}
module InnerProduct where
open import Algebra.Bundles using (CommutativeRing)
open import NormedModule using (NormedModule)
open import Level using (_⊔_; suc)
open import Relation.Nullary using (¬_)
module _
{r ℓr} (CR : CommutativeRing r ℓr)
m ℓm rel
where
module _
{... |
{-# OPTIONS --without-K #-}
module Stream where
open import Level as Level using (zero)
import Relation.Binary as BinRel
open import Relation.Binary as BinRel hiding (Setoid; Rel)
open import Relation.Binary.PropositionalEquality as PE
Setoid = BinRel.Setoid Level.zero Level.zero
open import Data.Nat using (ℕ; zero;... |
open import Issue1296.SolvedMeta
-- Expected error:
|
module Dave.Algebra.Naturals.Addition where
open import Dave.Algebra.Naturals.Definition public
open import Dave.Extensionality
_+_ : ℕ → ℕ → ℕ
zero + b = b
suc a + b = suc (a + b)
infixl 6 _+_
{- Semigroup -}
+-assoc : associative _+_
+-assoc zero n p = refl
+-assoc (suc m) n p = cong suc (+-a... |
{-# OPTIONS --cubical #-}
open import Agda.Primitive.Cubical
renaming ( primIMin to _∧_ -- I → I → I
; primIMax to _∨_ -- I → I → I
; primINeg to ~_ -- I → I
)
infix 10 _≡_
postulate
_≡_ : I → I → Set
refl : ∀ {i} → i ≡ i
module Vars (i j k : I) where
... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Every respectful unary relation induces a preorder. No claim is
-- made that this preorder is unique.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
... |
module Dave.Structures.Monoid where
open import Dave.Structures.Semigroup public
record Identity {A : Set} (_·_ : op₂ A) (e : A) : Set where
field
left : left-identity _·_ e
right : right-identity _·_ e
record IsMonoid {A : Set} (_·_ : op₂ A) (e : A) : Set where
fie... |
-- Andreas, 2016-02-02, issue reported by Nisse
record R : Set₁ where
field F : Set
postulate r : R
open R r using (F)
S : Set
S = F
-- Run "Explain why a particular name is in scope" (C-c C-w) for F.
-- Expected result:
--
-- F is in scope as
-- * a record field Issue1804._.F brought into scope by
-- - th... |
module Oscar.Property.Reflexivity where
open import Oscar.Level
record Reflexivity {𝔬} {⋆ : Set 𝔬} {ℓ} (_≣_ : ⋆ → ⋆ → Set ℓ) : Set (𝔬 ⊔ ℓ) where
field
reflexivity : ∀ x → x ≣ x
open Reflexivity ⦃ … ⦄ public
|
module Selective.Examples.PingPong where
open import Selective.ActorMonad public
open import Prelude
-- An example including three actors: spawner, pinger, ponger
--
-- Spawner is the actor that starts it all.
-- Spawner spawns both pinger and ponger.
-- Then spawner send the reference of ponger to pinger,
-- and the... |
-- Minimal implicational logic, vector-based de Bruijn approach, initial encoding
module Vi.ArrMp where
open import Lib using (Nat; suc; _+_; Fin; fin; Vec; _,_; proj; VMem; mem)
-- Types
infixr 0 _=>_
data Ty : Set where
UNIT : Ty
_=>_ : Ty -> Ty -> Ty
-- Context and truth judgement
Cx : Nat ->... |
-- From Dimytro Starosud
-- https://github.com/dima-starosud/Uniqueness-typing-in-Agda/blob/master/RefAPITest.agda
module Issue784 where
open import Issue784.RefAPI
open import Function
open import Data.Nat
open import Data.Product
-- new : ∀ a n → Transformer! [] [(n , Unique (Ref-ℕ a))]
{-Here also doesn't work wi... |
import Lvl
open import Structure.Operator.Vector
open import Structure.Setoid
open import Type
module Structure.Operator.Vector.LinearCombination
{ℓᵥ ℓₛ ℓᵥₑ ℓₛₑ}
{V : Type{ℓᵥ}} ⦃ equiv-V : Equiv{ℓᵥₑ}(V) ⦄
{S : Type{ℓₛ}} ⦃ equiv-S : Equiv{ℓₛₑ}(S) ⦄
{_+ᵥ_ : V → V → V}
{_⋅ₛᵥ_ : S → V → V}
{_+ₛ_ _⋅ₛ_ : S ... |
{-# OPTIONS --cubical --safe #-}
module Cardinality.Finite.ManifestEnumerable.Inductive where
open import Prelude
open import Data.List public
open import Data.List.Membership public
ℰ : Type a → Type a
ℰ A = Σ[ xs ⦂ List A ] Π[ x ⦂ A ] ∥ x ∈ xs ∥
|
module interactiveProgramsAgdaUnsized where
open import NativeIO
open import Function
record IOInterface : Set₁ where
field Command : Set
Response : (c : Command) → Set
open IOInterface public
mutual
record IO (I : IOInterface) (A : Set) : Set where
coinductive
constructor delay
... |
------------------------------------------------------------------------------
-- Testing a type synonymous for Set
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism... |
-- This file needs to exist because the Makefile dependencies require a *.agda file.
-- The actual test is in Issue2937.sh which uses two files under Issue2737/*.agda
|
{-# OPTIONS --without-K --safe #-}
module Source.Type where
open import Source.Size as S using
( Size ; Δ ; Δ′ ; Δ″ ; Ω ; Ω′ ; Ω″ ; n ; m ; o ; p ; b )
open import Source.Size.Substitution.Canonical as SC using
( Sub⊢ )
open import Source.Size.Substitution.Theory
open import Source.Size.Substitution.Universe as SU... |
module map-is-foldr where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; cong)
open Eq.≡-Reasoning
open import lists using (List; []; _∷_; map; foldr)
postulate
-- 外延性の公理
extensionality : ∀ {A B : Set} {f g : A → B}
→ (∀ (x : A) → f x ≡ g x)
-----------------------
→ f ≡ g
-... |
module Proof-last-is-deterministic where
-- Show that last is a deterministic operation.
-- The property to show is:
--
-- l == l1 ++ [x1] and l == l2 ++ [x2] implies x1 == x2
--
-- Here we show the simplified property
--
-- l1 ++ [x1] == l2 ++ [x2] implies x1 == x2
--
-- The initial property can be derived from th... |
module Haskell.Prim.Absurd where
open import Agda.Builtin.Nat
open import Agda.Builtin.List
open import Agda.Builtin.Unit
open import Agda.Builtin.Reflection renaming (bindTC to _>>=_; absurd to absurdP)
open import Agda.Builtin.Equality
open import Haskell.Prim
private
pattern vArg x = arg (arg-info visible rel... |
{-# OPTIONS --without-K #-}
module Data.ByteVec where
import Data.ByteString as BS
open import Data.Word8 using (Word8)
open BS using (ByteString; length)
open import Data.Nat using (ℕ; _<_)
open import Data.Product using (Σ; _,_; proj₁; proj₂)
open import Relation.Nullary using (yes; no)
open import Relation.Nullar... |
module Haskell.Prim.Show where
open import Agda.Builtin.Char
open import Agda.Builtin.Nat
import Agda.Builtin.String as Str
open import Haskell.Prim
open import Haskell.Prim.String
open import Haskell.Prim.List
open import Haskell.Prim.Word
open import Haskell.Prim.Double
open import Haskell.Prim.Maybe
open import H... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Membership of vectors, along with some additional definitions.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Relation.Binary using (Seto... |
-- Andreas, 2017-12-16, issue #2873, reported by m0davis
-- Regression introduced by a fix of #737 that printed
-- the refinement candidate to concrete syntax
-- and ran the scope checker again to get back to abstract syntax.
-- {-# OPTIONS -v interaction:50 #-}
open import Agda.Builtin.Nat
data Vec {a} (A : Set a)... |
{-# OPTIONS --cubical --safe --postfix-projections #-}
module Function.Injective.Base where
open import Level
open import Path
open import Data.Sigma
Injective : (A → B) → Type _
Injective f = ∀ x y → (f⟨x⟩≡f⟨y⟩ : f x ≡ f y) → x ≡ y
infixr 0 _↣_
_↣_ : Type a → Type b → Type (a ℓ⊔ b)
A ↣ B = Σ[ f ⦂ (A → B) ] × Injec... |
{-# OPTIONS --cubical #-}
module _ where
module _ where
open import Agda.Primitive.Cubical public
open import Agda.Builtin.Cubical.Path public
refl : ∀ {a} {A : Set a} {x : A} → x ≡ x
refl {x = x} = \ _ → x
-- Here there's no solution for H, pattern unification will try
-- H := \ i -> b, but the equality co... |
module Structure.Operator.Field.VectorSpace where
import Lvl
open import Structure.Setoid
open import Structure.Operator.Field
open import Structure.Operator.Properties using (associativity ; identityₗ ; distributivityᵣ)
open import Structure.Operator.Vector
open import Structure.Operator
open import Type
privat... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Some derivable properties
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Algebra.Bundles
module Algebra.Properties.Group {g₁ g₂} (G : Gr... |
module Category where
open import Agda.Primitive
open import Equality
open import Finite
record Category ℓ : Set (lsuc ℓ) where
field
obj : Set ℓ
hom : obj → obj → Set ℓ
id-hom : ∀ {x} → hom x x
compose : ∀ {x y z} → hom y z → hom x y → hom x z
compose-id-left : ∀ {x y} {f : hom x y} → compose ... |
{-# OPTIONS --cubical-compatible #-}
open import Agda.Primitive
data _≡_ {a} {A : Set a} (x : A) : A → Set where
refl : x ≡ x
|
-- Andreas and James, Nov 2011 and Oct 2012
-- function with flexible arity
-- {-# OPTIONS --no-coverage-check #-}
-- {-# OPTIONS -v tc.cover:20 #-}
module FlexibleInterpreter where
open import Common.Prelude using (Nat; zero; suc)
open import Common.MAlonzo hiding (main)
open import Common.Equality
data Ty : Set whe... |
{-# OPTIONS --without-K --safe #-}
module Cats.Category.Fun.Facts.Limit where
open import Data.Product using (_,_)
open import Cats.Category
open import Cats.Category.Cat.Facts.Exponential using (Eval ; Curry ; Uncurry)
open import Cats.Category.Cat.Facts.Product using (Swap)
open import Cats.Category.Cones as Cones ... |
{- 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.Consensus.SafetyRul... |
-- Andreas, 2020-06-21, issue #3734, reported 2019-05-01 by gallais
-- User warnings also on constructors and pattern synonyms.
-- {-# OPTIONS -v scope.warning.usage:50 #-}
data A : Set where
s : A → A
a : A
b : A
b = a -- (usage of a, but no warning yet installed)
{-# WARNING_ON_USAGE a "Used a" #-}
_ : A
_ ... |
--------------------------------------------------------------------------------
-- This file provides the data structures and functions for the theory of
-- cedille core extended with the constructs for metaprogramming.
--------------------------------------------------------------------------------
{-# OPTIONS --typ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties of n-ary products
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Product.N-ary.Properties where
open import Data.Nat.Base hid... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Data.Fin where
open import Cubical.Data.Fin.Base public
open import Cubical.Data.Fin.Properties public
open import Cubical.Data.Fin.Literals public
|
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.types.FunctionSeq
open import lib.types.TLevel
open import lib.types.Pi
open import lib.types.Pointed
open import lib.types.Sigma
open import lib.NType2
module lib.types.Truncation where
module _ {i} where
postulate -- HIT
Trunc :... |
{-# OPTIONS --without-K --safe #-}
module Definition.Typed.Consequences.Canonicity where
open import Definition.Untyped
open import Definition.Typed
open import Definition.Typed.Weakening
open import Definition.Typed.Properties
open import Definition.Typed.EqRelInstance
open import Definition.LogicalRelation
open im... |
open import Level using (Level)
open import Function using (_∘_; id; flip)
open import Data.Fin as Fin using (fromℕ)
open import Data.Nat as Nat using (ℕ; suc; zero; pred; _+_; _⊔_)
open import Data.Nat.Properties using (≤-decTotalOrder)
open import Data.List... |
open import Categories
open import Functors
open import RMonads
module RMonads.RKleisli.Adjunction {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.RKleisli M
open import RAdjunctions
open import RMonads.RKleisli.Fun... |
open import Data.ByteString using ( ByteString ; Style ; strict ; lazy )
open import Data.ByteString.Primitive using ( strict₁ ; strict₂ ; lazy₁ ; lazy₂ )
open import Data.Bool using ( Bool )
open import Data.Char using ( Char )
open import Data.Nat using ( ℕ )
open import Data.Natural using ( Natural ; % )
open import... |
{-# OPTIONS --without-K #-}
module hott.types.nat where
open import hott.core.universe
open import hott.core.equality
open import hott.functions
data ℕ : Type₀ where
zero : ℕ
succ : ℕ → ℕ
{-# BUILTIN NATURAL ℕ #-}
-- Addition.
_+_ : ℕ → ℕ → ℕ
0 + y = y
succ x + y = succ (x + y)
-- Multiplication
_*_ ... |
-- The "intro" command manages to refine goals of type ∞ A with the
-- term ♯ ?.
{-# OPTIONS --universe-polymorphism #-}
module IntroSharp where
postulate
Level : Set
zero : Level
suc : (i : Level) → Level
_⊔_ : Level -> Level -> Level
{-# BUILTIN LEVEL Level #-}
{-# BUILTIN LEVELZERO zero #-}
{-# BUI... |
data _≡_ {A : Set}(x : A) : A → Set where
refl : x ≡ x
data * : Set where ! : *
postulate
prop : ∀ x → x ≡ !
record StrictTotalOrder : Set where
field compare : *
open StrictTotalOrder
module M (Key : StrictTotalOrder) where
postulate
intersection′-₁ : ∀ x → x ≡ compare Key
-- Doesn't termin... |
{-# OPTIONS --without-K --exact-split #-}
module 04-inductive-types where
import 03-natural-numbers
open 03-natural-numbers public
-- Section 4.2 The unit type
-- Definition 4.2.1
data unit : UU lzero where
star : unit
𝟙 = unit
ind-unit : {i : Level} {P : unit → UU i} → P star → ((x : unit) → P x)
ind-unit ... |
module Category where
open import Logic.Equivalence
open import Logic.Relations
open Equivalence using () renaming (_==_ to eq)
record Cat : Set2 where
field
Obj : Set1
_─→_ : Obj -> Obj -> Set
id : {A : Obj} -> A ─→ A
_∘_ : {A B C : Obj} -> B ─→ C -> A ─→ B -> A ─→ C
Eq :... |
{-# OPTIONS --without-K --safe #-}
module Magma.Bundles where
open import Algebra.Bundles
open import Algebra.Core
open import Magma.Structures
open import Relation.Binary
open import Level
record IdempotentMagma c ℓ : Set (suc (c ⊔ ℓ)) where
infixl 7 _∙_
infix 4 _≈_
field
Carrier : Set c
_≈_ : ... |
------------------------------------------------------------------------------
-- Exercises for Type Theory CM0859 (Prof. Andreas Abel).
-- http://www1.eafit.edu.co/asr/courses/type-theory-CM0859/exercises.pdf
------------------------------------------------------------------------------
open import Data.PropFormula 2... |
{-# OPTIONS --cubical --safe #-}
module Relation.Nullary.Decidable where
open import Relation.Nullary.Decidable.Base public
|
module Selective.Examples.TestChannel where
open import Selective.Libraries.Channel
open import Prelude
open import Debug
open import Data.Nat.Show using (show)
ℕ-ReplyMessage : MessageType
ℕ-ReplyMessage = ValueType UniqueTag ∷ [ ValueType ℕ ]ˡ
ℕ-Reply : InboxShape
ℕ-Reply = [ ℕ-ReplyMessage ]ˡ
ℕ×ℕ→ℕ-Message : Me... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.Polynomials.Multivariate.EquivCarac.A[X]X-A where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.N... |
open import x1-Base
module x4-Nat where
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
{-# BUILTIN NATURAL ℕ #-}
data _≤_ : Rel ℕ where
z≤n : ∀ {x} → zero ≤ x
s≤s : ∀ {x y} → x ≤ y
→ suc x ≤ suc y
≤-suc : ∀ {x y} → suc x ≤ suc y
→ x ≤ y
≤-suc (s≤s x≤y) = x≤y
... |
{-# OPTIONS --cubical --safe #-}
module Control.Monad.Levels.Zipping where
open import Prelude
open import Control.Monad.Levels.Definition
open import Control.Monad.Levels.Eliminators
open import Data.Bag
open import Path.Reasoning
open import Cubical.Foundations.HLevels using (isOfHLevelΠ)
zip₂-alg : Levels-ϕ[ A ]... |
{-# OPTIONS --cubical --safe #-}
module Data.Binary where
open import Data.Binary.Base public
using (𝔹; ⟦_⇑⟧; ⟦_⇓⟧; _+_; _*_; _-_)
|
{-# OPTIONS --warning=error --safe --without-K #-}
open import Functions.Definition
open import Groups.Definition
open import Groups.Homomorphisms.Definition
open import Setoids.Setoids
open import Sets.EquivalenceRelations
open import Groups.Lemmas
open import Groups.QuotientGroup.Definition
open import Groups.Homomo... |
-- {-# OPTIONS -v import:10 -v scope:10 #-}
module Issue1078 where
import Common.Level
import Issue1078.A
import Issue1078.B
-- Was: weird scope error in Issue1078.B
-- Should give error:
-- You tried to load Issue1078/B.agda
-- which defines the module Issue1078.A. However, according to the
-- include path this mo... |
------------------------------------------------------------------------
-- Laws related to return⋆
------------------------------------------------------------------------
module TotalParserCombinators.Laws.ReturnStar where
open import Algebra
open import Category.Monad
open import Codata.Musical.Notation
open impor... |
module Esterel.Lang.CanFunction.Plug where
open import Data.Nat using (_+_ ; suc)
open import Function using (_∋_ ; _∘_ ; id ; _$_)
open import Data.Nat.Properties.Simple using ( +-comm ; +-assoc)
open import utility
open import Esterel.Lang
open import Esterel.Lang.Properties
open import Esterel.Lang.CanFunction
open... |
open import Issue4959-2
|
-- Andreas, bug found 2011-12-31
{-# OPTIONS --irrelevant-projections #-}
module Issue543a where
open import Common.Equality
data ⊥ : Set where
record ⊤ : Set where
constructor tt
data Bool : Set where
true false : Bool
record Squash (A : Set) : Set where
constructor squash
field
.unsquash : A
open ... |
{-# OPTIONS --exact-split -v tc.cover.cover:100 #-}
open import Common.Bool
open import Common.Equality
record Unit : Set where
eta-equality
constructor unit
f : Unit → Bool → Bool
f unit true = true
f u false = false -- passes without --exact-split
-- All equations pass do hold definitionally:
test-1 : f... |
open import Common.IO
open import Common.Unit
open import Common.String
open import Common.Nat
record Stream (A : Set) : Set where
coinductive
field
head : A
tail : Stream A
open Stream public
repeat : ∀ {A} → A → Stream A
head (repeat x) = x
tail (repeat x) = repeat x
lookup : ∀ {A} → Stream A → Nat → ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- A different interface to the Kleene lists, designed to mimic
-- Data.List.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Kleene.AsL... |
module Nat where
open import Function hiding (_∘_; id)
open import Level
open import Basic
open import Category
import Functor
open Category.Category
open Functor.Functor
record Nat {C₀ C₁ ℓ D₀ D₁ ℓ′} {C : Category C₀ C₁ ℓ} {D : Category D₀ D₁ ℓ′} (F G : Functor.Functor C D) : Set (suc (C₀ ⊔ C₁ ⊔ ℓ ⊔ D₀ ⊔ D₁ ⊔ ℓ′)) ... |
-- Andreas, 2016-07-28, issue #1720
record Foo (A : Set) : Set where
a : A
a = {!!} where
a' : A
a' = {!!}
field
f : A
-- Now: better error:
-- This declaration is illegal in a record before the last field
-- when scope checking the declaration
-- record Foo A where
-- mutual
-- a : A
... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category.Monoidal.Structure using (MonoidalCategory)
module Categories.Category.Construction.MonoidalFunctors {o ℓ e o′ ℓ′ e′}
(C : MonoidalCategory o ℓ e) (D : MonoidalCategory o′ ℓ′ e′) where
-- The functor category for a given pair of monoidal categories... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Homomorphism proofs for constants over polynomials
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Tactic.RingSolver.Core.Polynomial.Param... |
module PublicWithoutOpen where
module A where
module B = A public
|
------------------------------------------------------------------------------
-- Alter: An unguarded co-recursive function
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-poly... |
module Tactic.Reflection.Telescope where
open import Prelude hiding (abs)
open import Builtin.Reflection
open import Tactic.Reflection.DeBruijn
Telescope = List (String × Arg Type)
telView : Type → Telescope × Type
telView (pi a (abs x b)) = first (_∷_ (x , a)) (telView b)
telView a = [] , a
visible... |
-- The ATP pragma with the role <prove> can be used with postulates.
module ATPConjecture where
postulate
D : Set
_≡_ : D → D → Set
postulate
sym : ∀ {m n} → m ≡ n → n ≡ m
{-# ATP prove sym #-}
|
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
open import Categories.Functor hiding (id)
-- Cone over a Functor F (from shape category J into category C)
module Categories.Diagram.Cone
{o ℓ e} {o′ ℓ′ e′} {C : Category o ℓ e} {J : Category o′ ℓ′ e′} (F : Functor J C) where
open Category C
open ... |
module Luau.Value where
open import Agda.Builtin.Float using (Float)
open import Luau.Addr using (Addr)
open import Luau.Syntax using (Block; Expr; nil; addr; number)
open import Luau.Var using (Var)
data Value : Set where
nil : Value
addr : Addr → Value
number : Float → Value
val : ∀ {a} → Value → Expr a
val ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Properties related to All
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Vec.Functional.Relation.Unary.All.Properties where
open import ... |
module Structure.Category.Functor.Category where
open import Data.Tuple
open import Function.Equals
import Lvl
open import Logic
open import Logic.Predicate
open import Structure.Setoid
open import Structure.Category
open import Structure.Category.Functor
open import Structure.Category.NaturalTransformation
open ... |
module Avionics.Maybe where
open import Function using (_∘_)
open import Level using (Level)
private
variable
a b c : Level
A : Set a
B : Set b
C : Set c
data Maybe (A : Set a) : Set a where
nothing : Maybe A
just : (x : A) → Maybe A
maybe : ∀ {A : Set a} {B : Maybe A → Set b} →
((x... |
{-
Part 3: Transport and composition
- Cubical transport
- Subst as a special case of cubical transport
- Path induction from subst?
- Homogeneous composition (hcomp)
- Binary composition of paths as special case of hcomp
-}
{-# OPTIONS --cubical #-}
module Part2 where
open import Part1 public
-- Transport is mor... |
module Structure.Relator.Ordering.Lattice where
import Lvl
open import Functional
open import Logic
open import Logic.Propositional hiding (⊤ ; ⊥)
open import Logic.Predicate
open import Logic.Propositional.Theorems
open import Structure.Relator.Ordering
open import Structure.Relator.Properties hiding (antisymmet... |
module Haskell.Prim.Enum where
open import Agda.Builtin.Nat as Nat hiding (_==_; _<_; _+_; _*_; _-_)
open import Agda.Builtin.Char
open import Agda.Builtin.Equality
open import Agda.Builtin.List
open import Agda.Builtin.Unit
open import Agda.Builtin.Int using (pos; negsuc)
open import Haskell.Prim
open import Haskel... |
{-# OPTIONS --type-in-type #-}
Ty : Set; Ty
= (Ty : Set)
(ι : Ty)
(arr : Ty → Ty → Ty)
→ Ty
ι : Ty; ι = λ _ ι _ → ι
arr : Ty → Ty → Ty; arr = λ A B Ty ι arr → arr (A Ty ι arr) (B Ty ι arr)
Con : Set;Con
= (Con : Set)
(nil : Con)
(snoc : Con → Ty → Con)
→ Con
nil : Con;nil
= λ Con nil snoc → n... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Truncation.FromNegTwo.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Data.Nat
open import Cubical.Data.NatMinusOne
open import Cubical.HITs.Nullification
open import Cubical.HITs.Sn.Ba... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Groups.Definition
open import Setoids.Setoids
open import Setoids.Subset
open import LogicalFormulae
open import Sets.EquivalenceRelations
open import Groups.Homomorphisms.Definition
open import Groups.Homomorphisms.Lemmas
open import Groups.Subgroups.Defi... |
{-# OPTIONS --cubical --safe #-}
module Data.Binary.Literals where
open import Data.Binary.Base
open import Literals.Number
open import Data.Unit
open import Data.Nat.Literals
instance
number𝔹 : Number 𝔹
Number.Constraint number𝔹 = λ _ → ⊤
Number.fromNat number𝔹 = λ n → ⟦ n ⇑⟧
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.