text stringlengths 4 690k |
|---|
{-# OPTIONS --without-K #-}
module Pitch where
open import Data.Bool using (Bool; false; true)
open import Data.Integer using (โค; +_; -[1+_])
open import Data.Fin using (Fin; toโ; #_; _โ_) renaming (zero to fz; suc to fs)
open import Data.Maybe using (Maybe; just; nothing) renaming (map to mmap)
... |
module Base.Prelude.Unit where
open import Data.Unit using (tt) renaming (โค to โคแต) public
open import Base.Free using (Free; pure)
โค : (S : Set) (P : S โ Set) โ Set
โค _ _ = โคแต
pattern Tt = pure tt
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
module stash.modalities.gbm.GbmUtil where
BM-Relation : โ {โ} (M : Modality โ) {A : Type โ} {B : Type โ} (Q : A โ B โ Type โ) โ Type โ
BM-Relation M {A} {B} Q =
{aโ : A} {bโ : B} (qโ : Q aโ bโ)
{aโ : A} (qโ : Q aโ bโ)
{bโ : B} (qโ : Q aโ bโ) โ ... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.EilenbergMacLane
open import groups.ToOmega
open import cohomology.Theory
open import cohomology.SpectrumModel
module cohomology.EMModel where
module _ {i} (G : AbGroup i) where
open EMExplicit G using (โEM; EM-level; EM-conn; spectrum)... |
------------------------------------------------------------------------
-- Laws related to _โ_ and return
------------------------------------------------------------------------
module TotalParserCombinators.Laws.ApplicativeFunctor where
open import Algebra
open import Category.Monad
open import Codata.Musical.Nota... |
{-# OPTIONS --no-termination-check #-}
module RunTests where
open import Prelude.Bool
open import Prelude.Char
open import Prelude.Nat
open import Prelude.List
open import Prelude.IO
open import Prelude.String
open import Prelude.Unit
open import Prelude.Product
postulate
Stream : Set
popen : String -> String ->... |
-- ----------------------------------------------------------------------
-- The Agda ฯ-library
--
-- Renamings
-- ----------------------------------------------------------------------
-- A renaming is defined as a substitution ฯ, mapping
-- indices to indices (w/ explicit bounds). It is a subclass
-- of substituti... |
------------------------------------------------------------------------
-- Isomorphism of monoids on sets coincides with equality (assuming
-- univalence)
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
-- This module has been developed in collaboration wit... |
module Haskell.Prim.Char where
open import Agda.Builtin.IO
open import Agda.Builtin.String
open import Agda.Builtin.Char
open import Agda.Builtin.Bool
open import Agda.Builtin.Int using (pos; negsuc)
open import Haskell.Prim
open import Haskell.Prim.Int
open import Haskell.Prim.Integer
open import Haskell.Prim.Enum
... |
module TestLib where
import Lib.Bool
import Lib.Eq
import Lib.Fin
import Lib.IO
import Lib.Id
import Lib.List
import Lib.Logic
import Lib.Maybe
import Lib.Monad
import Lib.Nat
import Lib.Prelude
import Lib.Vec
|
module UniDB.Morph.Shift where
open import UniDB.Spec
open import UniDB.Morph.Depth
open import UniDB.Morph.Weaken
--------------------------------------------------------------------------------
data Shift : MOR where
shift : {ฮณโ ฮณโ : Dom} (ฮพ : Depth Weaken ฮณโ ฮณโ) โ Shift ฮณโ ฮณโ
instance
iUpShift : Up Shift
... |
------------------------------------------------------------------------------
-- Subtraction using the fixed-point operator
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-pol... |
{-# OPTIONS --type-in-type #-}
module examplesPaperJFP.agdaCodeBrady where
open import Data.List
open import Agda.Builtin.Unit public renaming (โค to Unit; tt to triv)
open import Data.Product
open import examplesPaperJFP.StateDependentIO
{- Brady's Effect -}
Effect : Setโ
Effect = (Result : Set) โ (InResource : S... |
-- Andreas, Ulf, 2016-06-01, discussing issue #679
-- {-# OPTIONS -v tc.with.strip:20 #-}
postulate anything : {A : Set} โ A
data Ty : Set where
_=>_ : (a b : Ty) โ Ty
โฆ_โง : Ty โ Set
โฆ a => b โง = โฆ a โง โ โฆ b โง
eq : (a : Ty) โ โฆ a โง โ โฆ a โง โ Set
eq (a => b) f g = โ {x y : โฆ a โง} โ eq a x y โ eq b (f x) (g y)
bad... |
-- Andreas, 2014-09-23
-- Issue 1194, reported by marco.vax91, 2014-06-13
-- {-# OPTIONS -v scope.operators:50 #-}
module _ where
module A where
data D1 : Set where
c : D1
-- Just default notation for c here.
module B where
data D2 : Set where
c : A.D1 โ D2
-- Interesting notation for c here.
... |
{-
This second-order signature was created from the following second-order syntax description:
syntax CommGroup | CG
type
* : 0-ary
term
unit : * | ฮต
add : * * -> * | _โ_ l20
neg : * -> * | โ_ r40
theory
(ฮตUโแดธ) a |> add (unit, a) = a
(ฮตUโแดฟ) a |> add (a, unit) = a
(โA) a b c |> add (add(a, b), ... |
-- {-# OPTIONS --safe #-}
module Language where
open import Map
open import Relation.Binary.PropositionalEquality
open import Data.String using (String)
open import Data.Nat
open import Data.Bool
open import Data.Maybe using (Maybe; just; nothing)
open import Agda.Builtin.Unit
open import Data.Empty
open import Relati... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Finite.Fin.Instance.Parallel where
open import Data.Nat using (โ)
open import Data.Fin
open import Data.Fin.Patterns
open import Relation.Binary.PropositionalEquality using (_โก_ ; refl)
open import Categories.Category.Finite.Fin
open import Categories.Cat... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.types.Bool
open import lib.types.Group
open import lib.types.Nat
open import lib.types.Pi
open import lib.types.Sigma
open import lib.types.Coproduct
open import lib.types.Truncation
open import lib.groups.Homomorphism
open import lib.group... |
{-# OPTIONS --without-K #-}
open import library.Basics
open import library.types.Sigma
open import library.types.Bool
open import library.types.Truncation hiding (Trunc)
module Sec8judgmentalBeta where
{-
Recall Definition 3.6:
postulate
Trunc : Type โ Type
h-tr : (X : Type) โ is-prop (Trunc X)
โฃ_โฃ : {X : ... |
open import Prelude
module Implicits.Semantics.RewriteContext where
open import Implicits.Syntax
open import Implicits.Substitutions
open import Implicits.Substitutions.Lemmas
open import Data.Vec
open import Data.List.All as All
open import Extensions.Vec
-- rewrite context (relation between implicit and explicit ... |
{-# OPTIONS --allow-unsolved-metas #-}
module _ where
open import Agda.Primitive using (Level)
variable
l : Level
postulate
ฮฃ : {l' : Level}{X : Set} (Y : X โ Set l') -> Set
_,_ : {l' : Level}{X : Set} {Y : X โ Set l'} -> (x : X)(y : Y x) -> ฮฃ Y
is-universal-element : {l' : Level}{X : Set} {A : X โ Set l'} -... |
open import Auto.Core
open import Data.List using (_โท_; []; length)
open import Data.Nat using (โ; zero; suc)
open import Data.Product using (_,_)
open import Data.Sum using (injโ; injโ)
open import Reflection using (Term; Name; lam; visible; abs; TC; returnTC; bindTC)
module Auto.Extensible (instHintDB :... |
module Issue4267.A1 where
record RA1 : Setโ where
field
A : Set
|
module consoleExamples.helloWorld where
open import ConsoleLib
main : ConsoleProg
main = run (WriteString "Hello World")
|
module Prelude.Smashed where
open import Prelude.Equality
open import Prelude.Unit
open import Prelude.Empty
open import Prelude.Nat.Core
open import Prelude.Function
open import Prelude.Ord
record Smashed {a} (A : Set a) : Set a where
field
smashed : โ {x y : A} โ x โก y
open Smashed {{...}} public
{-# DISPLA... |
{-# OPTIONS --cubical --safe #-}
open import Agda.Builtin.Cubical.Path
open import Agda.Primitive
private
variable
a : Level
A B : Set a
Is-proposition : Set a โ Set a
Is-proposition A = (x y : A) โ x โก y
data โฅ_โฅ (A : Set a) : Set a where
โฃ_โฃ : A โ โฅ A โฅ
@0 trivial : Is-proposition โฅ A โฅ
re... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
module Categories.Object.Product.Core {o โ e} (๐ : Category o โ e) where
open import Level
open import Function using (flip; _$_)
open import Categories.Morphism ๐
open import Categories.Morphism.Reasoning ๐
open Category ๐
open HomReasoning
pr... |
module _ where
open import Agda.Builtin.Nat
postulate
F : Set โ Set
pure : โ {A} โ A โ F A
-- _<*>_ : โ {A B} โ F (A โ B) โ F A โ F B
fail : F Nat โ F Nat
fail a = (| suc a |)
|
postulate
A : Set
f : (B : Set) โ B โ A
f A a = a
-- Expected error:
-- A !=< A of type Set
-- (because one is a variable and one a defined identifier)
-- when checking that the expression a has type A
|
{-# OPTIONS --rewriting #-}
module FFI.Data.Aeson where
open import Agda.Builtin.Equality using (_โก_)
open import Agda.Builtin.Equality.Rewrite using ()
open import Agda.Builtin.Bool using (Bool)
open import Agda.Builtin.String using (String)
open import FFI.Data.ByteString using (ByteString)
open import FFI.Data.Ha... |
import cedille-options
module elaboration-helpers (options : cedille-options.options) where
open import lib
open import monad-instances
open import general-util
open import cedille-types
open import syntax-util
open import ctxt
open import conversion
open import constants
open import to-string options
open import subs... |
------------------------------------------------------------------------
-- An example: A function that, given a stream, tries to find an
-- element satisfying a predicate
------------------------------------------------------------------------
{-# OPTIONS --cubical --safe #-}
module Search where
open import Equalit... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.ZCohomology.Groups.Coproduct where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.HLevels
open import Cubical.Data.Nat
open import Cubica... |
-- Step-indexed logical relations based on functional big-step semantics.
--
-- Goal for now: just prove the fundamental theorem of logical relations,
-- relating a term to itself in a different environments.
--
-- But to betray the eventual goal, I can also relate integer values with a
-- change in the relation witnes... |
{-
Automatically generating proofs of UnivalentStr for records
-}
{-# OPTIONS --cubical --no-exact-split --safe #-}
module Cubical.Structures.Record where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
ope... |
module Record where
module M where
record A
: Set
where
constructor
a
open M
record B
: Set
where
record C
: Set
where
constructor
c
x
: A
x
= a
y
: C
y
= record {}
record D
(E : Set)
: Set
where
record F
: Setโ
where
field
G
: Set
... |
{-# OPTIONS --cubical --safe #-}
module JustBeInjective where
open import Cubical.Core.Everything
open import Cubical.Data.Unit
data maybe (A : Set) : Set where
just : A -> maybe A
nothing : maybe A
variable A : Set
unwrap : A โ (a : maybe A) โ A
unwrap _ (just x) = x
unwrap a nothing = a
just-injective : โ {A ... |
{-# OPTIONS --cubical #-}
module LaterPrims where
open import Agda.Primitive
open import Agda.Primitive.Cubical renaming (itIsOne to 1=1)
open import Agda.Builtin.Cubical.Path
open import Agda.Builtin.Cubical.Sub renaming (Sub to _[_โฆ_]; primSubOut to outS)
module Prims where
primitive
primLockUniv : Setโ
open... |
module 120-natural-induction-necessary where
open import 010-false-true
open import 020-equivalence
open import 100-natural
-- We prove that the induction axiom is necessary.
-- Peano axioms without induction.
record NaturalWithoutInduction
{M : Set}
(zero : M)
(suc : M -> M)
(_==_ : M -> M -> Set)
: Set1... |
module Issue468 where
data Unit : Set where
nothing : Unit
data Maybe (A : Set) : Set where
nothing : Maybe A
just : A โ Maybe A
data P : (R : Set) โ Maybe R โ Setโ where
p : (R : Set) (x : R) โ P R (just x)
works : P Unit (just _)
works = p _ nothing
fails : Unit โ P Unit (just _)
fails x = p _ nothing
|
{-# OPTIONS --safe --warning=error --without-K #-}
open import Setoids.Setoids
open import Agda.Primitive using (Level; lzero; lsuc; _โ_)
open import Groups.Definition
open import Groups.Homomorphisms.Definition
module Groups.Isomorphisms.Definition where
record GroupIso {m n o p : _} {A : Set m} {S : Setoid {m} {o}... |
module Lib.Vec where
open import Lib.Prelude
open import Lib.Nat
open import Lib.Fin
infixr 40 _::_ _++_
data Vec (A : Set) : Nat -> Set where
[] : Vec A 0
_::_ : forall {n} -> A -> Vec A n -> Vec A (suc n)
_++_ : {A : Set}{n m : Nat} -> Vec A n -> Vec A m -> Vec A (n + m)
[] ++ ys = ys
(x :: xs) ++ y... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommRing.Instances.Unit where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Unit
open import Cubical.Algebra.Ring
open import Cubical.Algebra.CommRing
private
variable
โ : Level
open CommRingStr
UnitCommRing : โ {โ} โ CommRing โ
fst UnitCommRi... |
module Prelude.String where
open import Prelude.Bool
open import Prelude.Char
open import Prelude.List
open import Prelude.Nat
postulate
String : Set
nil : String
primStringToNat : String โ Nat
charToString : Char -> String
{-# BUILTIN STRING String #-}
primitive
primStringAppend : String โ String โ Str... |
module Everything where
import Library
import Syntax
import RenamingAndSubstitution
import EquationalTheory
|
-- TODO: Unfinished
open import Logic
open import Type
open import Structure.Relator
open import Structure.Setoid
module Geometry.HilbertAxioms
{โโ โโ โโโ โโโ โโโ โโโโ}
(Point : Type{โโ}) โฆ equiv-point : Equiv{โโโ}(Point) โฆ -- The type of points on a plane.
(Line : Type{โโ}) โฆ equiv-line : Equiv{โโโ}(Line) โฆ ... |
{-# OPTIONS --sized-types #-}
module GiveSize where
postulate Size : Set
{-# BUILTIN SIZE Size #-}
id : Size โ Size
id i = {!i!}
|
open import Formalization.PredicateLogic.Signature
module Formalization.PredicateLogic.Syntax.NegativeTranslations (๐ : Signature) where
open Signature(๐)
open import Data.ListSized
import Lvl
open import Formalization.PredicateLogic.Syntax (๐)
open import Functional using (_โ_ ; _โโ_ ; swap)
open import Nume... |
module Lawvere where
open import Library
open import Data.Sum
open import Categories
open import Categories.Sets
open import Categories.Initial
open import Categories.PushOuts
open import Categories.Products hiding (_ร_)
open import Categories.CoProducts
open import Categories.Terminal
open import Functors
open impor... |
module UniDB.Subst.Core where
open import UniDB.Spec public
open import UniDB.Morph.Unit
record Ap (T X : STX) : Setโ where
field
ap : {ฮ : MOR} {{lkTฮ : Lk T ฮ}} {{upฮ : Up ฮ}}
{ฮณโ ฮณโ : Dom} (ฮพ : ฮ ฮณโ ฮณโ) (x : X ฮณโ) โ X ฮณโ
open Ap {{...}} public
record ApVr (T : STX) {{vrT : Vr T}} {{apTT : Ap T T}} : ... |
{-# OPTIONS --allow-unsolved-metas #-}
infixr 6 _โท_
data List (A : Set) : Set where
[] : List A
_โท_ : A -> List A -> List A
postulate
Bool : Set
t : Bool
long : List Bool
long =
t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท
t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท t โท ... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.ZCohomology.Groups.Unit where
open import Cubical.ZCohomology.Base
open import Cubical.ZCohomology.Properties
open import Cubical.HITs.Sn
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Iso... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.AbGroup.Instances.FreeAbGroup where
open import Cubical.Foundations.Prelude
open import Cubical.HITs.FreeAbGroup
open import Cubical.Algebra.AbGroup
private variable
โ : Level
module _ {A : Type โ} where
FAGAbGroup : AbGroup โ
FAGAbGroup = makeAbGroup {G = FreeAbG... |
module Data.Collection where
open import Data.Collection.Core public
open import Data.Collection.Equivalence
open import Data.Collection.Inclusion
open import Relation.Nullary
--------------------------------------------------------------------------------
-- Singleton
-----------------------------------------------... |
module Numeral.Natural.Oper.Proofs.Rewrite where
import Lvl
open import Numeral.Natural
open import Numeral.Natural.Oper
open import Numeral.Natural.Induction
open import Relator.Equals
open import Relator.Equals.Proofs
open import Syntax.Function
private variable x y : โ
[+]-baseโ : ๐ + y โก y
[+]-baseโ {x} = โ-eli... |
module Numeral.PositiveInteger where
import Lvl
open import Syntax.Number
open import Data.Boolean.Stmt
open import Functional
open import Numeral.Natural.Oper.Comparisons
open import Numeral.Natural as โ using (โ)
open import Type
data โโ : Type{Lvl.๐} where
๐ : โโ
๐ : โโ โ โโ
โโ-to-โ : โโ โ โ
โโ-to-โ (๐) ... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import Agda.Primitive using (Level; lzero; lsuc; _โ_)
open import LogicalFormulae
module Functions.Definition where
Rel : {a b : _} โ Set a โ Set (a โ lsuc b)
Rel {a} {b} A = A โ A โ Set b
_โ_ : {a b c : _} {A : Set a} {B : Set b} {C : Set c} โ (f : B โ C) โ ... |
-- This is a selection of useful function
-- from the standard library that we tend to use a lot.
module Prelude where
open import Data.Nat
hiding (_โ_)
public
open import Level
renaming (suc to lsuc; zero to โ0)
public
open import Relation.Binary.PropositionalEquality
renaming ([_] to Reve... |
{-# OPTIONS --allow-unsolved-metas #-}
open import Agda.Primitive using (Level)
module Tutorials.Monday where
-- Two dashes to comment out the rest of the line
{-
Opening {-
and closing -}
for a multi-line comment
-}
-- In Agda all the tokens are tokenised using whitespace (with the exception of parentheses a... |
module map-Tree where
-- ใใชใผ
data Tree (A B : Set) : Set where
leaf : A โ Tree A B
node : Tree A B โ B โ Tree A B โ Tree A B
-- ใใชใผใฎmap
map-Tree : โ {A B C D : Set} โ (A โ C) โ (B โ D) โ Tree A B โ Tree C D
map-Tree f g (leaf a) = leaf (f a)
map-Tree f g (node treeหก b treeสณ) = node (map-Tree f g treeหก... |
{-# OPTIONS --without-K #-}
open import Base
open import Homotopy.PullbackDef
module Homotopy.PullbackIsPullback {i} (d : pullback-diag i) where
open pullback-diag d
import Homotopy.PullbackUP as PullbackUP
open PullbackUP d (ฮป _ โ unit)
pullback-cone : cone (pullback d)
pullback-cone = (pullback.a d , pullback.b ... |
module GUIgeneric.GUIExampleLib where
open import GUIgeneric.Prelude hiding (addButton)
open import GUIgeneric.GUIDefinitions renaming (add to add'; add' to add)
open import GUIgeneric.GUI
executeChangeGui : โ{i} โ (fr : FFIFrame)(mvar : MVar StateAndGuiObj)
(mvarFFI : MVar StateAndFFI... |
import cedille-options
open import general-util
module spans (options : cedille-options.options) {mF : Set โ Set} {{_ : monad mF}} where
open import lib
open import functions
open import cedille-types
open import constants
open import conversion
open import ctxt
open import is-free
open import syntax-util
open impor... |
module Issue2749-2 where
-- testing unicode lambda and arrow
id : {A : Set} -> A -> A
id = {!!}
-- testing unicode double braces
it : {A : Set} {{a : A}} โ A โ A
it = {!!}
data B : Set where
mkB : B โ B โ B
-- testing unicode suffixes
left : B โ B
left bโ = {!!}
open import Agda.Builtin.Equality
-- testing asci... |
open import Coinduction using ( โฏ_ )
open import Relation.Binary.PropositionalEquality using ( _โก_ ; refl ; sym ; cong ; subst )
open import System.IO.Transducers.Lazy using ( _โ_ ; inp ; out ; done ; โฆ_โง ; _โ_ )
open import System.IO.Transducers.Strict using ( Strict )
open import System.IO.Transducers.Session using (... |
module Text.Greek.SBLGNT.3John where
open import Data.List
open import Text.Greek.Bible
open import Text.Greek.Script
open import Text.Greek.Script.Unicode
ฮฮฉฮฮฮฮฮฅ-ฮ : List (Word)
ฮฮฉฮฮฮฮฮฅ-ฮ =
word (แฝ โท []) "3John.1.1"
โท word (ฯ โท ฯ โท ฮต โท ฯ โท ฮฒ โท ฯ โท ฯ โท ฮต โท ฯ โท ฮฟ โท ฯ โท []) "3John.1.1"
โท word (ฮ โท ฮฑ โท ฮ โท แฟณ โท ... |
module Dummy where
|
{-# OPTIONS --without-K --safe #-}
open import Algebra.Structures.Bundles.Field
open import Algebra.Linear.Structures.Bundles
module Algebra.Linear.Space.Hom
{k โ} (K : Field k โ)
{aโ โโ} (Vโ-space : VectorSpace K aโ โโ)
{aโ โโ} (Vโ-space : VectorSpace K aโ โโ)
where
open import Relation.Binary
open import L... |
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Functions.Definition
open import Groups.Groups
open import Groups.Definition
open import Rings.Definition
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Naturals
open import Numbers.Naturals.Order
open import... |
module Common.Weakening where
-- open import Agda.Primitive
import Data.List as List
open import Data.List.Base
open import Data.List.Membership.Propositional
open import Data.List.Relation.Unary.All as All
open import Data.List.Prefix
open import Function
open import Level
{-
The following `Weakenable` record defi... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Foundations.Pointed where
open import Cubical.Foundations.Pointed.Base public
open import Cubical.Foundations.Pointed.Properties public
open import Cubical.Foundations.Pointed.FunExt public
open import Cubical.Foundations.Pointed.Homotopy public
open i... |
postulate
A B : Set
f : A โ B
data D : B โ Set where
c : {n : A} โ D (f n)
test : (x : B) โ D x โ Set
test n c = {!!}
test2 : Set
test2 =
let X = A in
let X = B in
{!!}
|
module ProcessRun where
open import Data.Bool
open import Data.List
open import Data.Maybe
open import Data.Product
open import Relation.Binary.PropositionalEquality
open import Typing
open import ProcessSyntax
open import Channel
open import Global
open import Values
open import Session
open import Schedule
-- au... |
{-# OPTIONS --safe --warning=error --without-K --guardedness #-}
open import Agda.Primitive using (Level; lzero; lsuc; _โ_)
open import LogicalFormulae
open import Groups.Lemmas
open import Groups.Definition
open import Setoids.Orders.Total.Definition
open import Setoids.Setoids
open import Functions.Definition
open i... |
module Haskell.Prim.Eq where
open import Agda.Builtin.Nat as Nat hiding (_==_)
open import Agda.Builtin.Char
open import Agda.Builtin.Unit
open import Agda.Builtin.List
open import Haskell.Prim
open import Haskell.Prim.Bool
open import Haskell.Prim.Integer
open import Haskell.Prim.Int
open import Haskell.Prim.Word
o... |
-- 2017-05-11, Reported by Ulf
-- Implicit absurd matches should be treated in the same way as explicit ones
-- when it comes to being used/unused.
open import Agda.Builtin.Bool
open import Agda.Builtin.Equality
data โฅ : Set where
record โค : Set where
abort : (A : Set) {_ : โฅ} โ A
abort A {}
test : (x y : โฅ) โ abor... |
module logical_foundations.Naturals where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_โก_; refl)
open Eq.โก-Reasoning using (begin_; _โกโจโฉ_; _โ)
data โ : Set where
zero : โ
suc : โ โ โ
{-# BUILTIN NATURAL โ #-}
_+_ : โ โ โ โ โ
zero + n = n
suc m + n = suc (m + n)
{-# BUILTIN NATPLUS _+_ #... |
open import HoTT
open import cohomology.FunctionOver
module cohomology.Exactness where
module _ {i j k} {G : Group i} {H : Group j} {K : Group k}
(ฯ : G โแดณ H) (ฯ : H โแดณ K) where
private
module G = Group G
module H = Group H
module K = Group K
module ฯ = GroupHom ฯ
module ฯ = GroupHom ฯ
{- ... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.CommRing.Integers where
open import Cubical.Foundations.Prelude
open import Cubical.Algebra.CommRing
module _ where
open import Cubical.HITs.Ints.BiInvInt
renaming (
_+_ to _+โค_;
-_ to _-โค_;
+-assoc to +โค-assoc;
... |
-- Andreas, 2018-10-18, issue #3289 reported by Ulf
--
-- For postfix projections, we have no hiding info
-- for the eliminated record value.
-- Thus, contrary to the prefix case, it cannot be
-- taken into account (e.g. for projection disambiguation).
open import Agda.Builtin.Nat
record R : Set where
field
p ... |
-- Test that postponing tactic applications work properly
module _ where
open import Common.Prelude
open import Common.Reflection
data Zero : Set where
zero : Zero
macro
fill : Term โ Tactic
fill = give
_asTypeOf_ : {A : Set} โ A โ A โ A
x asTypeOf _ = x
-- Requires postponing the macro evaluation until the... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Surjections
------------------------------------------------------------------------
module Function.Surjection where
open import Level
open import Function.Equality as F
using (_โถ_) renaming (_โ_ to _โชโโซ_)
o... |
{-# OPTIONS --no-import-sorts --prop #-}
open import Agda.Primitive renaming (Set to Set; Prop to Setโ)
test : Setโ
test = Set
|
{-
Index a structure T a positive structure S: X โฆ S X โ T X
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Structures.Relational.Function where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Equiv
open import Cubical.Foundati... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.cubical.Square
open import lib.types.Group
open import lib.types.EilenbergMacLane1.Core
open import lib.types.EilenbergMacLane1.DoubleElim
module lib.types.EilenbergMacLane1.DoublePathElim where
private
emloop-emloop-eq-helper : โ {i j... |
module Progress where
open import Data.Bool
open import Data.Empty
open import Data.Maybe hiding (Any ; All)
open import Data.Nat
open import Data.List
open import Data.List.All
open import Data.List.Any
open import Data.Product
open import Data.Unit
open import Relation.Nullary
open import Relation.Binary.Propositio... |
{-# OPTIONS --safe #-}
module Definition.Typed.Consequences.RelevanceUnicity where
open import Definition.Untyped hiding (Uโขโ; Uโขฮ ; Uโขne; โโขฮ ; โโขne; ฮ โขne; UโขEmpty; โโขEmpty; Emptyโขฮ ; Emptyโขne)
open import Definition.Untyped.Properties using (subst-Univ-either)
open import Definition.Typed
open import Definition.Typed.... |
------------------------------------------------------------------------
-- Breadth-first labelling of trees
------------------------------------------------------------------------
-- This module just defines breadth-first labelling. For a full
-- development including a specification and proof, see BreadthFirst.
mo... |
module System.IO.Transducers.Properties where
open import System.IO.Transducers.Properties.Category public
open import System.IO.Transducers.Properties.Monoidal public
open import System.IO.Transducers.Properties.LaxBraided public
open import System.IO.Transducers.Properties.Equivalences public
|
{-# OPTIONS --without-K --rewriting #-}
module lib.types.EilenbergMacLane1 where
open import lib.types.EilenbergMacLane1.Core public
open import lib.types.EilenbergMacLane1.Recursion public
open import lib.types.EilenbergMacLane1.DoubleElim public
open import lib.types.EilenbergMacLane1.DoublePathElim public
open imp... |
{-# OPTIONS --without-K #-}
module sets.list.core where
open import sum
import sets.vec.core as V
open import sets.nat.core
List : โ {i} โ Set i โ Set i
List A = ฮฃ โ (V.Vec A)
module _ {i}{A : Set i} where
vec-to-list : โ {n} โ V.Vec A n โ List A
vec-to-list {n} xs = n , xs
[] : List A
[] = 0 , V.[]
infi... |
-- Andreas, 2013-04-06
-- Interaction point buried in postponed type checking problem
module Issue1083 where
data Bool : Set where true false : Bool
T : Bool โ Set
T true = Bool โ Bool
T false = Bool
postulate
f : {x : Bool} โ T x
test : (x : Bool) โ T x
test true = f {!!}
test false = {!!}
-- Constraints show... |
-- Andreas, 2020-05-16, issue #4649
-- Allow --safe flag in -I mode
{-# OPTIONS --safe #-}
data Unit : Set where
unit : Unit
test : Unit
test = {!!}
|
data N : Set = zero | suc (n:N)
data B : Set = true | false
data False : Set =
data True : Set = tt
F : B -> Set
F true = N
F false = B
G : (x:B) -> F x -> Set
G false _ = N
G true zero = B
G true (suc n) = N
(==) : B -> B -> Set
true == true = True
false == false = True
_ == _ = False
data Equal (x,y:B... |
open import Oscar.Prelude
module Oscar.Data.Constraint where
data Constraint {๐} {๐ : ร ๐} (๐ถ : ๐) : รโ where
instance โ
: Constraint ๐ถ
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- Reverse view
------------------------------------------------------------------------
module Data.List.Reverse where
open import Data.List
open import Data.Nat
import Data.Nat.Properties as Nat
open import Indu... |
-- Andreas, 2013-02-21 issue seems to have been fixed along with issue 796
-- {-# OPTIONS -v tc.decl:10 #-}
module Issue4 where
open import Common.Equality
abstract
abstract -- a second abstract seems to have no effect
T : Set -> Set
T A = A
see-through : โ {A} โ T A โก A
see-through = refl
data Ok... |
-- It is recommended to use Cubical.Algebra.CommRing.Instances.Int
-- instead of this file.
{-# OPTIONS --safe #-}
module Cubical.Algebra.AbGroup.Instances.DiffInt where
open import Cubical.Foundations.Prelude
open import Cubical.HITs.SetQuotients
open import Cubical.Algebra.AbGroup.Base
open import Cubical.Data.Int... |
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.Lambda {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped as U hiding (wk)
open import Definition.Untyped.Properties
open import Definition.Typed
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.