text stringlengths 4 690k |
|---|
module Data.Maybe where
data Maybe (a : Set) : Set where
nothing : Maybe a
just : a -> Maybe a
|
{-# OPTIONS --cubical-compatible --rewriting --confluence-check #-}
module Issue1719.Common where
ofType : ∀ {i} (A : Set i) → A → A
ofType A x = x
syntax ofType A x = x :> A
infixr 3 ofType
postulate
_↦_ : ∀ {i} {A : Set i} → A → A → Set i
idr : ∀ {i} {A : Set i} {a : A} → a ↦ a
{-# BUILTIN REWRITE _↦_ #-}
i... |
module A where
import B
import C
|
{-# OPTIONS --without-K #-}
module Util.HoTT.Univalence where
open import Util.HoTT.Univalence.Axiom public
open import Util.HoTT.Univalence.Beta public
open import Util.HoTT.Univalence.ContrFormulation public using
( UnivalenceContr ; UnivalenceProp ; univalenceContr ; univalenceProp )
open import Util.HoTT.Univale... |
module plfa.part1.Induction where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl; cong; sym)
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_; step-≡; _∎)
open import Data.Nat using (ℕ; zero; suc; _+_; _*_; _∸_)
_ : (3 + 4) + 5 ≡ 3 + (4 + 5)
_ =
begin
(3 + 4) + 5
≡⟨⟩
7 + 5
≡⟨⟩
1... |
------------------------------------------------------------------------
-- Specifications of output-restricted deques (single-ended queues
-- with cons)
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open import Equality
module Queue {c⁺} (eq : ∀ {a p} → ... |
-- Andreas, 2017-12-04, issue #2862, reported by m0davis
-- Regression in development version 2.5.4
-- Scope checker allowed definition in different module than signature
-- {-# OPTIONS -v scope.data.def:30 #-}
open import Agda.Builtin.Equality
data N : Set
module Z where
data N where -- should be rejected sinc... |
module Acc where
data Acc ( A : Set ) ( Lt : A -> A -> Set) : A -> Set where
acc : ( b : A )
-> ( ( a : A ) -> Lt a b -> Acc A Lt a )
-> ( Acc A Lt b )
data Nat : Set where
zero : Nat
succ : Nat -> Nat
data Lt : Nat -> Nat -> Set where
ltzero : ( x : Nat ) -> Lt zero (succ x)
ltsucc... |
module Binders.Var where
data Var (a b : Set) : Set where
Free : a -> Var a b
Bound : b -> Var a b
|
module LearnYouAgda where
data ℕ : Set where
zero : ℕ
-- one : ℕ
suc : ℕ -> ℕ
-- define arithmetic operations
_+_ : ℕ → ℕ → ℕ
zero + zero = zero
zero + n = n
(suc n) + n′ = suc (n + n′)
|
{-# OPTIONS --without-K #-}
open import Base
open import Homotopy.TruncatedHIT
open import Integers
module Algebra.FreeGroupProps {i} (A : Set i) ⦃ p : is-set A ⦄ where
import Algebra.FreeGroup
open Algebra.FreeGroup A
abstract
freegroup-is-set : is-set freegroup
freegroup-is-set =
spheres-filled-is-truncat... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.NType2
open import lib.types.Modality
open import lib.types.Truncation
module lib.modalities.Truncation where
Trunc-modality : ∀ {i} n → Modality i
Trunc-modality n = record {
is-local = has-level n;
is-local-is-prop = has-level-is-pr... |
{-# OPTIONS --without-K --safe #-}
open import Categories.Bicategory using (Bicategory)
-- A Pseudofunctor is a homomorphism of Bicategories
-- Follow Bénabou's definition, which is basically that of a Functor
-- Note that what is in nLab is an "exploded" version of the simpler version below
module Categories.Pseud... |
{-# OPTIONS --allow-unsolved-metas --universe-polymorphism #-}
module Issue203 where
postulate
Level : Set
zero : Level
suc : Level → Level
max : Level → Level → Level
{-# BUILTIN LEVEL Level #-}
{-# BUILTIN LEVELZERO zero #-}
{-# BUILTIN LEVELSUC suc #-}
{-# BUILTIN LEVELMAX max #-}
-- Should work but giv... |
module Test where
-- To compile code: stack exec -- agda Test.agda -c
-- or: agda Test.agda -c --ghc-flag=-dynamic
open import IO
-- All of these are not necessary but they help to reduce clutter when looking
-- at the types of the different things in the code
import Agda.Builtin.List as List
open import Agda.Builtin... |
{-# OPTIONS --without-K --safe #-}
module TypeTheory.HoTT.Function.Properties where
-- agda-stdlib
open import Axiom.Extensionality.Propositional
open import Level
-- agda-misc
open import TypeTheory.HoTT.Base
private
variable
a b : Level
A : Set a
B : Set b
module _ {a b} {A : Set a} {B : Set b} whe... |
{-# OPTIONS --rewriting --without-K #-}
open import Agda.Primitive
open import Prelude
open import GSeTT.Syntax
open import GSeTT.Rules
{- Type theory for globular sets -}
module GSeTT.Uniqueness-Derivations where
has-all-paths-∈ : ∀ {Γ x A} → Γ ⊢C → has-all-paths (x # A ∈ Γ)
has-all-paths-∈ {Γ :: (y , B)} {x} {... |
import SOAS.Families.Core
-- Combinators for context maps
module SOAS.ContextMaps.Combinators {T : Set}
(open SOAS.Families.Core {T})
(𝒳 : Familyₛ) where
open import SOAS.Common
open import SOAS.Context {T}
open import SOAS.Sorting
open import SOAS.Variable
open import SOAS.Families.Isomorphism
open import SOA... |
{-
Constant structure: _ ↦ A
-}
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Structures.Constant where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.SIP
private
variable
ℓ ℓ' : Level
-- Structured isomorphisms
module _ (A ... |
record R : Set₁ where
field
_! : Set → Set
open R
F : Set → Set
F ! = !
|
open import MJ.Types
open import MJ.Classtable
module MJ.Syntax {c}(Σ : Classtable c) where
open import MJ.Syntax.Typed Σ public
|
{-# OPTIONS --without-K --safe #-}
module Data.Sigma.Base where
open import Agda.Builtin.Sigma
using (Σ; _,_; fst; snd)
public
open import Level
infixr 4.5 ∃-syntax
∃-syntax : ∀ {a b} {A : Type a} (B : A → Type b) → Type (a ℓ⊔ b)
∃-syntax {A = A} = Σ A
syntax ∃-syntax (λ x → e) = ∃ x × e
infixr 4.5 Σ⦂-syntax
Σ... |
module Open1 where
module M where
data ⊤
: Set
where
tt
: ⊤
module N where
open M
v
: ⊤
v
= tt
open M
open N
module O where
w
: ⊤
w
= tt
x
: ⊤
x
= tt
module P where
open O
using (w)
renaming (x to x')
y
: ⊤
y
= w
open P
modul... |
module Issue561 where
open import Common.Prelude
open import Common.MAlonzo using ()
-- if I do not include this, I get compilation errors
-- MAlonzo/Code/Common/Prelude.hs:8:7:
-- Not in scope: type constructor or class `Common.FFI.Nat'
primitive
primIsDigit : Char → Bool
postulate
return : ∀ {A} → ... |
------------------------------------------------------------------------------
-- Testing the --schematic-functions option
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polym... |
module Problem2 where
open import Problem1
infixr 40 _►_
data Vec (A : Set) : Nat -> Set where
ε : Vec A zero
_►_ : {n : Nat} -> A -> Vec A n -> Vec A (suc n)
-- 2.1
vec : {A : Set}{n : Nat} -> A -> Vec A n
vec {n = zero } x = ε
vec {n = suc n} x = x ► vec x
-- 2.2
infixl 80 _<*>_
_<*>_ : {A B : Set}{n :... |
module Issue790 where
open import Common.Level renaming (lzero to zero; lsuc to suc)
open import Common.Prelude using (Bool; true; false; zero; suc) renaming (Nat to ℕ)
even? : ℕ -> Bool
even? 0 = true
even? (suc (suc n)) = even? n
even? _ = false
-- Name overlap between Level's suc and Nat... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Natural number division
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.Nat.DivMod where
open import Agda.Builtin.Nat using (div-helper; ... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Pointwise equality over lists using propositional equality
------------------------------------------------------------------------
-- Note think carefully about using this module as pointwise
-- propositional e... |
module Data.Union where
open import Data.List using (List; _∷_; [_]; [])
open import Data.List.Relation.Unary.Any using (here; there; _─_)
open import Data.List.Membership.Propositional using (_∈_)
open import Data.Maybe using (Maybe; just; nothing; _>>=_)
open import Level using (Level; _⊔_)
open import Function u... |
open import FRP.JS.Bool using ( Bool ; not )
open import FRP.JS.Maybe using ( Maybe ; just ; nothing ) renaming ( _≟[_]_ to _≟?[_]_ )
open import FRP.JS.Nat using ( ℕ ; zero ; suc ; _≟_ ; _<_ )
open import FRP.JS.Object using ( Object ; IObject ; [] ; _↦_∷_ ; object ; ⟪⟫ ; ⟪_ ; _↦_,_ ; _↦_⟫ ; _≟[_]_ ; _⊆[_]_ ; lookup ... |
module container.w.core where
open import level
open import sum
open import equality
open import function.extensionality
open import function.isomorphism
open import function.isomorphism.properties
open import function.overloading
open import sets.empty
open import sets.nat.core using (suc)
open import sets.unit
open ... |
{-# OPTIONS --without-K --safe #-}
-- This module defines D<: normal form, proves its transitivity and shows its
-- equivalence to the original D<:. It turns out that D<: normal form can be used to
-- prove undecidability.
module DsubEquivSimpler where
open import Data.List as List
open import Data.List.All as All
op... |
module imper-nouni where
--
-- TO-DOs
--
-- * change use of =string
-- * prove that =string can't be both tt and ff
-- * prove reverse theorems for passes/fails/chck
-- * prove semantic equivalence for execs and execsTo
-- + this would be s-thm and s-det
open import lib
open import eq-reas-nouni
_=nat_ = _=ℕ_
_-... |
{-# OPTIONS --exact-split #-}
postulate
I : Set
P : I → Set
record ∃ (P : I → Set) : Set where
constructor _,_
field
fst : I
snd : P fst
open ∃
data S : ∃ P → Set where
s : (i : I) (x : P i) → S (i , x)
Foo : (p : ∃ P) → S p → Set
Foo p (s .(fst p) .(snd p)) = I
|
module hello-world where
open import IO
open import Level
main = run {0ℓ} (putStrLn "Hello, World!")
|
-- Andreas, 2011-05-10
-- {-# OPTIONS -v tc.term.con:20 -v tc.meta:20 #-}
module Issue380 where
data _==_ {A : Set}(a : A) : A -> Set where
refl : a == a
record Sigma (A : Set)(B : A -> Set) : Set where
constructor _,_
field
fst : A
snd : B fst
open Sigma public
testProj : {A : Set}{B : A -> Set}(y z :... |
module _ where
open import Common.Bool
private
unused = true
used = true
private
module Private where
not-in-scope = true
in-scope = used
|
record R : Set₁ where
field
⟨_+_⟩ : Set
open R
-- Name parts coming from projections can not be used as part of the
-- defined name.
+ : Set → Set
+ A = A
|
{-# OPTIONS --without-K #-}
open import HoTT
open import homotopy.elims.Lemmas
open import homotopy.elims.CofPushoutSection
module homotopy.elims.SuspSmash {i j k} {X : Ptd i} {Y : Ptd j}
{P : Suspension (X ∧ Y) → Type k}
(north* : P north) (south* : P south)
(cod* : (s : fst X × fst Y) → north* == south* [ P ↓... |
-- {-# OPTIONS -v term:20 #-}
module Issue787 where
data ⊥ : Set where
data List (A : Set) : Set where
[] : List A
_∷_ : A → List A → List A
data Rat' {X : Set} : List (List X) → List X → Set where
cons : ∀{ss x xs} → Rat' ((x ∷ xs) ∷ ss) xs → Rat' ss (x ∷ xs)
bad : {X : Set} (xs : List X) (acc : List (List ... |
module Warshall
(X : Set)
((≤) : X -> X -> Prop)
-- and axioms...
where
id : {A:Set} -> A -> A
id x = x
(∘) : {A B C:Set} -> (B -> C) -> (A -> B) -> A -> C
f ∘ g = \x -> f (g x)
-- Natural numbers --------------------------------------------------------
data Nat : Set where
zero : Nat
suc : Nat -> N... |
module BTA4 where
-- specialize two-level typed terms to untyped lambda calculus
open import Data.Nat hiding (_<_)
open import Data.Bool
open import Data.Fin hiding (_≤_ ; pred; _+_)
open import Data.List
open import Data.Product
open import Function
open import Algebra.FunctionProperties using (Commutative; Identity... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Some defined operations (multiplication by natural number and
-- exponentiation)
------------------------------------------------------------------------
open import Algebra
module Algebra.Operations {s₁ s₂} (S... |
module New.Types where
open import Data.Integer public
open import Data.Product public hiding (map)
open import Data.Sum public hiding (map)
infixr 5 _⇒_
data Type : Set where
_⇒_ : (σ τ : Type) → Type
int : Type
pair : (σ τ : Type) → Type
sum : (σ τ : Type) → Type
⟦_⟧Type : Type → Set
⟦ σ ⇒ τ ⟧Type = ⟦ σ ⟧T... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.RingSolver.CommRingAsAlmostRing where
open import Cubical.Foundations.Prelude
open import Cubical.Algebra.CommRing.Base
open import Cubical.Algebra.RingSolver.AlmostRing
open import Cubical.Algebra.Semigroup
open import Cubical.Algebra.Monoid
op... |
{-# OPTIONS --cubical --safe #-}
module Yamanote where
open import Data.Fin
open import Data.List using (List; map) renaming (_∷_ to _L∷_; _++_ to _L++_; [] to L[])
open import Data.Maybe using (fromMaybe)
open import Data.Nat
open import Data.Product using (_×_; _,_; proj₁; proj₂)
open import Function using (_∘_)
op... |
module Examples.InfiniteBind where
open import ActorMonad
open import Prelude
Box : InboxShape
Box = []
binder : ∀ {i} → ∞ActorM i Box ⊤₁ [] (λ _ → [])
binder .force = binder ∞>> binder
|
{-# OPTIONS --cubical #-}
module Miscellaneous.LimNatural where
import Lvl
open import Numeral.Natural as ℕ using (ℕ)
open import Numeral.Sign as Sign using (−|+ ; −|0|+ ; ➖ ; ➕)
open import Type.Cubical
open import Type.Cubical.Path.Equality
open import Type
data ℕ∞ : Type{Lvl.𝟎} where
𝟎 : ℕ∞
𝐒 : ℕ∞ → ℕ... |
{-# OPTIONS --cubical #-}
open import Agda.Primitive.Cubical
open import Agda.Builtin.Cubical.Path
open import Agda.Builtin.Cubical.Id
reflPath : ∀ {ℓ} {A : Set ℓ} {x : A} → x ≡ x
reflPath {x = x} = λ i → x
reflId : ∀ {ℓ} {A : Set ℓ} {x : A} → Id x x
reflId {x = x} = conid i1 reflPath
Id-comp-Id : ∀ {ℓ ℓ'} {A : Set... |
module Issue246 where
module James where
data Nat : Set where
zero : Nat
suc : Nat -> Nat
data Zero : Set where
data One : Set where
void : One
propLEQ : Nat -> Nat -> Set
propLEQ zero _ = One
propLEQ (suc n) (suc m) = propLEQ n m
propLEQ (suc n) zero = Zero
data Fin : N... |
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module FOT.FOTC.Data.Conat.PropertiesI where
open import FOTC.Base
open import FOTC.Data.Conat
open import FOTC.Data.Conat.PropertiesI
open import... |
{-# OPTIONS --warning=ignore #-}
module Issue2596 where
{-# REWRITE #-}
|
module Pi-.NoRepeat where
open import Data.Empty
open import Data.Unit
open import Data.Sum
open import Data.Product
open import Relation.Binary.Core
open import Relation.Binary
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
open import Data.Nat
open import Data.Nat.Properties
open impor... |
{-# OPTIONS --cubical --no-import-sorts #-}
open import Cubical.Foundations.Everything renaming (_⁻¹ to _⁻¹ᵖ; assoc to ∙-assoc)
open import Function.Base using (_∋_; _$_)
open import Cubical.Data.Sigma renaming (_×_ to infixr 4 _×_)
open import Cubical.Data.Empty renaming (elim to ⊥-elim; ⊥ to ⊥⊥) -- `⊥` and `elim`
o... |
data ⊤ : Set where tt : ⊤
postulate
A : Set
B : A → Set
a : A
b : B a
G : ∀ x → B x → Set
postulate tt' : ⊤
poo : G a b
poo with tt | a
... | _ | _ = {!!}
|
{-# OPTIONS --universe-polymorphism #-}
-- {-# OPTIONS --verbose tc.rec:15 #-}
-- {-# OPTIONS --verbose tc.records.ifs:15 #-}
-- {-# OPTIONS --verbose tc.constr.findInScope:15 #-}
-- {-# OPTIONS --verbose tc.term.args.ifs:15 #-}
module 05-equality-std2 where
open import Relation.Binary
open import Data.Bool hiding (_... |
{-
This file contains:
- Natural functions from FreeGroupoid into FreeGroupoid
- Proofs that they induce equivalences
- Natural paths in Universe from FreeGroupoid to FreeGroupoid
- Proofs that these functions and paths respect the groupoid structure of FreeGroupoid
-}
{-# OPTIONS --safe #-}
module Cubical.HITs.Fre... |
------------------------------------------------------------------------------
-- ABP terms
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --witho... |
-- An implementation of Olivier Danvy's Type-Directed Partial Evaluation (POPL 1996)
-- for STLC with sum types using continuations in form of shift and reset.
--
-- The algorithm was originally for a two-level lambda-calculus.
-- Our use of Kripke semantics makes the effect of fresh variable generation explicit and f... |
data C : Set₁ where
c : Set → C
data D : Set where
d : D
F : C → {y : D} → C → Set₁
F z (c _) = G d
module M where
G : D → Set₁
G _ = Set
fail : Set
fail = M.G
|
{-# OPTIONS --without-K --rewriting #-}
open import HoTT renaming (pt to ⊙pt)
open import homotopy.Bouquet
open import homotopy.FinWedge
open import homotopy.LoopSpaceCircle
open import homotopy.SphereEndomorphism
open import groups.SphereEndomorphism
open import cw.CW
open import cw.FinCW
open import cw.WedgeOfCells
... |
-- The ATP pragma with the role <axiom> can be used with data constructors.
module ATPAxiomDataConstructors where
postulate
D : Set
zero : D
succ : D → D
data N : D → Set where
zN : N zero
sN : ∀ {n} → N n → N (succ n)
{-# ATP axiom zN #-}
|
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Relation.Binary.Construct.Never where
open import Cubical.Core.Everything
open import Cubical.Relation.Binary
open import Cubical.Relation.Binary.Construct.Constant
open import Cubical.Data.Empty.Polymorphic
-------------------------------------------... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Matrix where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Univalence
open import Cubical.Founda... |
module _ {A : Set} (P : A → Set) where
instance
postulate
forbidden : {x : A} → P x
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.Vec.Relation.Binary.Equality.Propositional directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
mod... |
{-# OPTIONS --without-K --safe #-}
-- Singleton type and its 'inverse'
module Singleton where
open import Data.Unit using (⊤; tt)
open import Data.Sum
open import Data.Product
open import Relation.Binary.PropositionalEquality
using (_≡_; refl; sym; trans; subst; cong ; cong₂ ; inspect ; [_])
-- open import Level
-... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Categories.Equivalence.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Sigma
open import Cubical.Categories.Category
open import Cubical.Categories.Functor
open import Cubical.Categories.NaturalTransformation
open impo... |
------------------------------------------------------------------------------
-- Properties of the Collatz function
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphis... |
{-# OPTIONS --sized-types #-}
module SNat where
open import Data.Nat hiding (_+_)
open import Size
data SNat : {ι : Size} → Set where
zero : {ι : Size}
→ SNat {↑ ι}
succ : {ι : Size}
→ SNat {ι}
→ SNat {↑ ι}
subtyping : {ι : Size} → SNat {ι} → SNat {↑ ι}... |
module nat-log-test where
open import eq
open import nat
open import nat-log
test : log-result 11 3
test = log 11 3 refl refl
exp-from-test : ℕ
exp-from-test with test
exp-from-test | pos-power e s p = e
exp-from-test | no-power p = 0
|
------------------------------------------------------------------------
-- The Agda standard library
--
-- The Thunk wrappers for sized codata, copredicates and corelations
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe --sized-types #-}
module Codata.Thunk wh... |
{-# OPTIONS --cubical #-}
module TranspComputing where
open import Agda.Builtin.Cubical.Path
open import Agda.Primitive.Cubical
open import Agda.Builtin.List
transpList : ∀ (φ : I) (A : Set) x xs → primTransp (λ _ → List A) φ (x ∷ xs) ≡ (primTransp (λ i → A) φ x ∷ primTransp (λ i → List A) φ xs)
transpList φ A x xs ... |
-- {-# OPTIONS -v interaction:50 #-}
module Issue841 where
postulate
D : Set
c : (A : Set) (B : Set1) → D
e : (A : Set) (B : Set1) (C : Set2) (X : Set3) → D
-- When the following is refined the goals end up being the wrong way
-- around.
bad : D
bad = {!c ?!}
-- I.e. bad ?3 ?2 instead of bad ?2 ?3.
-- Andreas... |
{-# OPTIONS --cubical-compatible #-}
module Common.Maybe where
data Maybe {a} (A : Set a) : Set a where
nothing : Maybe A
just : A → Maybe A
|
module Reduction where
open import Data.Sum
open import Library
open import Terms
open import Substitution
open import TermShape
open import SN
data βECxt (Γ : Cxt) : (Δ : Cxt) (a b : Ty) → Set where
appl : ∀ {a b} (u : Tm Γ a) → βECxt Γ Γ (a →̂ b) b
appr : ∀ {a b} (t : Tm Γ (a →̂ b)) → βECxt Γ Γ a ... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Relation.Binary.Base
open import Cubical.Core.Everything
module Cubical.Relation.Binary.Raw.Structures
{a ℓ} {A : Type a} -- The underlying type
(_<>_ : RawRel A ℓ) -- The relation
where
open import Cubical.Foundations.Prelude using (refl... |
module Algebra where
-- Core graph construction primitives
data Graph (A : Set) : Set where
ε : Graph A -- Empty graph
v : A -> Graph A -- Graph comprising a single vertex
_+_ : Graph A -> Graph A -> Graph A -- Overlay two graphs
_*_ : Graph A -> Graph A -> Gr... |
-- Andreas, 2014-01-10, reported by fredrik.forsberg
record ⊤ : Set where
record Σ (A : Set) (B : A → Set) : Set where
syntax Σ A (λ x → B) = Σ[ x ∈ A ] B
test : Set
test = {! Σ[ x ∈ ⊤ ] ?!}
-- Fredrik's report:
-- Using the darcs version of Agda from today 10 January,
-- if I load the file and give (or refine) ... |
module heap.libraryNat where
open import Data.Nat renaming (_⊔_ to _⊔n_; _≟_ to _≟ℕ_) hiding ( _<_ )
open import Data.Bool
open import Data.Fin hiding (pred)
open import Data.Unit
open import Data.Empty
open import Function
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
{-
--- WARNING ... |
{-# OPTIONS --cubical --no-import-sorts #-}
module Number.Instances.QuoIntFromInt where
open import Agda.Primitive renaming (_⊔_ to ℓ-max; lsuc to ℓ-suc; lzero to ℓ-zero)
open import Cubical.Foundations.Everything hiding (⋆) renaming (_⁻¹ to _⁻¹ᵖ; assoc to ∙-assoc)
open import Cubical.Foundations.Logic renaming (inl ... |
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Nat
open import lib.types.Group
open import lib.types.TLevel
module lib.types.Int where
data ℤ : Type₀ where
pos : (n : ℕ) → ℤ
negsucc : (n : ℕ) → ℤ
Int = ℤ
{-# BUILTIN INTEGER Int #-}
{-# BUILTIN INTEGERPOS pos #-}
{-# BUILTIN INTEGERNEG... |
-- Andreas, 2016-11-03, issue #2291 reported by Aerate
test = let {{_}} = _ in _
-- WAS: Internal error
-- NOW: Could not parse the left-hand side {{_}}
|
module Issue4130 where
module Foo where
data D : Set where
con : D
module Bar (S : Set) where
open Foo public using (con)
open Bar using (con)
open Foo using (D; con)
data B : Set where
tt : B
ff : B
module _ (S : Set) where
open Bar S
f : D -> B
-- 'con' is not ambiguous, because although 'con' ... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.Group.Morphism where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Algebra
open import Cubical.Algebra.Monoid.Morphism
open import Cubical.Algebra.P... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.Algebra.RingSolver.CommRingExamples where
open import Cubical.Foundations.Prelude
open import Cubical.Data.FinData
open import Cubical.Data.Nat using (ℕ)
open import Cubical.Data.Vec.Base
open import Cubical.Algebra.CommRing
open import Cubical.Algebr... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.AbGroup.Instances.DirectSumFun where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat
open import Cubical.Algebra.AbGroup
open import Cubical.Algebra.DirectSum.DirectSumFun.Base
open import Cubical.Algebra.DirectSum.DirectSumFun.Properties
private va... |
{-# OPTIONS --cubical --safe #-}
module Data.Tree.Rose where
open import Prelude
open import Data.List
mutual
Forest : Type a → Type a
Forest A = List (Tree A)
infixr 5 _&_
record Tree {a} (A : Type a) : Type a where
inductive
constructor _&_
field
root : A
children : Forest A
open ... |
{-# OPTIONS --cubical #-}
module Demos.Printf where
open import Data.List
open import Data.String
open import Prelude
open import Data.Nat.Show
data Fstr : Type where
[] : Fstr
%s_ : Fstr → Fstr
%i_ : Fstr → Fstr
_∷_ : Char → Fstr → Fstr
parse : String → Fstr
parse = go ∘ unpack
where
go : List Char → F... |
{-# OPTIONS --cubical-compatible #-}
-- Andreas, 2020-02-07, instances of #906 needing --cubical-compatible to throw
-- off the termination checker.
module Issue906WithoutK where
module Issue3081 where
postulate
X : Set
P : (x : X) → Set
any : {X : Set} → X
record W : Set where
field
x : ... |
{-# OPTIONS --warning=error --safe --without-K #-}
open import LogicalFormulae
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Functions.Definition
open import Setoids.Setoids
open import Setoids.Subset
open import Graphs.Definition
module Graphs.Bipartite where
Bipartite : {a b : _} {c : _} {... |
module Typing where
import IO.Primitive as Prim
--open import Data.Unit
open import ParseTree
open import Data.Nat
open import Data.List
open import Data.String
open import Data.Unit
{-# FOREIGN GHC
import InteractWithAgda
#-}
postulate getTypes : List ParseTree -> ℕ -> List Expr -> String -> Prim.IO (List Expr)
{-#... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.types.TLevel
open import lib.types.Pi
open import lib.types.Sigma
open import lib.NType2
module lib.types.Truncation where
module _ {i} where
postulate -- HIT
Trunc : (n : ℕ₋₂) (A : Type i) → Type i
[_] : {n : ℕ₋₂} {A : Type i... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.HSpace renaming (HSpaceStructure to HSS)
open import homotopy.Pi2HSusp
open import homotopy.WedgeExtension
open import lib.types.TwoSemiCategory
open import lib.two-semi-categories.FundamentalCategory
module homotopy.Pi2HSuspCompose {i} {X ... |
module Basics where
_%_ : {A B : Set}{C : B -> Set}
(f : (x : B) -> C x)(g : A -> B)(x : A) -> C (g x)
f % g = \x -> f (g x)
-- Logic
data False : Set where
record True : Set where
tt : True
tt = _
¬_ : Set -> Set
¬ A = A -> False
record ∃ {A : Set}(P : A -> Set) : Set where
field
witness : A
... |
module Cryptol where
open import Bool
open import Nat
open import Eq
postulate
Int : Set
Float : Set
Char : Set
String : Set
{-# BUILTIN INTEGER Int #-}
{-# BUILTIN FLOAT Float #-}
{-# BUILTIN CHAR Char #-}
{-# BUILTIN STRING String #-}
data List (A : Set) : Set where
Nil : List A
Co... |
{-# 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.Actions.Definition
open import Sets.EquivalenceRelations
module Groups.Actions.Orbit where
data Orbit {a b c d : _} {A : Set a} {B... |
{-# OPTIONS --safe --experimental-lossy-unification #-}
module Cubical.Algebra.Polynomials.Multivariate.Properties where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat renaming(_+_ to _+n_; _·_ to _·n_)
open import Cubical.Data.Vec
open import Cubical.Data.Vec.OperationsNat
open import Cubical.... |
module AKS.Binary where
open import AKS.Binary.Base public
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.