text stringlengths 4 690k |
|---|
{-# POLARITY F #-}
|
module Imports.Issue1913-M where
data D : Set where
d : D
|
{- 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.Prelude
open import LibraBFT.Base.PKCS
open import LibraBF... |
module Vehicle.Data.Tensor where
open import Level using (Level)
open import Data.Empty.Polymorphic using (⊥)
open import Data.Nat.Base using (ℕ; zero; suc)
open import Data.List.Base using (List; []; _∷_)
open import Data.Vec.Functional using (Vector)
private
variable
a : Level
A : Set a
n : ℕ
Tensor... |
postulate
X A : Set
module Foo {{x : X}} where
postulate
B C : Set
foo : A → B → C → Set
module Bar {{x : X}} where
open Foo
postulate
-- The following fails to infer the instance argument if we do not either:
-- * apply {{x}} explicitly to foo
-- * apply {{x}} explicitly when openi... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.WedgeExtension
import homotopy.SuspAdjointLoop as SAL
module homotopy.Freudenthal where
{- lemma (move this where?) -}
private
move1-left-on-left : ∀ {i} {A : Type i} {x y : A} (p : x == y) (q : x == y)
→ ((! q) ∙ p == idp → p == q)
... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- This module is DEPRECATED. Please use
-- Data.List.Relation.Binary.Equality.Setoid directly.
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
open impo... |
{-# OPTIONS --rewriting #-}
open import Agda.Builtin.Equality
open import Agda.Builtin.Equality.Rewrite
data ⊥ : Set where
postulate
T : Set
t0 : T
t1 : T
postulate
foo : ⊥ → t0 ≡ t1
{-# REWRITE foo #-}
test : t0 ≡ t1
test = refl
|
open import Common.Prelude
open import Common.Reflection
data D (A : Set) : Nat → Set where
d : ∀ {n} → A → D A n
term : Term
term = con (quote d) (hArg (def (quote Nat) []) ∷ vArg (con (quote zero) []) ∷ [])
-- There was a bug where extra implicit arguments were inserted for the parameters, resulting in
-- the u... |
{-# OPTIONS --cubical --safe #-}
module Data.Empty.Base where
open import Cubical.Data.Empty using (⊥; ⊥-elim; isProp⊥) public
open import Level
infix 4.5 ¬_
¬_ : Type a → Type a
¬ A = A → ⊥
|
-- Andreas, 2016-06-20
-- Issue #1653 reported by Jesper
-- Fixed by Ulf's AIM XXIII code sprint "instantiating module parameters"
open import Common.Equality
module _ (A : Set₁) where
-- Matching on refl works with new instantiateable module parameters.
test : A ≡ Set → Set₁
test refl = A
-- Case splittin... |
open import Algebra.Apartness using (HeytingField)
module Data.Real.Abstract.Bundles
c ℓ₁ ℓ₂ r
where
open import Relation.Binary using (Rel)
open import Data.Real.Abstract.Structures
open import Level using (_⊔_; suc)
record OrderedHeytingField : Set (suc (c ⊔ ℓ₁ ⊔ ℓ₂ ⊔ r)) where
field
f : HeytingField c ℓ... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
module Cubical.HITs.Rationals.QuoQ.Properties where
open import Cubical.Foundations.Everything hiding (_⁻¹)
open import Cubical.HITs.Ints.QuoInt as ℤ using (ℤ; Sign; signed; pos; neg; posneg; sign)
open import Cubical.HITs.SetQuotients as SetQuotient using () renamin... |
{-# OPTIONS --copatterns #-}
module CopatternCheckingNYI where
record Stream (A : Set) : Set where
coinductive
field
head : A
tail : Stream A
open Stream
data Nat : Set where
zero : Nat
suc : Nat -> Nat
alternate : Stream Nat
( (head alternate)) = zero
(head (tail alternate)) = suc zero
(tail (t... |
{-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
open import Cubical.Relation.Binary.Raw
module Cubical.Relation.Binary.Reasoning.Base.Partial
{a ℓ} {A : Type a} (_∼_ : RawRel A ℓ) (transitive : Transitive _∼_)
where
open import Cubical.Foundations.Prelude
infix 4 _IsRelat... |
------------------------------------------------------------------------
-- Squashing
------------------------------------------------------------------------
{-# OPTIONS --erased-cubical --prop --safe #-}
import Equality.Path as P
module Squash {e⁺} (eq : ∀ {a p} → P.Equality-with-paths a p e⁺) where
open P.Derive... |
module RenamingAndSubstitution where
open import Library
open import Syntax
open ≡-Reasoning
infixr 4 _,_
------------------------------------------------------------------------
-- Renaming
------------------------------------------------------------------------
-- Renamings from Γ to Δ are snoc-lists of variables... |
module Issue127 where
data C : Set where
c : C
d : C
F : C → Set → Set
F c = λ A → A
F d = λ A → A
data D : C → Set where
d : (x : C) → F x (D x) → D x
-- .-< no longer
-- The following non-well-founded definition is / seemingly accepted by
-- Agda:
∞ : (x : C) ... |
module test.StringLiteral where
open import Type
open import Declarative
open import Builtin
open import Builtin.Constant.Type
open import Builtin.Constant.Term Ctx⋆ Kind * # _⊢⋆_ con size⋆
-- zerepoch/zerepoch-core/test/data/stringLiteral.plc
postulate str1 : ByteString
{-# FOREIGN GHC import qualified Data.ByteStr... |
------------------------------------------------------------------------
-- Simplification of parsers
------------------------------------------------------------------------
module TotalParserCombinators.Simplification where
open import Algebra
open import Codata.Musical.Notation
open import Data.List using (List; [... |
import MJ.Classtable.Core as Core
module MJ.Classtable.Membership {c}(Ct : Core.Classtable c) where
open Core c
open Classtable Ct
open import Prelude
open import Data.Star
open import Data.Product hiding (Σ)
open import Data.List
open import Data.List.Relation.Unary.Any
open import Data.List.Relation.Unary.Any.Pro... |
{-# OPTIONS --without-K --exact-split #-}
module rings-with-properties where
import rings
open rings public
--------------------------------------------------------------------------------
{- Commutative rings -}
is-commutative-Ring :
{ l : Level} → Ring l → UU l
is-commutative-Ring R =
(x y : type-Ring R) → I... |
-- Andreas, 2017-01-12, issue #2386
-- Should be rejected:
data Eq (A : Set) : (x y : A) → Set where
refl : (x y : A) → Eq A x y
{-# BUILTIN EQUALITY Eq #-}
-- Expected error:
-- Wrong type of constructor of BUILTIN EQUALITY
-- when checking the pragma BUILTIN EQUALITY Eq
|
------------------------------------------------------------------------
-- Reasoning about _⇔_
--
-- NOTE: we don’t use Relation.Binary.IsEquivalence here, since we’re reasoning
-- about a heterogeneous equivalence relation (i.e., the types of the operands
-- of _⇔_, which are themselves types, can be of different lev... |
{-# OPTIONS --rewriting #-}
module Properties.StrictMode where
import Agda.Builtin.Equality.Rewrite
open import Agda.Builtin.Equality using (_≡_; refl)
open import FFI.Data.Either using (Either; Left; Right; mapL; mapR; mapLR; swapLR; cond)
open import FFI.Data.Maybe using (Maybe; just; nothing)
open import Luau.Heap... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- An inductive definition of the heterogeneous suffix relation
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Data.List.Relation.Binary.Suffix.H... |
module PredicateName where
open import OscarPrelude
record PredicateName : Set
where
constructor ⟨_⟩
field
name : Nat
open PredicateName public
instance EqPredicateName : Eq PredicateName
Eq._==_ EqPredicateName _ = decEq₁ (cong name) ∘ (_≟_ on name $ _)
|
{-# OPTIONS --copatterns --sized-types #-}
open import Size
open import Function
open import Relation.Binary
open import Relation.Binary.PropositionalEquality as P
open ≡-Reasoning
open import Algebra.Structures using (IsCommutativeSemiring; IsCommutativeMonoid)
open import Data.Nat
open import Data.Nat.Properties u... |
module _ where
open import Agda.Builtin.Reflection
open import Agda.Builtin.Unit
open import Agda.Builtin.Nat
open import Agda.Builtin.Equality
variable
A : Set
super-tac : Term → TC ⊤
super-tac hole = unify hole (lit (nat 101))
solver : Nat → Term → TC ⊤
solver n hole = unify hole (lit (nat (n + 1)))
foo : {@(... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.NatSolver.HornerForms where
open import Cubical.Foundations.Prelude
open import Cubical.Data.Nat hiding (isZero)
open import Cubical.Data.FinData
open import Cubical.Data.Vec
open import Cubical.Data.Bool using (Bool; true; false; if_then_else_)
private
variable
ℓ ... |
module Basic.Compiler.SplitCode where
open import Basic.Compiler.Code
open import Basic.AST
open import Basic.BigStep
open import Utils.Monoid
open import Data.Vec hiding (_++_; [_]; _∷ʳ_)
open import Data.Bool renaming (if_then_else_ to ifBool_then_else_)
open import Data.Nat
open import Data.List hiding ([_])
open... |
-- Andreas, 2016-05-13 Issue 1973 reported by Nisse
-- Problems with parameters to overloaded projections
-- {-# OPTIONS -v tc.proj.amb:100 #-}
-- {-# OPTIONS -v tc.deftype:100 #-}
record R₁ : Set₁ where
field
f : Set
open R₁ public
postulate
F : ∀ {a} → Set a → Set a
module M (_ : Set₁) where
record R₂... |
module Category.Monad.Reader {i}{I : Set i} where
open import Category.Applicative.Indexed
open import Category.Monad
open import Category.Monad.Predicate
open import Relation.Unary
open import Relation.Unary.PredicateTransformer
open import Data.Product
open import Data.Unit
open import Function
open import Level
Re... |
-- Andreas, 2019-03-25, issue #3647, reported and bisected by nad.
-- Regression introduced in refactoring a78d7f54e447cadf039da81b50ff40c81aa93909.
{-# OPTIONS --allow-unsolved-metas #-}
-- {-# OPTIONS -v 90 #-}
postulate
A : Set
P : A → Set
Q : A → A → Set
Q _ x = P x
record R (P : A → Set) : Set where
fie... |
module Test where
open import IO using (run; putStrLn)
import IO.Primitive as Prim using (IO)
open import Data.Nat.Show as Nat using (show)
open import Data.Unit using (⊤)
open import Vector
main : Prim.IO ⊤
main = run (putStrLn (Nat.show (length gravity₂)))
|
module Logic.Linear where
open import Data.Nat using (ℕ; zero; suc)
open import Data.Fin using (Fin; zero; suc)
open import Data.Vec using (Vec; []; _∷_; _++_; map)
open import Data.Empty using (⊥)
-- Operator precedences.
infix 10 _^⊥ e?_ e!_
infixl 9 _⊗_ _&_
infixl 8 _⊕_ _⅋_
infixl 7 _⊸_
infixl 6 _≡_
-- Primitive ... |
{-# OPTIONS --without-K #-}
module well-typed-syntax-interpreter where
open import common public
open import well-typed-syntax
import well-typed-syntax-pre-interpreter
open import well-typed-syntax-eq-dec
max-level : Level
max-level = well-typed-syntax-pre-interpreter.max-level
Context⇓ : (Γ : Context) → Set (lsuc ma... |
{-# OPTIONS --without-K #-}
module ForAmr where
open import Level using (Level)
open import Relation.Nullary.Core
open import Data.Vec
using (Vec; tabulate; []; _∷_; lookup; allFin)
renaming (_++_ to _++V_; map to mapV; concat to concatV)
open import Data.Vec.Properties
using (lookup-++-≥; lookup∘t... |
------------------------------------------------------------------------
-- Parser indices
------------------------------------------------------------------------
module StructurallyRecursiveDescentParsing.Index where
open import Data.Bool
open import Relation.Nullary
open import Relation.Binary
open import Relation... |
module LF where
data Zero : Set where
record One : Set where
★ : One
★ = record {}
One-elim : (C : One -> Set) -> C ★ -> (a : One) -> C a
One-elim C h _ = h
One-elim₁ : (C : One -> Set1) -> C ★ -> (a : One) -> C a
One-elim₁ C h _ = h
-- data One' : Set1 where
-- ★' : One'
data Two : Set where
★₀ : Two
★₁ ... |
-- We show by allowing the reminder of integer division to be
-- negative, we can get more precise estimation of the rank of the
-- remainder: rank reminder ≤ (rank divisor) / 2.
{-# OPTIONS --without-K --safe #-}
module Integer.EucDomain2 where
-- --------------------------------------------------------------------... |
module _ where
data Nat : Set where
postulate
C Q : Set → Set
unQ : ∀ {A} → Q A → A
instance
CQ : C (Q Nat)
theC : {A : Set} {{_ : C A}} → A
-- We shouldn't solve this based on CQ being the only instance available for Q _.
dont-solve : _
dont-solve = unQ theC
|
{-
Holey congruence where congruence is limited to specific functions.
To use, open the module `AutoCong` with a database that maps function names to
congruences for those functions.
-}
module Holes.Cong.Limited where
open import Holes.Prelude
open import Holes.Term
open Holes.Prelude public using (quote-term)
p... |
open import Prelude
open import Nat
open import dynamics-core
open import contexts
open import contraction
open import weakening
open import exchange
open import lemmas-disjointness
open import binders-disjoint-checks
module lemmas-subst-ta where
-- this is what makes the binders-unique assumption below good enough:... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.LoopSpaceCircle
open import homotopy.PinSn
open import homotopy.SphereEndomorphism
open import homotopy.SuspAdjointLoop
open import groups.FromSusp
open import groups.Int
open import groups.Pointed
open import groups.SuspAdjointLoop
open imp... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Some derivable properties
------------------------------------------------------------------------
open import Algebra
module Algebra.Properties.AbelianGroup
{g₁ g₂} (G : AbelianGroup g₁ g₂) where
imp... |
{- 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.Consensus... |
module Issue2487 where
open import Issue2487.b
|
module nodcap.Base where
open import Data.Nat as ℕ using (ℕ; suc; zero)
open import Data.Pos as ℕ⁺ using (ℕ⁺; suc; _+_)
open import Data.List as L using (List; []; _∷_; _++_)
open import Data.List.Any using (Any; here; there)
open import Data.List.Any.Membership.Propositional using (_∈_; _∼[_]_; bag)
open import Data.... |
{-# OPTIONS --without-K #-}
open import lib.Basics
open import lib.types.Coproduct
open import lib.types.Sigma
{- Some miscellaneous lemmas for types with decidable equality. -}
module Util.DecEq where
×-has-dec-eq : {i j : ULevel} {A : Type i} {B : Type j} → (has-dec-eq A) → (has-dec-eq B) →
(has-dec-eq (A × B))
... |
module Category.Core where
open import Level
open import Data.Product
-- open import Relation.Binary as B using ()
open import Relation.Binary as B using ()
open import Relation.Binary.Indexed
open import Relation.Binary.PropositionalEquality as PropEq using (_≡_; refl)
record IsMorphism {𝒸 ℓ : Level}
... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Monads on indexed sets (predicates)
------------------------------------------------------------------------
-- Note that currently the monad laws are not included here.
{-# OPTIONS --without-K --safe #-}
modu... |
module CoinductiveCK where
open import Data.Product
open import Data.Sum
open import Data.Empty
open import Data.Nat
open import Data.Bool using (Bool; if_then_else_; true; false)
open import Relation.Binary.PropositionalEquality as PropEq
using (_≡_; _≢_; refl; sym; cong; subst)
open PropEq.≡-Reasoning
open import... |
{-# OPTIONS --safe #-}
module Cubical.HITs.Wedge.Base where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Pointed
open import Cubical.HITs.Pushout.Base
open import Cubical.Data.Sigma
open import Cubical.Data.Unit
_⋁_ : ∀ {ℓ ℓ'} → Pointed ℓ → Pointed ℓ' → Type (ℓ-max ℓ ℓ')
_⋁_ (A , ptA) (B , ... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.Group.Instances.Int where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Isomorphism
open import Cubical.Data.Int
renaming (_+_ to _+ℤ_ ; _-_ to _-ℤ_; -_ to -ℤ_ ; _·_ to _·ℤ_)
open import Cubical.Algebra.Group.Base
open import Cubical.Algebra.G... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Homogeneously-indexed binary relations
------------------------------------------------------------------------
-- The contents of this module should be accessed via
-- `Relation.Binary.Indexed.Homogeneous`.
{-... |
open import Agda.Primitive using (lzero; lsuc; _⊔_)
open import Agda.Builtin.Nat
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
open import Data.Fin
open import Relation.Binary
module SingleSorted.AlgebraicTheory where
open import SingleSorted.Context public
Arity : Set
Arity = Context
... |
module +-swap where
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; cong; sym)
open Eq.≡-Reasoning using (begin_; _≡⟨⟩_; step-≡; _∎)
open import Data.Nat using (ℕ; _+_)
open import Induction′ using (+-assoc; +-comm)
+-swap : ∀ (m n p : ℕ) → m + (n + p) ≡ n + (m + p)
+-swap m n p =
begin
... |
------------------------------------------------------------------------------
-- Testing nested axioms
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPT... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Instance.Cartesians where
open import Level
open import Categories.Category
open import Categories.Category.Helper
open import Categories.Category.Cartesian.Structure
open import Categories.Functor.Cartesian
open import Categories.Functor.Cartesian.Proper... |
{-# OPTIONS --without-K --safe #-}
module Data.Nat.DivMod where
open import Data.Nat.Base
open import Agda.Builtin.Nat as Nat
open import Data.Bool
nonZero : ℕ → Bool
nonZero (suc _) = true
nonZero zero = false
infixl 8 _÷_
_÷_ : (n m : ℕ) → { m≢0 : T (nonZero m) } → ℕ
_÷_ n (suc m) = Nat.div-helper 0 m n m
rem... |
------------------------------------------------------------------------
-- The Agda standard library
--
-- Almost commutative rings
------------------------------------------------------------------------
{-# OPTIONS --without-K --safe #-}
module Tactic.RingSolver.Core.AlmostCommutativeRing where
open import Level
... |
open import Data.Product using ( _×_ ; _,_ )
open import Relation.Unary using ( _∈_ )
open import Web.Semantic.DL.ABox using ( ABox )
open import Web.Semantic.DL.Signature using ( Signature )
open import Web.Semantic.DL.TBox using ( TBox )
open import Web.Semantic.Util using ( Finite )
module Web.Semantic.DL.Category.... |
{- 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.Impl.NetworkMsg
open i... |
{-# OPTIONS --cubical #-}
module Type.Cubical.Logic where
open import Functional
import Logic.Propositional as Logic
import Logic.Predicate as Logic
import Lvl
open import Type
open import Type.Cubical.Path.Equality
open import Type.Cubical.HTrunc₁
open import Type.Properties.Homotopy
open import T... |
{-# OPTIONS --type-in-type #-}
module dyn.fib where
open import prelude
open import functors
open import prelude.Stream using (take)
open import prelude.io
open import dyn
fib : Dyn
fib = (plus ⊠⊠⊠ delay ℕ) ⟫
λ ( f , f₋ ) → f₋ , λ (.tt)
→ ((f₋ , f) , f )
where plus = fun→dyn (uncurry _... |
open import Categories.Category
import Categories.Functor as Fun
open import Categories.Monad
open import Categories.Object.BinaryCoproducts
import Categories.Normalise as Nm
module Categories.Monad.Coproduct {o ℓ e} (C : Category o ℓ e) (coprod : BinCoproducts C) where
open Category C
open Equiv
open BinCoproducts... |
{-# OPTIONS --without-K --safe #-}
module Categories.Category.Product where
open import Level
open import Function using () renaming (_∘_ to _∙_)
open import Data.Product using (_×_; Σ; _,_; proj₁; proj₂; zip; map; <_,_>; swap)
open import Categories.Utils.Product
open import Categories.Category using (Category)
open... |
{-# OPTIONS --without-K --rewriting #-}
open import HoTT
open import homotopy.HSpace
open import homotopy.EilenbergMacLane1 using (EM₁-level₁)
module homotopy.EM1HSpace where
module EM₁HSpace {i} (G : AbGroup i) where
private
module G = AbGroup G
emloop-commutes : (g g' : G.El) → emloop g ∙ emloop g' == ... |
module InstanceArgumentsConstraintsModule where
data Bool : Set where
true false : Bool
module M (A1 A2 B C : Set) (a1 : A1) (a2 : A2) where
record Class (R : Bool → Set) : Set where
field f : (t : Bool) → R t
open Class {{...}} public
instance
class1 : Class (λ _ → A1)
class1 = record { f = λ... |
------------------------------------------------------------------------
-- Properties of homogeneous binary relations
------------------------------------------------------------------------
module Relation.Binary where
open import Data.Product
open import Data.Sum
open import Data.Function
import Relation.Binary.Pr... |
{-
Day 2, 2nd part
-}
module a2b where
open import Agda.Builtin.IO using (IO)
open import Agda.Builtin.Unit using (⊤)
open import Agda.Builtin.String using (String; primShowNat; primStringAppend)
open import Agda.Builtin.Equality
open import Data.Nat
open import Data.Bool using (if_then_else_)
open import Data.List... |
module Oscar.Class.Injectivity where
open import Oscar.Level
record Injectivity {a} {A : Set a} {b} {B : Set b} {ℓ₁} (_≋₁_ : A → B → Set ℓ₁)
{i} {I : Set i} {ℓ₂} (_≋₂_ : I → I → Set ℓ₂)
(f : I → A)
(g : I → B)
: Set (a ⊔ b ⊔ ℓ₁ ⊔ i ⊔ ℓ₂) where
field
... |
-- {-# OPTIONS -v tc.lhs:100 #-}
module IrrelevantData where
data T (A : Set) : Set where
c : .A → T A
d : ∀ {A} → T A → A
d (c x) = x
-- needs to fail since x is irrelevant under c |
{-# OPTIONS --prop --allow-unsolved-metas #-}
{-# TERMINATING #-}
makeloop : {P : Prop} → P → P
makeloop p = makeloop p
postulate
A : Set
B : A → Prop
record AB : Set where
constructor _,_
field
a : A
b : B a
open AB public
id : AB → AB
id ab = a ab , makeloop (b ab)
postulate
f : (id* : AB → AB)... |
{-# OPTIONS --guardedness --cubical #-}
module Issue2799 where
open import Agda.Primitive.Cubical
open import Agda.Builtin.Cubical.Path
record Stream (A : Set) : Set where
coinductive
constructor _,_
field
head : A
tail : Stream A
open Stream
mapS : ∀ {A B} → (A → B) → Stream A → Stream B
head (mapS ... |
module half where
open import Relation.Binary.PropositionalEquality using (_≡_ ; refl)
open import Size
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
{-# BUILTIN NATURAL ℕ #-}
half : ℕ → ℕ
half zero = zero
half (suc zero) = zero
half (suc (suc i)) = suc (half i)
_ : half 5 ≡ 2
_ = refl
data ℕₛ (n : Size) : Set wher... |
module UnquoteDecl where
open import Common.Prelude
open import Common.Reflection
open import Common.Equality
open import Agda.Builtin.Sigma
infixr 3 _`⇒_
pattern _`⇒_ a b = pi (vArg a) (abs "_" b)
pattern `Nat = def (quote Nat) []
unquoteDecl x =
define (vArg x) (funDef `Nat (clause [] [] (quoteTerm 15) ∷ []))
... |
open import Oscar.Prelude
open import Oscar.Class
open import Oscar.Class.Congruity
open import Oscar.Class.Reflexivity
open import Oscar.Class.Symmetry
open import Oscar.Class.Transitivity
open import Oscar.Class.HasEquivalence
open import Oscar.Class.Transassociativity
open import Oscar.Class.Transleftidentity
open ... |
-- Andreas, 2017-10-06, issue #2751
-- Highlighting for unsolved constraints
module _ where
open import Agda.Builtin.Size
module UnsolvedSizeConstraints where
mutual
data D (i : Size) (A : Set) : Set where
c : D′ i A → D i A
record D′ (i : Size) (A : Set) : Set where
inductive
field
... |
open import Prelude
open import Data.Vec
open import Data.List.Properties
open import Data.List.Any hiding (map)
open import Data.List.All as All using ()
open import Extensions.Vec
open import Data.Product hiding (map)
module Implicits.Resolution.Ambiguous.Semantics where
open import Implicits.Syntax
open import Imp... |
-- Basic intuitionistic modal logic S4, without ∨, ⊥, or ◇.
-- Gentzen-style formalisation of labelled syntax, after Basin-Matthews-Viganò.
module BasicIS4.Syntax.LabelledGentzen where
open import BasicIS4.Syntax.Common public
-- Labels, as in Gabbay’s labelled deductive systems.
postulate
Label : Set
-- Label... |
A : {!!}
A a = Set
-- Display constraints (C-c C-=):
-- An internal error has occurred. Please report this as a bug.
-- Location of the error: src/full/Agda/Interaction/BasicOps.hs:457
|
open import Common.Product
open import Agda.Builtin.Equality
data ⊥ : Set where
record Empty : Set where
field absurdity : ⊥
magic₁ : Empty → ⊥
magic₁ ()
record EmptyIrr : Set where
field .absurdity : ⊥
magic₂ : EmptyIrr → ⊥
magic₂ ()
test : ∀ x y → magic₂ x ≡ magic₂ y
test x y = refl
postulate whatever : Se... |
{-# OPTIONS --without-K --rewriting #-}
open import lib.Basics
open import lib.types.Group
open import lib.types.Lift
open import lib.groups.Homomorphism
open import lib.groups.Isomorphism
module lib.groups.Lift where
Lift-group-structure : ∀ {i j} {A : Type i}
→ GroupStructure A → GroupStructure (Lift {j = j} A)
... |
-- Andreas, 2019-04-10, issue #3689, reported by andrejtokarcik
-- Regression introduced by #3533 (dropping trivially impossible clauses
-- during case-splitting).
-- {-# OPTIONS -v interaction.case:100 #-}
-- {-# OPTIONS -v tc.cover:100 #-}
data _≡_ {A : Set} (a : A) : A → Set where
refl : a ≡ a
record Σ (A : Se... |
-- Andreas, 2020-05-19, issue #4157, reported by nad
-- In old-style mutual blocks, it should be possible to have
-- several anonymous definitions.
open import Agda.Builtin.Equality
mutual
_ : Set₁
_ = Set
_ : Set → Set
_ = λ A → A
mutual
F : Set → Set
F = _
_ : F ≡ λ A → A
_ = refl
G : Set →... |
module LocalOpenImplicit where
record Id (a : Set) : Set where
field id : a -> a
foo : {a b : Set} -> Id a -> Id b -> (a -> b) -> a -> b
foo id1 id2 f x = id id2 (f (id id1 x))
where open Id
|
module _ where
postulate
C : Set → Set
A : Set
i : C A
foo : {X : Set} {{_ : C X}} → X
-- Let bindings need to be declared 'instance' to be eligible.
bar : A
bar = let z = i in foo
|
--------------------------------------------------------------------------------
-- Author : Bradley Hardy
--------------------------------------------------------------------------------
-- The first exercise from the ACS Algebraic Path Problems course, taught by
-- Timothy Griffin
--
-- Final proofs of 'fun fun fact... |
{-# OPTIONS --rewriting #-}
module Luau.OpSem where
open import Agda.Builtin.Equality using (_≡_)
open import Agda.Builtin.Float using (Float; primFloatPlus; primFloatMinus; primFloatTimes; primFloatDiv; primFloatEquality; primFloatLess; primFloatInequality)
open import Agda.Builtin.Bool using (Bool; true; false)
ope... |
module Numeric.Nat.Prime where
open import Prelude hiding (less-antirefl)
open import Numeric.Nat.GCD
open import Numeric.Nat.Divide
open import Numeric.Nat.Divide.Properties
open import Numeric.Nat.DivMod
open import Numeric.Nat.Sqrt
open import Numeric.Nat.Properties
open import Tactic.Nat
data Prime (n : Nat) : S... |
open import Oscar.Prelude
open import Oscar.Data.¶
open import Oscar.Data.Fin
open import Oscar.Data.Vec
module Oscar.Data.Term where
module Term {𝔭} (𝔓 : Ø 𝔭) where
mutual
Terms : ¶ → ¶ → Ø 𝔭
Terms N n = ⟨ Term n ∞ ⟩¶⟨≤ N ⟩
data Term (n : ¶) : Ø 𝔭 where
i : (x : ¶⟨< n ⟩) → Term n
l... |
{-# OPTIONS --safe #-}
module Cubical.Algebra.CommAlgebra.QuotientAlgebra where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.Isomorphism
open import Cubical.Foundations.Powerset using (_∈_; _⊆_)
open import Cubical.... |
{-# OPTIONS --without-K --safe #-}
open import Definition.Typed.EqualityRelation
module Definition.LogicalRelation.Substitution.Introductions.Fst {{eqrel : EqRelSet}} where
open EqRelSet {{...}}
open import Definition.Untyped as U hiding (wk)
open import Definition.Untyped.Properties
open import Definition.Typed
ope... |
------------------------------------------------------------------------------
-- The LTC-PCF natural numbers type
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism ... |
open import Data.Product using ( _,_ )
open import Data.Sum using ( inj₁ ; inj₂ )
open import FRP.LTL.ISet.Core using
( ISet ; I⟦_⟧ ; M⟦_⟧ ; ⟦_⟧ ; ⌈_⌉ ; splitM⟦_⟧ ; subsumM⟦_⟧ ; i→m ; m→i ) renaming
( [_] to [_]′ )
open import FRP.LTL.ISet.Stateless using ( _⇒_ ; _$_ )
open import FRP.LTL.Time.Bound using ( fin ;... |
{- NEW TRANSLATION STUFF: same thing but interpret source nat as ♭nat-}
open import Preliminaries
open import Source
open import Complexity
module Translation where
mutual
⟨⟨_⟩⟩ : Tp → CTp
⟨⟨ unit ⟩⟩ = unit
⟨⟨ nat ⟩⟩ = nat
⟨⟨ susp A ⟩⟩ = || A ||
⟨⟨ A ->s B ⟩⟩ = ⟨⟨ A ⟩⟩ ->c || B ||
⟨⟨ A ×s B... |
{-# OPTIONS --allow-unsolved-metas #-}
data U : ∀ t → Set
data T t : Set
|
module Quantifiers where
-- Imports
import Relation.Binary.PropositionalEquality as Eq
open Eq using (_≡_; refl)
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₁;... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.