commit stringlengths 40 40 | old_file stringlengths 2 205 | new_file stringlengths 2 205 | old_contents stringlengths 0 32.9k | new_contents stringlengths 1 38.9k | subject stringlengths 3 9.4k | message stringlengths 6 9.84k | lang stringlengths 3 13 | license stringclasses 13
values | repos stringlengths 6 115k |
|---|---|---|---|---|---|---|---|---|---|
0b848c7f1bc49d5ae50193b8abe25a13694ce804 | experiments/Coerce.agda | experiments/Coerce.agda | {-# OPTIONS --guardedness-preserving-type-constructors #-}
-- Agda specification of `coerce`
--
-- Incomplete: too much work just to make type system happy.
-- Conversions between morally identical types obscure
-- the operational content.
open import Function
open import Data.Product
open import Data.Maybe
open impo... | {-# OPTIONS --guardedness-preserving-type-constructors #-}
-- Agda specification of `coerce`
--
-- Incomplete: too much work just to make type system happy.
-- Conversions between morally identical types obscure
-- the operational content.
open import Function
open import Data.Product
open import Data.Maybe
open impo... | make agda spec of `coerce` terminating for contractive types | make agda spec of `coerce` terminating for contractive types
| Agda | mit | yfcai/CREG |
634f458ffffacc3e5bc977bed4de2be936703233 | New/Lang.agda | New/Lang.agda | module New.Lang where
open import Relation.Binary.PropositionalEquality
open import Data.Unit
open import Data.Sum
open import New.Types public
open import Base.Syntax.Context Type public
open import Base.Syntax.Vars Type public
open import Base.Data.DependentList public
module _ where
data Const : (τ : Type) → Se... | module New.Lang where
open import Relation.Binary.PropositionalEquality
open import Data.Unit
open import Data.Sum
open import New.Types public
open import Base.Syntax.Context Type public
open import Base.Syntax.Vars Type public
open import Base.Data.DependentList public
module _ where
data Const : (τ : Type) → Se... | Add helpers | Add helpers
| Agda | mit | inc-lc/ilc-agda |
be5ee7eec0dd2371c546256f7625b36c21943d03 | Popl14/Change/Specification.agda | Popl14/Change/Specification.agda | module Popl14.Change.Specification where
-- Denotation-as-specification for Calculus Popl14
--
-- Contents
-- - ⟦_⟧Δ : binding-time-shifted derive
-- - Validity and correctness lemmas for ⟦_⟧Δ
-- - `corollary`: ⟦_⟧Δ reacts to both environment and arguments
-- - `corollary-closed`: binding-time-shifted main theorem
op... | module Popl14.Change.Specification where
-- Denotation-as-specification for Calculus Popl14
--
-- Contents
-- - ⟦_⟧Δ : binding-time-shifted derive
-- - Validity and correctness lemmas for ⟦_⟧Δ
-- - `corollary`: ⟦_⟧Δ reacts to both environment and arguments
-- - `corollary-closed`: binding-time-shifted main theorem
op... | Remove unnecessary imports. | Remove unnecessary imports.
Old-commit-hash: 01c6cb718906e9a41b8156076fe9e837257c7a1f
| Agda | mit | inc-lc/ilc-agda |
584a95def9b81558cd9bc660db3fc2eb687dd915 | PLDI14-List-of-Theorems.agda | PLDI14-List-of-Theorems.agda | module PLDI14-List-of-Theorems where
open import Function
-- List of theorems in PLDI submission
--
-- For hints about installation and execution, please refer
-- to README.agda.
--
-- Agda modules corresponding to definitions, lemmas and theorems
-- are listed here with the most important name. For example,
-- after... | module PLDI14-List-of-Theorems where
open import Function
-- List of theorems in PLDI submission
--
-- For hints about installation and execution, please refer
-- to README.agda.
--
-- Agda modules corresponding to definitions, lemmas and theorems
-- are listed here with the most important name. For example,
-- after... | correct list of theorems | correct list of theorems
Old-commit-hash: c915c2bba4a8fd18c2b4d5af429fdedf6042ca83
| Agda | mit | inc-lc/ilc-agda |
d0bb4f7bbbfa2acbfe952a24f1f347e8b7bac989 | lib/Algebra/Field.agda | lib/Algebra/Field.agda | module Algebra.Field where
open import Relation.Binary.PropositionalEquality.NP
import Algebra.FunctionProperties.Eq as FP
open import Data.Nat.NP using (ℕ; zero; suc; fold)
import Data.Integer as ℤ
open ℤ using (ℤ)
record Field-Ops {ℓ} (A : Set ℓ) : Set ℓ where
infixl 6 _+_ _−_
infixl 7 _*_ _/_
field
_+_ ... | module Algebra.Field where
open import Relation.Binary.PropositionalEquality.NP
import Algebra.FunctionProperties.Eq as FP
open import Data.Nat.NP using (ℕ; zero; suc; fold)
import Data.Integer as ℤ
open ℤ using (ℤ)
record Field-Ops {ℓ} (A : Set ℓ) : Set ℓ where
infixl 6 _+_ _−_
infixl 7 _*_ _/_
field
_+_ ... | Add more derived Field properties | Add more derived Field properties
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
e295b6ccc86d810b0a1b3567f66adcdaf0bb065f | arrow.agda | arrow.agda | data Bool : Set where
true : Bool
false : Bool
_∨_ : Bool → Bool → Bool
true ∨ _ = true
false ∨ b = b
_∧_ : Bool → Bool → Bool
false ∧ _ = false
true ∧ b = b
----------------------------------------
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
{-# BUILTIN NATURAL ℕ #-}
_==_ : ℕ → ℕ → Bool
zero == zero... | data Bool : Set where
true : Bool
false : Bool
_∨_ : Bool → Bool → Bool
true ∨ _ = true
false ∨ b = b
_∧_ : Bool → Bool → Bool
false ∧ _ = false
true ∧ b = b
if_then_else_ : {A : Set} → Bool → A → A → A
if true then a else _ = a
if false then _ else b = b
----------------------------------------
data ℕ... | Add tests | Add tests
| Agda | mit | louisswarren/hieretikz |
fab1df4c820031858a8111d3a016a96fcf1bd2e4 | Parametric/Denotation/CachingEvaluation.agda | Parametric/Denotation/CachingEvaluation.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Caching evaluation
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Denotation.Value as Value
im... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Caching evaluation
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Denotation.Value as Value
im... | Clarify comment | Clarify comment
| Agda | mit | inc-lc/ilc-agda |
07cae51cc16edefb7e8225f94559a896323c1dd2 | Popl14/Syntax/Term.agda | Popl14/Syntax/Term.agda | module Popl14.Syntax.Term where
open import Popl14.Syntax.Type
open import Data.Integer
import Parametric.Syntax.Term Base as Term
-- Popl14-Const ? No.
data Const : Term.Structure where
intlit-const : (n : ℤ) → Const ∅ int
add-const : Const (int • int • ∅) int
minus-const : Const (int • ∅) (int)
empty-con... | module Popl14.Syntax.Term where
open import Popl14.Syntax.Type
open import Data.Integer
import Parametric.Syntax.Term Base as Term
data Const : Term.Structure where
intlit-const : (n : ℤ) → Const ∅ int
add-const : Const (int • int • ∅) int
minus-const : Const (int • ∅) (int)
empty-const : Const ∅ (bag)
i... | Remove comment. | Remove comment.
Old-commit-hash: aabb08e2144e33b92062ac6a93d3722869d7ba2f
| Agda | mit | inc-lc/ilc-agda |
ce0860eb54642cc4fd246103f18313790c9d29f4 | lib/Data/Vec/NP.agda | lib/Data/Vec/NP.agda | module Data.Vec.NP where
open import Data.Vec public
open import Data.Nat using (ℕ; suc; zero; _+_)
open import Data.Fin hiding (_+_)
open import Data.Fin.Props
open import Data.Bool
open import Data.Product
open import Function
import Relation.Binary.PropositionalEquality.NP as ≡
open ≡
count : ∀ {n a} {A : Set a} →... | module Data.Vec.NP where
open import Data.Vec public
open import Data.Nat using (ℕ; suc; zero; _+_)
open import Data.Fin hiding (_+_)
open import Data.Fin.Props
open import Data.Bool
open import Data.Product
open import Function
import Relation.Binary.PropositionalEquality.NP as ≡
open ≡
count : ∀ {n a} {A : Set a} →... | rename ≡-splitAt into ++-decomp | rename ≡-splitAt into ++-decomp
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
9a173b770f197c6b30d41ce679f7a2b1864026a1 | ZK/JSChecker.agda | ZK/JSChecker.agda | {-# OPTIONS --without-K #-}
module ZK.JSChecker where
open import Type.Eq
open import Function using (case_of_)
open import Data.Two.Base using (_∧_)
open import Data.List.Base using ([]; _∷_)
open import FFI.JS
open import FFI.JS.Check
-- open import FFI.JS.Proc using (URI; JSProc; showURI; server)
-- o... | {-# OPTIONS --without-K #-}
module ZK.JSChecker where
open import Type.Eq
open import Function using (case_of_)
open import Data.Two.Base using (_∧_)
open import Data.List.Base using ([]; _∷_)
open import FFI.JS
open import FFI.JS.Check
-- open import FFI.JS.Proc using (URI; JSProc; showURI; server)
-- o... | Update ZK.JSChecker to monadic JS operations | Update ZK.JSChecker to monadic JS operations
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
13ef6fc79c73003cf82b179fbf73127b0e3772b8 | Parametric/Denotation/CachingEvaluation.agda | Parametric/Denotation/CachingEvaluation.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Caching evaluation
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Denotation.Value as Value
im... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Caching evaluation
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Denotation.Value as Value
im... | Drop non-CBPV caching semantics & update comments | Drop non-CBPV caching semantics & update comments
| Agda | mit | inc-lc/ilc-agda |
27a4ba88511dda3572cdb1d98a77ac8d6af2e8e1 | Base/Change/Context.agda | Base/Change/Context.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Change contexts
------------------------------------------------------------------------
module Base.Change.Context
{Type : Set}
(ΔType : Type → Type) where
open import Base.Syntax.Context Type
-- Transfo... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Change contexts
--
-- This module specifies how a context of values is merged
-- together with the corresponding context of changes.
--
-- In the PLDI paper, instead of merging the contexts together, we just
-- conc... | Improve commentary on Base.Change.Context. | Improve commentary on Base.Change.Context.
Old-commit-hash: ad5f3d68627e46f68376b1c994a9ce3787870847
| Agda | mit | inc-lc/ilc-agda |
670c3d1576725334e48ff0039610f28d8afc13f2 | Parametric/Change/Correctness.agda | Parametric/Change/Correctness.agda | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Denotation.Value as Value
import Parametric.Denotation.Evaluation as Evaluation
import Parametric.Change.Validity as Validity
import Parametric.Change.Specification as Specification
import Parametric.Change.Type as ChangeType
... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Correctness of differentiation (Lemma 3.10 and Theorem 3.11).
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
imp... | Document P.C.Correctness. | Document P.C.Correctness.
Old-commit-hash: 688c41e30d805aa8b9ac8494f9ec53ddf0b1eb5a
| Agda | mit | inc-lc/ilc-agda |
2fbf9654c1cd556317dc4eaee7c81283b276d720 | lib/Explore/Function/Fin.agda | lib/Explore/Function/Fin.agda | {-# OPTIONS --without-K #-}
open import Type
open import Function
open import Data.Fin using (Fin)
open import Level.NP
open import Algebra
open import Algebra.FunctionProperties.NP
open import Data.Fin using (Fin; zero; suc)
open import Data.Nat
open import Data.Product
open import Relation.Binary.NP
open import Expl... | {-# OPTIONS --without-K #-}
open import Type
open import Function
open import Data.Fin using (Fin)
open import Level.NP
open import Algebra
open import Algebra.FunctionProperties.NP
open import Data.Fin using (Fin; zero; suc)
open import Data.Nat
open import Data.Product
open import Relation.Binary.NP
open import Expl... | use the Regular version | Fun...Fun: use the Regular version
| Agda | bsd-3-clause | crypto-agda/explore |
18cdc5c3e0989baa42c6669ff2552c5f95ed8867 | Postulate/Bag-Nehemiah.agda | Postulate/Bag-Nehemiah.agda | module Postulate.Bag-Nehemiah where
-- Postulates about bags of integers, version Nehemiah
--
-- This module postulates bags of integers with negative
-- multiplicities as a group under additive union.
open import Relation.Binary.PropositionalEquality
open import Algebra.Structures
open import Data.Integer
-- postul... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Bags with negative multiplicities, for Nehemiah.
--
-- Instead of implementing bags (with negative multiplicities,
-- like in the paper) in Agda, we postulate that a group of such
-- bags exist. Note that integer ba... | Document Postulate.Bag-Nehemiah (for #275). | Document Postulate.Bag-Nehemiah (for #275).
Old-commit-hash: f22f7ab7d307f61d4bb165003c6eb917869d49a5
| Agda | mit | inc-lc/ilc-agda |
e047957caacbba3c00568183dc07c1230b362d8e | Denotation/Specification/Canon-Popl14.agda | Denotation/Specification/Canon-Popl14.agda | module Denotation.Specification.Canon-Popl14 where
-- Denotation-as-specification for Calculus Popl14
--
-- Contents
-- - ⟦_⟧Δ : binding-time-shifted derive
-- - Validity and correctness lemmas for ⟦_⟧Δ
-- - `corollary`: ⟦_⟧Δ reacts to both environment and arguments
-- - `corollary-closed`: binding-time-shifted main t... | module Denotation.Specification.Canon-Popl14 where
-- Denotation-as-specification for Calculus Popl14
--
-- Contents
-- - ⟦_⟧Δ : binding-time-shifted derive
-- - Validity and correctness lemmas for ⟦_⟧Δ
-- - `corollary`: ⟦_⟧Δ reacts to both environment and arguments
-- - `corollary-closed`: binding-time-shifted main t... | Make some arguments of correctVar explicit. | Make some arguments of correctVar explicit.
Old-commit-hash: 2596b6835434e84c2b902574a029b3b1644baa1b
| Agda | mit | inc-lc/ilc-agda |
9b2d54a0d452488646b4ad893d98b6b7c51edbc6 | lib/Function/Extensionality.agda | lib/Function/Extensionality.agda | {-# OPTIONS --without-K #-}
module Function.Extensionality where
open import Relation.Binary.PropositionalEquality renaming (subst to tr)
postulate
FunExt : Set
λ= : ∀ {a b}{A : Set a}{B : A → Set b}{f₀ f₁ : (x : A) → B x}{{fe : FunExt}}
(f= : ∀ x → f₀ x ≡ f₁ x) → f₀ ≡ f₁
-- This should be der... | {-# OPTIONS --without-K #-}
module Function.Extensionality where
open import Function.NP
open import Relation.Binary.PropositionalEquality.NP -- renaming (subst to tr)
happly : ∀ {a b}{A : Set a}{B : A → Set b}{f g : (x : A) → B x}
→ f ≡ g → (x : A) → f x ≡ g x
happly p x = ap (λ f → f x) p
postulate
FunExt :... | Add happly, and the univalence axioms | Add happly, and the univalence axioms
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
0087d65feddda54b6f2fa46d87ca1d54d8f1779a | Parametric/Change/Specification.agda | Parametric/Change/Specification.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Change evaluation (Def 3.6 and Fig. 4h).
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Denota... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Change evaluation (Def 3.6 and Fig. 4h).
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Denota... | Simplify definition | Simplify definition
This variant is simpler to think about and do proofs about on paper, and
the two variants are definitionally equal for Agda.
| Agda | mit | inc-lc/ilc-agda |
df3e9873d4d0c9dac1df76aa623fc13494cecc2d | lib/NomPa/All.agda | lib/NomPa/All.agda | module NomPa.All where
import NomPa.Record
import NomPa.Derived
import NomPa.Derived.NaPa
import NomPa.Traverse
import NomPa.Implem
import NomPa.Examples.LC.DataTypes
import NomPa.Examples.LC.Contexts
import NomPa.Examples.LC.Equiv
-- import NomPa.Examples.LC.Monadic
-- import NomPa.Examples.LC.Monadic.Tests
import Nom... | module NomPa.All where
import NomPa.Record
import NomPa.Derived
import NomPa.Derived.NaPa
import NomPa.Traverse
import NomPa.Implem
import NomPa.Examples.LC.DataTypes
import NomPa.Examples.LC.Contexts
import NomPa.Examples.LC.Equiv
-- import NomPa.Examples.LC.Monadic
-- import NomPa.Examples.LC.Monadic.Tests
import Nom... | Disable broken import | NomPa: Disable broken import
| Agda | bsd-3-clause | np/NomPa |
95e2bfa97f5f84f48cf5fe9cd6a123b8e8ddb4bb | Game/ReceiptFreeness/Definitions.agda | Game/ReceiptFreeness/Definitions.agda | {-# OPTIONS --without-K #-}
open import Function
open import Type
open import Data.Product renaming (zip to zip-×)
open import Data.Two
open import Data.List as L
open import Data.Nat.NP hiding (_==_)
module Game.ReceiptFreeness.Definitions
(PubKey : ★)
(SecKey : ★)
-- Message = 𝟚
(CipherText : ★)
(S... | {-# OPTIONS --without-K #-}
open import Function
open import Type
open import Data.Product renaming (zip to zip-×)
open import Data.Two
open import Data.List as L
open import Data.Nat.NP hiding (_==_)
module Game.ReceiptFreeness.Definitions
(PubKey : ★)
(SecKey : ★)
-- Message = 𝟚
(CipherText : ★)
(S... | Add missing projection for Receipts | Add missing projection for Receipts
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
a74d5f4d0654808362f2583716c758bb12b35288 | Parametric/Change/Implementation.agda | Parametric/Change/Implementation.agda | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Denotation.Value as Value
import Parametric.Denotation.Evaluation as Evaluation
import Parametric.Change.Validity as Validity
import Parametric.Change.Specification as Specification
import Parametric.Change.Type as ChangeType
... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Logical relation for erasure (Def. 3.8 and Lemma 3.9)
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Para... | Document P.C.Implementation. | Document P.C.Implementation.
Old-commit-hash: 62c4109c756f345ba501b4ab6a99669cec1f3a21
| Agda | mit | inc-lc/ilc-agda |
14cfac67791f75bdf456a7774da62935891a6640 | Control/Strategy.agda | Control/Strategy.agda | module Control.Strategy where
open import Function.NP
open import Type using (★)
open import Category.Monad
open import Data.Product hiding (map)
open import Data.List using (List; []; _∷_)
open import Relation.Binary.PropositionalEquality.NP
data Strategy (Q : ★) (R : Q → ★) (A : ★) : ★ where
ask : (q? : Q) (cont... | module Control.Strategy where
open import Data.Nat
open import Function.NP
open import Type using (★)
open import Category.Monad
open import Data.Product hiding (map)
open import Data.List as List using (List; []; _∷_)
open import Relation.Binary.PropositionalEquality.NP
data Strategy (Q : ★) (R : Q → ★) (A : ★) : ★ ... | Add some more ways of computing Strategy | Add some more ways of computing Strategy
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
00bee87e47150d5062c2e99e9711f35f367885f2 | formalization/agda/Spire/Operational.agda | formalization/agda/Spire/Operational.agda | module Spire.Operational where
----------------------------------------------------------------------
data Level : Set where
zero : Level
suc : Level → Level
----------------------------------------------------------------------
data Context : Set
data Type (Γ : Context) : Set
data Value (Γ : Context) : Type Γ ... | module Spire.Operational where
----------------------------------------------------------------------
data Level : Set where
zero : Level
suc : Level → Level
----------------------------------------------------------------------
data Context : Set
data Type (Γ : Context) : Set
data Value (Γ : Context) : Type Γ ... | Add Mu eliminator to operational semantics. | Add Mu eliminator to operational semantics.
| Agda | bsd-3-clause | spire/spire |
c9a0e322742287bc9c2a9d3e057a06d23971c82c | Syntax/Language/Calculus.agda | Syntax/Language/Calculus.agda | module Syntax.Language.Calculus where
-- Full description of a calculus in Plotkin style
--
-- Users should supply
-- - base types
-- - constants
-- - Δtype of base types
-- - derivatives of constants
open import Syntax.Type.Plotkin public
open import Syntax.Term.Plotkin public
open import Syntax.Context public
open ... | module Syntax.Language.Calculus where
-- Full description of a calculus in Plotkin style
--
-- Users should supply
-- - base types
-- - constants
-- - Δtype of base types
-- - derivatives of constants
open import Syntax.Type.Plotkin public
open import Syntax.Term.Plotkin public
open import Syntax.Context public
open ... | Refactor Syntax/Language/Calculus.agda | Refactor Syntax/Language/Calculus.agda
Move helpers inside record, so that if we open the record module with a
record value:
open Calculus some-specific-calculus
We get all of the helper functions specialized to
`some-specific-calculus`, like the fields.
Old-commit-hash: dafe67297ca04cb5ab0369e8d1d7a8e2109a6c6d
| Agda | mit | inc-lc/ilc-agda |
456887b7b811ebbfcf89f5846339b3778163d905 | Parametric/Change/Validity.agda | Parametric/Change/Validity.agda | import Parametric.Syntax.Type as Type
import Parametric.Denotation.Value as Value
module Parametric.Change.Validity
{Base : Type.Structure}
(⟦_⟧Base : Value.Structure Base)
where
open Type.Structure Base
open Value.Structure Base ⟦_⟧Base
-- Changes for Calculus Popl14
--
-- Contents
-- - Mutually recursive... | import Parametric.Syntax.Type as Type
import Parametric.Denotation.Value as Value
module Parametric.Change.Validity
{Base : Type.Structure}
(⟦_⟧Base : Value.Structure Base)
where
open Type.Structure Base
open Value.Structure Base ⟦_⟧Base
-- Changes for Calculus Popl14
--
-- Contents
-- - Mutually recursive... | Move nil-valid-change to use it in ⊞. | Move nil-valid-change to use it in ⊞.
What I learned from this project: To implement apply, you need nil.
Old-commit-hash: 3af743a00cc7e7cad69e57ec30364639c1b5e928
| Agda | mit | inc-lc/ilc-agda |
5d95a3734811ffcaf8c9508aca53f1f46a9739ee | FunUniverse/Fin/Op.agda | FunUniverse/Fin/Op.agda | open import Type
open import Function
open import Data.Nat.NP using (ℕ; module ℕ°)
open import Data.Fin.NP as Fin using (Fin; inject+; raise; bound; free)
open import Data.Vec.NP using (lookup)
open import FunUniverse.Data
open import FunUniverse.Core
open import FunUniverse.Rewiring.Linear
open import FunUniverse.Cate... | Add FunUniverse/Fin/Op.agda | Add FunUniverse/Fin/Op.agda
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
13c4b4c064a0a4ebee4104eb40461152750f44d5 | NormalizationByEvaluation.agda | NormalizationByEvaluation.agda | module NormalizationByEvaluation where
-- NORMALIZATION BY EVALUATION
--
-- for the simply-typed λ calculus with base types
open import Level hiding (Lift; lift)
open import Data.Bool
open import Relation.Binary hiding (_⇒_)
-- The rest of this file is parametric in the set of base types.
module Parametric (Base :... | Implement NbE for lambda calculus with base types (see #50). | Implement NbE for lambda calculus with base types (see #50).
Old-commit-hash: 26dd0dee4e73552fe51a52999922812354a03188
| Agda | mit | inc-lc/ilc-agda | |
7733c00a89f89d8d2ab941d498d88e4b5f59d2ef | adder.agda | adder.agda | open import Type
open import Data.Nat.NP
open import Data.Bool using (if_then_else_)
import Data.Vec as V
open V using (Vec; []; _∷_)
open import Function.NP hiding (id)
open import FunUniverse.Core hiding (_,_)
open import Data.Fin using (Fin; zero; suc; #_; inject+; raise) renaming (toℕ to Fin▹ℕ)
module adder where
... | add a "simple" circuit adder capable of 11+31=42 | add a "simple" circuit adder capable of 11+31=42
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
72c4baef0b4762d0e68731f5561c74025613aeca | lib/Data/Nat/Primality/NP.agda | lib/Data/Nat/Primality/NP.agda | {-# OPTIONS --without-K #-}
module Data.Nat.Primality.NP where
open import Data.Nat.NP
open import Data.Nat.Properties
open import Data.Nat.Divisibility.NP
open import Data.Nat.Primality public
hiding (prime?) -- was slow
open import Data.Fin.Dec
open import Relation.Unary
open import Relation.Binary.PropositionalE... | Add Nat.Primality.NP | Add Nat.Primality.NP
| Agda | bsd-3-clause | crypto-agda/agda-nplib | |
a22358b5e658d944b72f4ecb719b036e857e9f95 | lib/Data/One/Param/Binary.agda | lib/Data/One/Param/Binary.agda | {-# OPTIONS --without-K #-}
open import Type.Param.Binary
open import Data.Unit renaming (⊤ to 𝟙; tt to 0₁)
module Data.One.Param.Binary where
record ⟦𝟙⟧ (x₁ x₂ : 𝟙) : Set₀ where
constructor ⟦0₁⟧
| Add Data.One.Param.Binary | Add Data.One.Param.Binary
| Agda | bsd-3-clause | np/agda-parametricity | |
c838b5d3d047273d8b46736db7c5e6353d903cbd | Crypto/Sig/Lamport/OneBit/Abstract.agda | Crypto/Sig/Lamport/OneBit/Abstract.agda | {-# OPTIONS --without-K #-}
open import Type using (Type)
open import Type.Eq using (Eq?; _==_; ≡⇒==; ==⇒≡)
open import Data.Product.NP using (_×_; _,_; fst; snd; map)
open import Data.Bit using (Bit; 0b; 1b; proj′; ✓→≡; ≡→✓)
open import Relation.Binary.PropositionalEquality.NP
open ≡-Reasoning
module Crypto.Sig.Lampo... | Add Crypto.Sig.Lamport.OneBit.Abstract | Add Crypto.Sig.Lamport.OneBit.Abstract
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
d245f73509a8c7b6ddee9bdcd869c6144bf6d4c8 | FunUniverse/Nand/Function.agda | FunUniverse/Nand/Function.agda | open import Data.Product
module FunUniverse.Nand.Function where
module FromNand {A} (nand : A × A → A) where
open import FunUniverse.Agda
open import FunUniverse.Nand (Abstract𝟚.funRewiring A)
open FromNand nand public
open import Data.Two
module Nand𝟚 = FromNand (uncurry nand)
open import Data.Tre... | Add FunUniverse/Nand/Function.agda | Add FunUniverse/Nand/Function.agda
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
cf87a127259d824c11c3fb4c235421022c1fc846 | FLABloM/SemiRingRecord.agda | FLABloM/SemiRingRecord.agda | module SemiRingRecord where
import Algebra.FunctionProperties
using (LeftIdentity; RightIdentity)
import Function using (_on_)
import Relation.Binary.EqReasoning as EqReasoning
import Relation.Binary.On using (isEquivalence)
import Algebra.Structures using (module IsCommutativeMonoid; IsCommutativeMonoid)
open impor... | Add SemiRing | Add SemiRing
| Agda | bsd-3-clause | DSLsofMath/DSLsofMath | |
ddc36dae24c43d057f2b8f67f617631d371130bf | lib/Control/Process/Type.agda | lib/Control/Process/Type.agda | {-
On the one hand this module has nothing to do with JS, on the other
hand our JS binding relies on this particular type definition.
-}
module Control.Process.Type where
open import Data.String.Base using (String)
data Proc (C {-channels-} : Set₀) (M {-messages-} : Set₀) : Set₀ where
end : Proc C M
send :... | Add Control.Process.Type | Add Control.Process.Type
| Agda | bsd-3-clause | audreyt/agda-libjs,crypto-agda/agda-libjs | |
e0c6a8e5b17986de3b0562105b17b44fb570453b | FiniteField/FinImplem.agda | FiniteField/FinImplem.agda | -- Implements ℤq with Data.Fin
open import Type
open import Data.Nat
open import Data.Fin.NP as Fin
open import Relation.Binary.PropositionalEquality
open import Explore.Type
open import Explore.Explorable
open Fin.Modulo renaming (sucmod to [suc]; sucmod-inj to [suc]-inj)
module FiniteField.FinImplem (q-1 : ℕ) ([0]... | Add FiniteField/FinImplem.agda (unfinished) | Add FiniteField/FinImplem.agda (unfinished)
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
80516389760b8a704422d85e8bf6d5b682422d9d | Parametric/Change/Equivalence.agda | Parametric/Change/Equivalence.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Delta-observational equivalence
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Denotation.Value as Value
module Parametric.Change.Eq... | Implement delta-observational equivalence (#244, #299) | Implement delta-observational equivalence (#244, #299)
This proof shows that delta-observational equivalence is an equivalence
relation.
Known limitations of this commit:
* it does not show that any function respects this relation;
* it does not rephrase existing results;
* this might better belong in Base.Change.Equ... | Agda | mit | inc-lc/ilc-agda | |
f58fb12a605924ada6a2cc1645dc725167a301ea | meaning.agda | meaning.agda | module meaning where
open import Level
record Meaning (Syntax : Set) {ℓ : Level} : Set (suc ℓ) where
constructor
meaning
field
Semantics : Set ℓ
⟦_⟧ : Syntax → Semantics
open Meaning {{...}} public
| Add missing file. | Add missing file.
Forgot to add this file in commit ba1d8a8be0778b4d917c4d98c7db8f78f8f3cbbc.
Old-commit-hash: 02fcec1035aa2e0190d1ba3fc335cecbade97c9b
| Agda | mit | inc-lc/ilc-agda | |
14b8f096b525d8a615d01965c700b05596b5d603 | New/Equivalence.agda | New/Equivalence.agda | module New.Equivalence where
open import Relation.Binary.PropositionalEquality
open import Function
open import Data.Product
open import Postulate.Extensionality
open import New.Changes
module _ {a} {A : Set a} {{CA : ChAlg A}} {x : A} where
-- Delta-observational equivalence: these asserts that two changes
-- g... | Add lemmas to prove function changes valid | Add lemmas to prove function changes valid
| Agda | mit | inc-lc/ilc-agda | |
02b7dc1fcde2d5ea5944dc426ae4920689962b5d | experiments/NonregularTraversable.agda | experiments/NonregularTraversable.agda | -- A traversable functor that is not regular.
open import Data.Nat
open import Data.Vec
open import Data.Product
record Applicative : Set₁ where
constructor
appl
field
Map : Set → Set
pure : ∀ {A} → A → Map A
call : ∀ {A B} → Map (A → B) → Map A → Map B
Traversable : (Set → Set) → Set₁
Tra... | add example of non-regular traversable functor | add example of non-regular traversable functor
| Agda | mit | yfcai/CREG | |
ccc91a1d485cba9d42a78ea4ff80597f0f7e7849 | bytecode.agda | bytecode.agda | -- This module is an example of the use of the circuit building library.
-- The point is to start with a tiny bytecode evaluator for bit operations.
module bytecode where
open import Function
open import Data.Nat
open import Data.Vec
open import Data.Product.NP
open import Data.Bits
open import Data.Bool
open import A... | Add bytecode.agda to experiment with circuits | Add bytecode.agda to experiment with circuits
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
095f53c09c64b3abe9688067512e48f0db0bf52b | ZK/SigmaProtocol/KnownStatement.agda | ZK/SigmaProtocol/KnownStatement.agda | open import Type using (Type)
open import Data.Bool.Base using (Bool; true)
open import Relation.Binary.Core using (_≡_; _≢_)
-- This module assumes the exact statement of the Zero-Knowledge proof to be
-- known by all parties.
module ZK.SigmaProtocol.KnownStatement
(Commitment : Type) ... | Add ZK.SigmaProtocol.KnowStatement | Add ZK.SigmaProtocol.KnowStatement
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
6419e6a499edf075accabe01063360bc7c867ef8 | formalization/agda/Spire/Examples/CompLev.agda | formalization/agda/Spire/Examples/CompLev.agda | {-# OPTIONS --type-in-type #-}
open import Data.Unit
open import Data.Product hiding ( curry ; uncurry )
open import Data.List hiding ( concat )
open import Data.String
open import Relation.Binary.PropositionalEquality
open import Function
module Spire.Examples.CompLev where
-------------------------------------------... | Fix internalized as a computational description. | Fix internalized as a computational description.
The idea is that the core could have computatial descriptions,
which do not mention things like which arguments are implicit,
and Desc can be internalized as a description like the current
primitive (non-computational) description that also mentions
which arguments are ... | Agda | bsd-3-clause | spire/spire | |
3be44d190ddb71b95417f9028965e046e7938081 | agda/Language/Greek.agda | agda/Language/Greek.agda | module Language.Greek where
data Maybe A : Set where
none : Maybe A
just : A → Maybe A
data Unicode : Set where
Α Β Γ Δ Ε Ζ Η Θ Ι Κ Λ Μ Ν Ξ Ο Π Ρ Σ Τ Υ Φ Χ Ψ Ω α β γ δ ε ζ η θ ι κ λ′ μ ν ξ ο π ρ σ ς τ υ φ χ ψ ω : Unicode
grave acute diaeresis smooth rough circumflex iotaSubscript : Unicode
postulate
Char :... | Add an initial start for an Agda model. | Add an initial start for an Agda model.
| Agda | mit | scott-fleischman/greek-grammar,scott-fleischman/greek-grammar | |
8eb3bf726fb7d12e74f6c4c5fd3b4b9b641cfefd | lib/Algebra/Nearring.agda | lib/Algebra/Nearring.agda | {-# OPTIONS --without-K #-}
open import Relation.Binary.PropositionalEquality.NP
import Algebra.FunctionProperties.Eq
open Algebra.FunctionProperties.Eq.Implicits
open import Function.Extensionality
open import Data.Product.NP
open import Data.Nat.NP using (ℕ; zero; fold) renaming (suc to 1+)
open import Data.Integer u... | Add Nearring+1 | Add Nearring+1
| Agda | bsd-3-clause | crypto-agda/agda-nplib | |
b5129ee5c0b5ffae12387ee403ca85c9cabd2fb1 | lib/FFI/JS/BigI.agda | lib/FFI/JS/BigI.agda | open import FFI.JS hiding (toString)
module FFI.JS.BigI where
abstract
BigI : Set
BigI = JSValue
BigI▹JSValue : BigI → JSValue
BigI▹JSValue x = x
unsafe-JSValue▹BigI : BigI → JSValue
unsafe-JSValue▹BigI x = x
postulate
bigI : (x base : String) → BigI
add : (x y : BigI) → BigI
multiply : ... | Add FFI.JS.BigI | Add FFI.JS.BigI
| Agda | bsd-3-clause | crypto-agda/agda-libjs,audreyt/agda-libjs | |
27acbf899d88340ad1d03042fa744d1a3b783e0c | Base/Change/Sums.agda | Base/Change/Sums.agda | module Base.Change.Sums where
open import Relation.Binary.PropositionalEquality
open import Level
open import Base.Change.Algebra
open import Base.Change.Equivalence
open import Postulate.Extensionality
open import Data.Sum
module SumChanges ℓ (X Y : Set ℓ) {{CX : ChangeAlgebra ℓ X}} {{CY : ChangeAlgebra ℓ Y}} where... | Implement change structure for sum types | Implement change structure for sum types
| Agda | mit | inc-lc/ilc-agda | |
98776944ea4983b6faeeced4116bc7798c5e3ebc | Crypto/Sig/Lamport.agda | Crypto/Sig/Lamport.agda | {-# OPTIONS --without-K #-}
open import Function using (_∘_)
open import Data.Nat.NP hiding (_==_)
open import Data.Product.NP hiding (map)
open import Data.Bit hiding (_==_)
open import Data.Bits
open import Data.Bits.Properties
open import Data.Vec.NP
open import Relation.Binary.PropositionalEquality.NP
import Crypto... | Add Crypto.Sig.Lamport | Add Crypto.Sig.Lamport
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
128af4af6ee42b630e845312b9e05e5b42880cae | Control/Strategy/Utils.agda | Control/Strategy/Utils.agda | {-# OPTIONS --copatterns #-}
open import Type
open import Function
open import Data.Product
open import Control.Strategy renaming (map to mapS)
module Control.Strategy.Utils where
record Proto : ★₁ where
constructor P[_,_]
field
Q : ★
R : Q → ★
Client : Proto → ★ → ★
Client P[ Q , R ] A = Strategy Q R A
... | Add Control.Strategy.Utils | Add Control.Strategy.Utils
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
f4f6e7a3cad61d0a276de2905272032cf125b5eb | lib/Data/Product/Param/Binary.agda | lib/Data/Product/Param/Binary.agda | {-# OPTIONS --without-K #-}
open import Level
open import Data.Product
renaming (proj₁ to fst; proj₂ to snd)
open import Function.Param.Binary
module Data.Product.Param.Binary where
record ⟦Σ⟧ {a₁ a₂ b₂ b₁ aᵣ bᵣ}
{A₁ : Set a₁} {A₂ : Set a₂}
{B₁ : A₁ → Set b₁}
{B₂ : A₂ → Set b₂}
... | add Data.Product.Param.Binary | add Data.Product.Param.Binary
| Agda | bsd-3-clause | np/agda-parametricity | |
8fd23013cafc4153d1b4a63b41e95bc6ecbbac7e | Crypto/Sig/LamportOneBit.agda | Crypto/Sig/LamportOneBit.agda | {-# OPTIONS --without-K #-}
open import Data.Nat.NP hiding (_==_)
open import Data.Product.NP hiding (map)
open import Data.Bit hiding (_==_)
open import Data.Bits
open import Data.Bits.Properties
open import Data.Vec.NP
open import Relation.Binary.PropositionalEquality.NP
module Crypto.Sig.LamportOneBit
(#s... | Add Crypto.Sig.LamportOneBit | Add Crypto.Sig.LamportOneBit
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
fefd4590ac23e7cdf91cbc2277dcce1be57d736e | Control/Strategy.agda | Control/Strategy.agda | module Control.Strategy where
open import Function
open import Type using (★)
open import Category.Monad
open import Relation.Binary.PropositionalEquality.NP
data Strategy (Q R A : ★) : ★ where
ask : (q? : Q) (cont : R → Strategy Q R A) → Strategy Q R A
done : A → Strategy Q R A
infix 2 _≈_
data _≈_ {Q R A} : (... | Add Control.Strategy | Add Control.Strategy
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
962dded37d6c55fa91fe570fbfe0821e7c37241a | ttfp1.agda | ttfp1.agda | -- some excises for learning ttfp (type theory for functional programming).
-- most of the code is *borrowed* from learn you an agda shamelessly
-- Function composition
_∘_ : {A : Set} { B : A -> Set} { C : (x : A) -> B x -> Set}
(f : {x : A}(y : B x) -> C x y) (g : (x : A) -> B x)
(x : A) -> C x (g x)
(f ... | Create ttfp1.agda | Create ttfp1.agda
notes while learning ttfp | Agda | bsd-3-clause | wangbj/excises,wangbj/excises,wangbj/excises | |
38dc0e74c8050099800069c05d5282fdff28dced | incremental.agda | incremental.agda | module incremental where
-- SIMPLE TYPES
-- Syntax
data Type : Set where
_⇒_ : (τ₁ τ₂ : Type) → Type
infixr 5 _⇒_
-- Semantics
Dom⟦_⟧ : Type -> Set
Dom⟦ τ₁ ⇒ τ₂ ⟧ = Dom⟦ τ₁ ⟧ → Dom⟦ τ₂ ⟧
-- TYPING CONTEXTS
-- Syntax
data Context : Set where
∅ : Context
_•_ : (τ : Type) (Γ : Context) → Context
infixr 9 _... | Implement STLC in AGDA (fix #13). | Implement STLC in AGDA (fix #13).
Old-commit-hash: 8c8d0d1e3a7f67f1a6640d7526542321b3a5a424
| Agda | mit | inc-lc/ilc-agda | |
2824f8185e103bd7e2500937eff9fb9af1077e07 | lib/Data/Nat/GCD/NP.agda | lib/Data/Nat/GCD/NP.agda | module Data.Nat.GCD.NP where
open import Data.Nat
open import Data.Nat.Properties
open import Data.Nat.Divisibility as Div
open import Relation.Binary
private module P = Poset Div.poset
open import Data.Product
open import Relation.Binary.PropositionalEquality as PropEq using (_≡_)
open import Induction
open import In... | Add a broken attempt at simplifying Nat.GCD: Nat.GCD.NP | Add a broken attempt at simplifying Nat.GCD: Nat.GCD.NP
| Agda | bsd-3-clause | crypto-agda/agda-nplib | |
4995bc2a3bd988bcf90ed2efe5b614e17b5554a0 | Game/IND-CPA-alt.agda | Game/IND-CPA-alt.agda |
{-# OPTIONS --without-K #-}
open import Type
open import Data.Product
open import Data.Bit
module Game.IND-CPA-alt
(PubKey : ★)
(SecKey : ★)
(Message : ★)
(CipherText : ★)
-- randomness supply for: encryption, key-generation, adversary, extensions
(Rₑ Rₖ Rₐ : ★)
(KeyGen : Rₖ → PubKey × SecK... | Add alternative defintion for IND CPA | Add alternative defintion for IND CPA
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
f9510280666609fdd9b8b35645bab6c0e17092c4 | lib/FFI/JS.agda | lib/FFI/JS.agda | module FFI.JS where
open import Data.Char.Base public using (Char)
open import Data.String.Base public using (String)
open import Data.Bool.Base public using (Bool; true; false)
open import Data.List.Base using (List)
open import Data.Product using (_×_) renaming (proj₁ to fst; proj₂ to snd)
open import Con... | Add FFI.JS | Add FFI.JS
| Agda | bsd-3-clause | audreyt/agda-libjs,crypto-agda/agda-libjs | |
9236c772d09686e999993e80d77ce8bd225d16f5 | lib/FFI/JS/SHA1.agda | lib/FFI/JS/SHA1.agda | module FFI.JS.SHA1 where
open import Data.String.Base using (String)
postulate SHA1 : String → String
{-# COMPILED_JS SHA1 function (x) { return require("sha1")(x); } #-}
| Add FFI.JS.SHA1 | Add FFI.JS.SHA1
| Agda | bsd-3-clause | audreyt/agda-libjs,crypto-agda/agda-libjs | |
d5f6beafc85ff125a91c2f035d2d29dd6409f54e | ZK/GroupHom/ElGamal/JS.agda | ZK/GroupHom/ElGamal/JS.agda | {-# OPTIONS --without-K #-}
open import FFI.JS.BigI
open import Data.Bool.Base using (Bool)
open import SynGrp
open import ZK.GroupHom.Types
import ZK.GroupHom.ElGamal
import ZK.GroupHom.JS
module ZK.GroupHom.ElGamal.JS (p q : BigI)(g : ℤ[ p ]★) where
module EG = ZK.GroupHom.ElGamal `ℤ[ q ]+ `ℤ[ p ]★ _`^_ g
module k... | Add ZK.GroupHom.ElGamal.JS, so far only known-enc-rnd | Add ZK.GroupHom.ElGamal.JS, so far only known-enc-rnd
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
1ffd391240cdf755b930cf4216a8231b81aee07d | FunUniverse/Fin/Op/Abstract.agda | FunUniverse/Fin/Op/Abstract.agda | open import Type
open import Function
open import Data.Product using (proj₂)
open import Data.Two renaming (mux to mux₂)
open import Data.Nat.NP using (ℕ; zero; suc; _+_; _*_; module ℕ°)
open import Data.Fin.NP as Fin using (Fin; inject+; raise; bound; free; zero; suc)
open import Data.Vec.NP using (Vec; []; _∷_; looku... | Add FunUniverse/Fin/Op/Abstract.agda | Add FunUniverse/Fin/Op/Abstract.agda
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
3887acc776498fc936c85a42b1ba8ed98dfe1593 | Everything.agda | Everything.agda | module Everything where
import Holes.Prelude
import Holes.Term
import Holes.Cong.Limited
import Holes.Cong.General
import Holes.Cong.Propositional
| Add Everything file | Add Everything file
| Agda | mit | bch29/agda-holes | |
22eab6635a40915cfce9e29a45fe31de8280bcbf | PLDI14-List-of-Theorems.agda | PLDI14-List-of-Theorems.agda | module PLDI14-List-of-Theorems where
open import Function
-- List of theorems in PLDI submission
--
-- For hints about installation and execution, please refer
-- to README.agda.
--
-- Agda modules corresponding to definitions, lemmas and theorems
-- are listed here with the most important name. For example,
-- after... | add list of theorems | add list of theorems
Old-commit-hash: ae20c5bded5fecd55d9723e7870ba03979cd0880
| Agda | mit | inc-lc/ilc-agda | |
dd18fcc5ba9cbb6d8cbf62d171887cf3a22893f5 | Base/Change/Products.agda | Base/Change/Products.agda | module Base.Change.Products where
open import Relation.Binary.PropositionalEquality
open import Level
open import Base.Change.Algebra
open import Data.Product
-- Also try defining sectioned change structures on the positives halves of
-- groups? Or on arbitrary subsets?
-- Restriction: we pair sets on the same lev... | Define a change structure for products | Define a change structure for products
Derivatives of curried functions seem challenging.
Accessing nested records too, but seems easy to fix.
Old-commit-hash: d89e6171d447aae6292cc025dc6db95ce2370b88
| Agda | mit | inc-lc/ilc-agda | |
16e3c79c254b8edd7f64b46df9c7c746fa4194c2 | Language/Simple/Free.agda | Language/Simple/Free.agda | {-# OPTIONS --without-K --copatterns #-}
open import Level.NP
open import Function hiding (_$_)
open import Type
open import Algebra
open import Algebra.FunctionProperties
open import Algebra.Structures
open import Data.Nat using (ℕ; zero; suc; _+_; _≤?_)
open import Data.Fin using (Fin; zero; suc)
open import Data.Vec... | Add Language.Simple.Free | Add Language.Simple.Free
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
a2284fe9263eadf1deb8ce96940c9f0cc72949bb | ModalLogic.agda | ModalLogic.agda | module ModalLogic where
-- Implement Frank Pfenning's lambda calculus based on modal logic S4, as
-- described in "A Modal Analysis of Staged Computation".
open import Denotational.Notation
data BaseType : Set where
Base : BaseType
Next : BaseType → BaseType
data Type : Set where
base : BaseType → Type
_⇒_ ... | Implement modal logic | Implement modal logic
This doesn't belong here, but it reuses @Toxaris modular library.
Old-commit-hash: 2f12ca949c8cb58e2b65b773607282bafbccb5c9
| Agda | mit | inc-lc/ilc-agda | |
006fd9c825ad2011f95bb01a40c7f000d4fd4f30 | bugs/Future.agda | bugs/Future.agda | module Future where
open import Denotational.Notation
-- Uses too much memory.
-- open import Data.Integer
open import Data.Product
open import Data.Sum
open import Data.Unit
postulate ⟦Int⟧ : Set
postulate ⟦Bag⟧ : Set → Set
--mutual
-- First, define a language of types, their denotations, and then the whole algeb... | add another bug example | Agda: add another bug example
Old-commit-hash: 82f681165ed59ccc36685cbf9c376026811e127f
| Agda | mit | inc-lc/ilc-agda | |
9bb44c3e31a11725d740b2f59d40ebbe7e0917a2 | FiniteField/JS.agda | FiniteField/JS.agda | {-# OPTIONS --without-K #-}
open import Function.NP
open import FFI.JS using (Number; Bool; true; false; String; warn-check; check; trace-call; _++_)
open import FFI.JS.BigI
open import Data.List.Base hiding (sum; _++_)
{-
open import Algebra.Raw
open import Algebra.Field
-}
module FiniteField.JS (q : BigI) where
abs... | Add FiniteField/JS | Add FiniteField/JS
| Agda | bsd-3-clause | crypto-agda/crypto-agda | |
a48ff25823603032db6b1a26e4605512aefd0561 | notes/FOT/FOTC/Data/Conat/ConatSL.agda | notes/FOT/FOTC/Data/Conat/ConatSL.agda | ------------------------------------------------------------------------------
-- Definition of FOTC Conat using Agda's co-inductive combinators
------------------------------------------------------------------------------
{-# OPTIONS --allow-unsolved-metas #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS -... | Add incomplete note on co-inductive natural numbers. | Add incomplete note on co-inductive natural numbers.
| Agda | mit | asr/fotc,asr/fotc | |
07045b7aa32a14de23ec233029b6fc6134b24685 | experiment/liftVec.agda | experiment/liftVec.agda | open import Function
open import Data.Nat using (ℕ ; suc ; zero)
open import Data.Fin using (Fin)
open import Data.Vec
open import Data.Vec.N-ary.NP
open import Relation.Binary.PropositionalEquality
module liftVec where
module single (A : Set)(_+_ : A → A → A)where
data Tm : Set where
var : Tm
cst : A → Tm
... | open import Function
open import Data.Nat using (ℕ ; suc ; zero)
open import Data.Fin using (Fin)
open import Data.Vec
open import Data.Vec.N-ary.NP
open import Relation.Binary.PropositionalEquality
module liftVec where
module single (A : Set)(_+_ : A → A → A)where
data Tm : Set where
var : Tm
cst : A → Tm
... | Upgrade to Data.Two | Upgrade to Data.Two
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
a79e9939c6512db4827fc831f2689871d99cfc26 | Base/Change/Context.agda | Base/Change/Context.agda | module Base.Change.Context
{Type : Set}
(ΔType : Type → Type) where
-- Transform a context of values into a context of values and
-- changes.
open import Base.Syntax.Context Type
ΔContext : Context → Context
ΔContext ∅ = ∅
ΔContext (τ • Γ) = ΔType τ • τ • ΔContext Γ
-- like ΔContext, but ΔType τ and τ are s... | module Base.Change.Context
{Type : Set}
(ΔType : Type → Type) where
open import Base.Syntax.Context Type
-- Transform a context of values into a context of values and
-- changes.
ΔContext : Context → Context
ΔContext ∅ = ∅
ΔContext (τ • Γ) = ΔType τ • τ • ΔContext Γ
-- like ΔContext, but ΔType τ and τ are s... | Move function-specific comment right before function | Move function-specific comment right before function
Currently, this seems a comment about the whole module.
Old-commit-hash: c25e918e712496981adfe4c74f94a8d80e8e5052
| Agda | mit | inc-lc/ilc-agda |
06d988ce4bc3692e4e60e39bdb8f2e1daddb660e | Denotation/Change/Popl14.agda | Denotation/Change/Popl14.agda | module Denotation.Change.Popl14 where
-- Changes for Calculus Popl14
--
-- Contents
-- - Mutually recursive concepts: ΔVal, validity.
-- Under module Syntax, the corresponding concepts of
-- ΔType and ΔContext reside in separate files.
-- Now they have to be together due to mutual recursiveness.
-- - `diff... | module Denotation.Change.Popl14 where
-- Changes for Calculus Popl14
--
-- Contents
-- - Mutually recursive concepts: ΔVal, validity.
-- Under module Syntax, the corresponding concepts of
-- ΔType and ΔContext reside in separate files.
-- Now they have to be together due to mutual recursiveness.
-- - `diff... | add type annotations to Denotation.Change.Popl14 | [WIP] add type annotations to Denotation.Change.Popl14
Old-commit-hash: 90b06722aecf9d0b5c6c69547217cb2c522912be
| Agda | mit | inc-lc/ilc-agda |
d9a3d68c58bd5c8ae49738e7a8f68fd5e89b4bce | lambda.agda | lambda.agda | module lambda where
open import Relation.Binary.PropositionalEquality
open import Denotational.Notation
-- SIMPLE TYPES
-- Syntax
data Type : Set where
_⇒_ : (τ₁ τ₂ : Type) → Type
bool : Type
infixr 5 _⇒_
-- Denotational Semantics
data Bool : Set where
true false : Bool
⟦_⟧Type : Type -> Set
⟦ τ₁ ⇒ τ₂ ⟧T... | module lambda where
open import Relation.Binary.PropositionalEquality
open import Syntactic.Types public
open import Syntactic.Contexts Type public
open import Denotational.Notation
open import Denotational.Values public
open import Denotational.Environments Type ⟦_⟧Type public
-- TERMS
-- Syntax
data Term : Cont... | Improve reuse (see #28). | Improve reuse (see #28).
Old-commit-hash: 7da11aabf971e192ab71542164b98c80cbe26325
| Agda | mit | inc-lc/ilc-agda |
a883bca1e4dcf18cbd172d5af888116a00518e15 | Parametric/Change/Term.agda | Parametric/Change/Term.agda | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.Type as ChangeType
module Parametric.Change.Term
{Base : Set}
(Constant : Term.Structure Base)
(ΔBase : ChangeType.Structure Base)
where
-- Terms that operate on changes
open Type.Structure Base
open Te... | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.Type as ChangeType
module Parametric.Change.Term
{Base : Set}
(Constant : Term.Structure Base)
(ΔBase : ChangeType.Structure Base)
where
-- Terms that operate on changes
open Type.Structure Base
open Te... | Rename lift-diff to diff-term. | Rename lift-diff to diff-term.
Old-commit-hash: 64cb73fbed07060d460e4d9ee85fcec48281d13a
| Agda | mit | inc-lc/ilc-agda |
b01d8abafe916c9d2d8af12b12d2adb5f2ae8340 | Syntax/Term/Plotkin.agda | Syntax/Term/Plotkin.agda | module Syntax.Term.Plotkin where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Product
open import Syntax.Type.Plotkin
open import Syntax.Context
data Term
{B : Set {- of base types -}}
{C : Set {- of constants -}}
{type-of : C → Type B}
(Γ : Context {Type... | module Syntax.Term.Plotkin
{B : Set {- of base types -}}
{C : Set {- of constants -}}
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Product
open import Syntax.Type.Plotkin
open import Syntax.Context
data Term
{type-of : C → Type B}
(Γ : Context... | Move parameters to module level. | Move parameters to module level.
All definitions in this module depend on the parameters {B} and
{C} which never change inside this module. So it is easier to
parameterize the whole module instead of each separate
definition.
Old-commit-hash: 1303320f48d486d11152713c604275c2c7bcdc18
| Agda | mit | inc-lc/ilc-agda |
9755ab9f86f1e00b28c36e99421e4e9be389a95f | Base/Change/Products.agda | Base/Change/Products.agda | module Base.Change.Products where
open import Relation.Binary.PropositionalEquality
open import Level
open import Base.Change.Algebra
open import Data.Product
-- Also try defining sectioned change structures on the positives halves of
-- groups? Or on arbitrary subsets?
-- Restriction: we pair sets on the same lev... | module Base.Change.Products where
open import Relation.Binary.PropositionalEquality
open import Level
open import Base.Change.Algebra
open import Data.Product
-- Also try defining sectioned change structures on the positives halves of
-- groups? Or on arbitrary subsets?
-- Restriction: we pair sets on the same lev... | Comment out holes to ensure Everything compiles again | Comment out holes to ensure Everything compiles again
Old-commit-hash: dfc28a00f9301015066e19d4be2c4179f8e0849b
| Agda | mit | inc-lc/ilc-agda |
07b3b64ff9795f6941b64231e7b2a0dd630e0de4 | lib/Explore/Examples.agda | lib/Explore/Examples.agda | {-# OPTIONS --without-K #-}
module Explore.Examples where
open import Type
open import Level.NP
open import Data.Maybe.NP
open import Data.List
open import Data.Two
open import Data.Product
open import Data.Sum.NP
open import Data.One
open import HoTT using (UA)
open import Function.Extensionality using (FunExt)
open ... | {-# OPTIONS --without-K #-}
module Explore.Examples where
open import Type
open import Level.NP
open import Data.Maybe.NP
open import Data.List
open import Data.Zero
open import Data.One
open import Data.Two
open import Data.Product
open import Data.Sum.NP
open import HoTT using (UA)
open import Function.NP
open impor... | Update the Examples | Update the Examples
| Agda | bsd-3-clause | crypto-agda/explore |
b4c39231ae725a5b759926a08d76642ed2df680d | Base/Change/Products.agda | Base/Change/Products.agda | module Base.Change.Products where
open import Relation.Binary.PropositionalEquality
open import Level
open import Base.Change.Algebra
open import Data.Product
-- Also try defining sectioned change structures on the positives halves of
-- groups? Or on arbitrary subsets?
-- Restriction: we pair sets on the same lev... | module Base.Change.Products where
open import Relation.Binary.PropositionalEquality
open import Level
open import Base.Change.Algebra
open import Data.Product
-- Also try defining sectioned change structures on the positives halves of
-- groups? Or on arbitrary subsets?
-- Restriction: we pair sets on the same lev... | Simplify code | Base.Change.Products: Simplify code
These simplifications are inspired by Base.Change.Sums. But they're
still modest.
| Agda | mit | inc-lc/ilc-agda |
5957a0a5f21ebc9ad88ea001c4afa6b381372c04 | Parametric/Change/Type.agda | Parametric/Change/Type.agda | import Parametric.Syntax.Type as Type
module Parametric.Change.Type
(Base : Type.Structure)
where
open Type.Structure Base
Structure : Set
Structure = Base → Base
module Structure (ΔBase : Structure) where
ΔType : Type → Type
ΔType (base ι) = base (ΔBase ι)
ΔType (σ ⇒ τ) = σ ⇒ ΔType σ ⇒ ΔType τ
open im... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Simply-typed changes (Fig. 3 and Fig. 4d)
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
module Parametric.Change.Type
(Base : Type.Structure)
wh... | Document P.C.Type. | Document P.C.Type.
Old-commit-hash: 11e38d018843f21411d014020ce42181e1f77d32
| Agda | mit | inc-lc/ilc-agda |
27037592477c7d9112554d56337e06c5a2c6f0b9 | Parametric/Syntax/Term.agda | Parametric/Syntax/Term.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- The syntax of terms (Fig. 1a and 1b).
------------------------------------------------------------------------
-- The syntax of terms depends on the syntax of simple types
-- (because terms are indexed by types in ... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- The syntax of terms (Fig. 1a and 1b).
------------------------------------------------------------------------
-- The syntax of terms depends on the syntax of simple types
-- (because terms are indexed by types in ... | Remove remaining duplication between abs₁ ... abs₆ | Remove remaining duplication between abs₁ ... abs₆
This relies on Agda 2.4.0's varying arity in a more essential way.
| Agda | mit | inc-lc/ilc-agda |
05536450804504640dcab4d2a372088bbc7ef7b3 | src/fot/FOTC/Program/McCarthy91/PropertiesATP.agda | src/fot/FOTC/Program/McCarthy91/PropertiesATP.agda | ------------------------------------------------------------------------------
-- Main properties of the McCarthy 91 function
------------------------------------------------------------------------------
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
-- The main properties proved of the McCar... | ------------------------------------------------------------------------------
-- Main properties of the McCarthy 91 function
------------------------------------------------------------------------------
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
-- The main properties proved of the McCar... | Revert "Added a non-required totality hypothesis." | Revert "Added a non-required totality hypothesis."
This reverts commit 57708b770c00d1ba6276cda0f02752e147f2f533.
| Agda | mit | asr/fotc,asr/fotc |
f04e665aed5f41deea97dd4b7160ad5ee957e41a | Nehemiah/Change/Validity.agda | Nehemiah/Change/Validity.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Dependently typed changes with the Nehemiah plugin.
------------------------------------------------------------------------
module Nehemiah.Change.Validity where
open import Nehemiah.Syntax.Type
open import Nehem... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Dependently typed changes with the Nehemiah plugin.
------------------------------------------------------------------------
module Nehemiah.Change.Validity where
open import Nehemiah.Syntax.Type
open import Nehem... | Update Nehemiah.Change.Validity | Update Nehemiah.Change.Validity
* Adapt to weaker instance resolution.
* Omit module application that runs into agda/agda#1985.
| Agda | mit | inc-lc/ilc-agda |
94c667f3d542af3d0d5f3f603fe4d1aeccaf6e95 | New/Changes.agda | New/Changes.agda | module New.Changes where
open import Relation.Binary.PropositionalEquality
open import Level
open import Data.Unit
open import Data.Product
record IsChAlg {ℓ : Level} (A : Set ℓ) (Ch : Set ℓ) : Set (suc ℓ) where
field
_⊕_ : A → Ch → A
_⊝_ : A → A → Ch
valid : A → Ch → Set ℓ
⊝-valid : ∀ (a b : A) → v... | module New.Changes where
open import Relation.Binary.PropositionalEquality
open import Level
open import Data.Unit
open import Data.Product
open import Data.Sum
record IsChAlg {ℓ : Level} (A : Set ℓ) (Ch : Set ℓ) : Set (suc ℓ) where
field
_⊕_ : A → Ch → A
_⊝_ : A → A → Ch
valid : A → Ch → Set ℓ
⊝-va... | Add change structure for changes | Add change structure for changes
| Agda | mit | inc-lc/ilc-agda |
f1c2df98ed89a3de0f4b42407cb950eded1c5ed4 | total.agda | total.agda | module total where
-- INCREMENTAL λ-CALCULUS
-- with total derivatives
--
-- Features:
-- * changes and derivatives are unified (following Cai)
-- * Δ e describes how e changes when its free variables or its arguments change
-- * denotational semantics including semantics of changes
--
-- Note that Δ is *not* ... | module total where
-- INCREMENTAL λ-CALCULUS
-- with total derivatives
--
-- Features:
-- * changes and derivatives are unified (following Cai)
-- * Δ e describes how e changes when its free variables or its arguments change
-- * denotational semantics including semantics of changes
--
-- Note that Δ is *not* ... | Increase overloading and confusion. | Increase overloading and confusion.
Old-commit-hash: df682306832e5b833f837c92dec32b3c428a7ab9
| Agda | mit | inc-lc/ilc-agda |
757995f811b789374410d560566e8717a68f1e24 | Base/Change/Equivalence.agda | Base/Change/Equivalence.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Delta-observational equivalence
------------------------------------------------------------------------
module Base.Change.Equivalence where
open import Relation.Binary.PropositionalEquality
open import Base.Chang... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Delta-observational equivalence
------------------------------------------------------------------------
module Base.Change.Equivalence where
open import Relation.Binary.PropositionalEquality
open import Base.Chang... | Revert "Show how badly reasoning for ≙ and ≡ combine" | Revert "Show how badly reasoning for ≙ and ≡ combine"
This reverts commit 24faa2c5edd91d1db64977d5124ef40e01de433f. The commit
showed how badly something worked, so let's leave in the old version for
now.
Old-commit-hash: 9f5f49cf0319ba809356655a204ec83725dfceb4
| Agda | mit | inc-lc/ilc-agda |
c1d53d1c793d91e002e6c8b4ffbbcc8dca4c6eda | README.agda | README.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Machine-checked formalization of the theoretical results presented
-- in the paper:
--
-- Yufei Cai, Paolo G. Giarrusso, Tillmann Rendel, Klaus Ostermann.
-- A Theory of Changes for Higher-Order Languages:
-- ... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Machine-checked formalization of the theoretical results presented
-- in the paper:
--
-- Yufei Cai, Paolo G. Giarrusso, Tillmann Rendel, Klaus Ostermann.
-- A Theory of Changes for Higher-Order Languages:
-- ... | Update recommended version of Agda | README.agda: Update recommended version of Agda
Rationale: 2.4.0 doesn't install any more.
| Agda | mit | inc-lc/ilc-agda |
464a985aa70ecceb7a7917d62fc7cb3e05dd59c2 | models/Desc.agda | models/Desc.agda | {-# OPTIONS --type-in-type
--no-termination-check
--no-positivity-check #-}
module Desc where
--********************************************
-- Prelude
--********************************************
-- Some preliminary stuffs, to avoid relying on the stdlib
--****************
-- Sigma and fr... | {-# OPTIONS --type-in-type #-}
module Desc where
--********************************************
-- Prelude
--********************************************
-- Some preliminary stuffs, to avoid relying on the stdlib
--****************
-- Sigma and friends
--****************
data Sigma (A : Set) (B : A -> Set) : Set ... | Update Desc model. Follow ICFP paper. With type-in-type, but termination-checker-friendly. | Update Desc model. Follow ICFP paper. With type-in-type, but termination-checker-friendly. | Agda | mit | kwangkim/pigment,kwangkim/pigment,brixen/Epigram,kwangkim/pigment |
7f1a4e72fc0081b46fe06904e4627bb80b3240ac | proposal/examples/TacticsMatchingFunctionCalls.agda | proposal/examples/TacticsMatchingFunctionCalls.agda | {-
This file demonstrates a technique that simulates the ability to
pattern match against function calls rather than just variables
or constructors.
This technique is necessary to write certain kinds of tactics
as generic functions.
-}
module TacticsMatchingFunctionCalls where
open import Data.Bool hiding ( _≟_ )
op... | {-
This file demonstrates a technique that simulates the ability to
pattern match against function calls rather than just variables
or constructors.
This technique is necessary to write certain kinds of tactics
as generic functions.
-}
module TacticsMatchingFunctionCalls where
open import Data.Bool hiding ( _≟_ )
op... | Add Coq's "simp" tactic. | Add Coq's "simp" tactic.
| Agda | bsd-3-clause | spire/spire |
71b3a14edcb512975548e8df67858a30b1f62d68 | Syntax/Term/Plotkin.agda | Syntax/Term/Plotkin.agda | import Syntax.Type.Plotkin as Type
import Syntax.Context as Context
module Syntax.Term.Plotkin
{B : Set {- of base types -}}
{C : Context.Context {Type.Type B} → Type.Type B → Set {- of constants -}}
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Pr... | import Syntax.Type.Plotkin as Type
import Syntax.Context as Context
module Syntax.Term.Plotkin
{B : Set {- of base types -}}
{C : Context.Context {Type.Type B} → Type.Type B → Set {- of constants -}}
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Pr... | Rename TermConstructor to CurriedTermConstructor. | Rename TermConstructor to CurriedTermConstructor.
This rename prepares for introducing UncurriedTermConstructor which
will allow to clarify the role of lift-η-const-rec.
Old-commit-hash: b9de3c413f5a2a2015d3114bfb8483ab3078cc06
| Agda | mit | inc-lc/ilc-agda |
6538c1e3a868c0dc095139fc2243a8683b77c995 | Data/NatBag/Properties.agda | Data/NatBag/Properties.agda | module Data.NatBag.Properties where
import Data.Nat as ℕ
open import Relation.Binary.PropositionalEquality
open import Data.NatBag
open import Data.Integer
open import Data.Sum hiding (map)
open import Data.Product hiding (map)
-- This import is too slow.
-- It causes Agda 2.3.2 to use so much memory that cai's
-- co... | module Data.NatBag.Properties where
import Data.Nat as ℕ
open import Relation.Binary.PropositionalEquality
open import Data.NatBag
open import Data.Integer
open import Data.Sum hiding (map)
open import Data.Product hiding (map)
-- This import is too slow.
-- It causes Agda 2.3.2 to use so much memory that cai's
-- co... | Remove dead code of Data.NatBag.Properties Checkpoint: Recast property proofs using set theoretic methods (#55) | Remove dead code of Data.NatBag.Properties
Checkpoint: Recast property proofs using set theoretic methods (#55)
Old-commit-hash: 04b32e5d92152cdab089a25c0d8f9f4c39279fb0
| Agda | mit | inc-lc/ilc-agda |
2971c097d16d13188929ef857808539310db0b8e | meaning.agda | meaning.agda | module meaning where
open import Level
record Meaning (Syntax : Set) {ℓ : Level} : Set (suc ℓ) where
constructor
meaning
field
{Semantics} : Set ℓ
⟦_⟧ : Syntax → Semantics
open Meaning {{...}} public
| module meaning where
open import Level
record Meaning (Syntax : Set) {ℓ : Level} : Set (suc ℓ) where
constructor
meaning
field
{Semantics} : Set ℓ
⟨_⟩⟦_⟧ : Syntax → Semantics
open Meaning {{...}} public
renaming (⟨_⟩⟦_⟧ to ⟦_⟧)
open Meaning public
using (⟨_⟩⟦_⟧)
| Improve printing of resolved overloading. | Improve printing of resolved overloading.
After this change, the semantic brackets will contain the syntactic
thing even if Agda displays explicitly resolved overloaded notation.
Old-commit-hash: c8cbc43ed8e715342e0cc3bccc98e0be2dd23560
| Agda | mit | inc-lc/ilc-agda |
b5190556d5bc58a768c39b9fa871dea8b2d6f0f1 | Parametric/Change/Term.agda | Parametric/Change/Term.agda | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.Type as ChangeType
module Parametric.Change.Term
{Base : Set}
(Constant : Term.Structure Base)
(ΔBase : ChangeType.Structure Base)
where
-- Terms that operate on changes
open Type.Structure Base
open Te... | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.Type as ChangeType
module Parametric.Change.Term
{Base : Set}
(Constant : Term.Structure Base)
(ΔBase : ChangeType.Structure Base)
where
-- Terms that operate on changes
open Type.Structure Base
open Te... | Fix bug in diff-term. | Fix bug in diff-term.
Old-commit-hash: 01ada999b676d2a8a2ab289b3a0c79f1524620e5
| Agda | mit | inc-lc/ilc-agda |
011116b87218eb84d5010b97f93c495b4f090fae | incremental.agda | incremental.agda | module incremental where
-- SIMPLE TYPES
-- Syntax
data Type : Set where
_⇒_ : (τ₁ τ₂ : Type) → Type
infixr 5 _⇒_
-- Semantics
Dom⟦_⟧ : Type -> Set
Dom⟦ τ₁ ⇒ τ₂ ⟧ = Dom⟦ τ₁ ⟧ → Dom⟦ τ₂ ⟧
-- TYPING CONTEXTS
-- Syntax
data Context : Set where
∅ : Context
_•_ : (τ : Type) (Γ : Context) → Context
infixr 9 _... | module incremental where
-- SIMPLE TYPES
-- Syntax
data Type : Set where
_⇒_ : (τ₁ τ₂ : Type) → Type
infixr 5 _⇒_
-- Semantics
Dom⟦_⟧ : Type -> Set
Dom⟦ τ₁ ⇒ τ₂ ⟧ = Dom⟦ τ₁ ⟧ → Dom⟦ τ₂ ⟧
-- TYPING CONTEXTS
-- Syntax
data Context : Set where
∅ : Context
_•_ : (τ : Type) (Γ : Context) → Context
infixr 9 _... | Implement nil changes. | Implement nil changes.
Old-commit-hash: da546d60ec48fe5f6f8b261aac1fdbb71b18fa69
| Agda | mit | inc-lc/ilc-agda |
f2fde70dc52c3050e537b787efd3c7efa9778118 | Syntax/Term/Plotkin.agda | Syntax/Term/Plotkin.agda | import Syntax.Type.Plotkin as Type
import Syntax.Context as Context
module Syntax.Term.Plotkin
{B : Set {- of base types -}}
{C : Context.Context {Type.Type B} → Type.Type B → Set {- of constants -}}
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Pr... | import Syntax.Type.Plotkin as Type
import Syntax.Context as Context
module Syntax.Term.Plotkin
{B : Set {- of base types -}}
{C : Context.Context {Type.Type B} → Type.Type B → Set {- of constants -}}
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Pr... | Introduce HOAS-like smart constructors for lambdas | Introduce HOAS-like smart constructors for lambdas
Old-commit-hash: 6bf4939f8ec84c611d98f6f2395332943573dfe5
| Agda | mit | inc-lc/ilc-agda |
8514aefef6973b813691fb922e6d44e072cfc75d | generic-zero-knowledge-interactive.agda | generic-zero-knowledge-interactive.agda | open import Type
open import Data.Bool.NP as Bool hiding (check)
open import Data.Nat
open import Data.Maybe
open import Data.Product.NP
open import Data.Bits
open import Function.NP
open import Relation.Binary.PropositionalEquality.NP
open import sum
module generic-zero-knowledge-interactive where
-- A random argum... | open import Type
open import Data.Bool.NP as Bool hiding (check)
open import Data.Nat
open import Data.Maybe
open import Data.Product.NP
open import Data.Bits
open import Function.NP
open import Relation.Binary.PropositionalEquality.NP
open import sum
module generic-zero-knowledge-interactive where
-- A random argum... | update generic ZK | update generic ZK
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
569e98b5b6d8a84329f54249ad3f83477357f717 | flipbased-implem.agda | flipbased-implem.agda | module flipbased-implem where
open import Function
open import Data.Bits
open import Data.Nat.NP
open import Data.Vec
open import Relation.Binary
import Relation.Binary.PropositionalEquality as ≡
import Data.Fin as Fin
open ≡ using (_≗_; _≡_)
open Fin using (Fin; suc)
import flipbased
-- “↺ n A” reads like: “toss n ... | module flipbased-implem where
open import Function
open import Data.Bits
open import Data.Nat.NP
open import Data.Vec
open import Relation.Binary
import Relation.Binary.PropositionalEquality as ≡
import Data.Fin as Fin
open ≡ using (_≗_; _≡_)
open Fin using (Fin; suc)
import flipbased
-- “↺ n A” reads like: “toss n ... | Switch count↺ to be based on search | Switch count↺ to be based on search
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
b590f8a3ed001a65516e5f2211013e1a46683692 | ZK/PartialHeliosVerifier.agda | ZK/PartialHeliosVerifier.agda | {-# OPTIONS --without-K #-}
module ZK.PartialHeliosVerifier where
open import Type
open import Function hiding (case_of_)
open import Data.Bool.Base
open import Data.Product
open import Data.List.Base using (List; []; _∷_; and; foldr)
open import Data.String.Base using (String)
open import FFI.JS as JS hiding (_+_; ... | {-# OPTIONS --without-K #-}
module ZK.PartialHeliosVerifier where
open import Type
open import Function hiding (case_of_)
open import Data.Bool.Base
open import Data.Product
open import Data.List.Base using (List; []; _∷_; and; foldr)
open import Data.String.Base using (String)
open import FFI.JS as JS hiding (_+_; ... | Update binds | Update binds
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
24e0a0189105b8f3f2766a604a1ad5423b51b77e | Parametric/Change/Derive.agda | Parametric/Change/Derive.agda | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.Type as ChangeType
module Parametric.Change.Derive
{Base : Type.Structure}
(Const : Term.Structure Base)
(ΔBase : ChangeType.Structure Base)
where
open Type.Structure Base
open Term.Structure Base Const
... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Incrementalization as term-to-term transformation (Fig. 4g).
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
impo... | Document P.C.Derive. | Document P.C.Derive.
Old-commit-hash: 962425cf9bb190e1b8fb2c400bd9765180081dd0
| Agda | mit | inc-lc/ilc-agda |
8d4599155dc64db203782bdd39087df1a8014331 | Popl14/Change/Term.agda | Popl14/Change/Term.agda | module Popl14.Change.Term where
-- Terms Calculus Popl14
--
-- Contents
-- - Term constructors
-- - Weakening on terms
-- - `fit`: weaken a term to its ΔContext
-- - diff-term, apply-term and their syntactic sugars
open import Data.Integer
open import Popl14.Syntax.Type public
open import Popl14.Syntax.Term public
o... | module Popl14.Change.Term where
-- Terms Calculus Popl14
--
-- Contents
-- - Term constructors
-- - Weakening on terms
-- - `fit`: weaken a term to its ΔContext
-- - diff-term, apply-term and their syntactic sugars
open import Data.Integer
open import Popl14.Syntax.Type public
open import Popl14.Syntax.Term public
o... | Move (apply|diff)-base to the top of the module. | Move (apply|diff)-base to the top of the module.
This commit separates the POPL14-specific code from the
language-independent code in this module. The following commits will
remove the language-independent code.
Old-commit-hash: 245a7b618b2ac811d28d702089482e9aed8b8425
| Agda | mit | inc-lc/ilc-agda |
c68a9b8870e9eaca8c1a746f2ec67e2c84d97fd5 | Crypto/JS/BigI/CyclicGroup.agda | Crypto/JS/BigI/CyclicGroup.agda | {-# OPTIONS --without-K #-}
open import Type.Eq
open import FFI.JS using (JS[_]; return; Bool; _++_; _>>_)
open import FFI.JS.Check using (check!)
open import FFI.JS.BigI
open import Data.List.Base using (List; foldr)
open import Data.Two hiding (_==_)
open import Relation.Binary.PropositionalEquality
open import Alge... | {-# OPTIONS --without-K #-}
open import Type.Eq
open import FFI.JS using (JS[_]; return; _++_; _>>_)
open import FFI.JS.Check using (check!)
open import FFI.JS.BigI
open import Data.List.Base using (List; foldr)
open import Data.Two hiding (_==_)
open import Relation.Binary.PropositionalEquality
open import Algebra.Ra... | remove useless import | CyclicGroup: remove useless import
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
3a1143b9db99b9ec7e1431f08aab91f27cf9bd7a | Postulate/Extensionality.agda | Postulate/Extensionality.agda | module Postulate.Extensionality where
-- POSTULATE EXTENSIONALITY
--
-- Justification on Agda mailing list:
-- http://permalink.gmane.org/gmane.comp.lang.agda/2343
open import Relation.Binary.PropositionalEquality
postulate ext : ∀ {a b} → Extensionality a b
-- Convenience of using extensionality 3 times in a row
-... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Postulate extensionality of functions.
--
-- Justification on Agda mailing list:
-- http://permalink.gmane.org/gmane.comp.lang.agda/2343
------------------------------------------------------------------------
modu... | Document Postulate.Extensionality regularly. | Document Postulate.Extensionality regularly.
Old-commit-hash: 35222e92088dbd2313ec7252e50cd68e85b340bf
| Agda | mit | inc-lc/ilc-agda |
e7d0ffc6976dc3270e58e80326cf78dc7e9dcb2e | flat-funs.agda | flat-funs.agda | module flat-funs where
open import Data.Nat
import Level as L
open import composable
open import vcomp
record FlatFuns {t} (T : Set t) : Set (L.suc t) where
constructor mk
field
`⊤ : T
`Bit : T
_`×_ : T → T → T
_`^_ : T → ℕ → T
_`→_ : T → T → Set
`Vec : T → ℕ → T
`Vec A n = A `^ n
... | module flat-funs where
open import Data.Nat
open import Data.Bits using (Bits)
import Level as L
import Function as F
open import composable
open import vcomp
open import universe
record FlatFuns {t} (T : Set t) : Set (L.suc t) where
constructor mk
field
universe : Universe T
_`→_ : T → T → Set
infix... | put the type interface in the universe module | flat-funs: put the type interface in the universe module
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.