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 |
|---|---|---|---|---|---|---|---|---|---|
f994df78d5187cf478e9bd11ea4ef31f16894f95 | New/NewNew.agda | New/NewNew.agda | module New.NewNew where
open import New.Changes
open import New.LangChanges
open import New.Lang
open import New.Types
open import New.Derive
[_]_from_to_ : ∀ (τ : Type) → (dv : Cht τ) → (v1 v2 : ⟦ τ ⟧Type) → Set
[ σ ⇒ τ ] df from f1 to f2 =
∀ (da : Cht σ) (a1 a2 : ⟦ σ ⟧Type) →
[ σ ] da from a1 to a2 → [ τ ] df a... | module New.NewNew where
open import New.Changes
open import New.LangChanges
open import New.Lang
open import New.Types
open import New.Derive
[_]_from_to_ : ∀ (τ : Type) → (dv : Cht τ) → (v1 v2 : ⟦ τ ⟧Type) → Set
[ σ ⇒ τ ] df from f1 to f2 =
∀ (da : Cht σ) (a1 a2 : ⟦ σ ⟧Type) →
[ σ ] da from a1 to a2 → [ τ ] df a... | Hide deducible arguments | NewNew.agda: Hide deducible arguments
| Agda | mit | inc-lc/ilc-agda |
1ae2c016233ad8fa076a9b194e880387b889b8b0 | Search/Searchable/Sum.agda | Search/Searchable/Sum.agda | open import Function.NP
open import Data.Nat using (_+_)
import Level as L
import Function.Inverse.NP as FI
import Function.Related as FR
open FI using (_↔_; inverses; module Inverse) renaming (_$₁_ to to; _$₂_ to from)
open import Function.Related.TypeIsomorphisms.NP
open import Data.Product.NP
open import Data.Sum
op... | open import Function.NP
open import Data.Nat using (_+_)
import Level as L
import Function.Inverse.NP as FI
import Function.Related as FR
open FI using (_↔_; inverses; module Inverse) renaming (_$₁_ to to; _$₂_ to from)
open import Function.Related.TypeIsomorphisms.NP
open import Data.Product.NP
open import Data.Sum
op... | add bit | Searchable.Sum: add bit
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
7540b79d7380f6d1c7ca7db983d990a2aab84b00 | lib/Explore/GroupHomomorphism.agda | lib/Explore/GroupHomomorphism.agda | {-# OPTIONS --without-K #-}
module Explore.GroupHomomorphism where
open import Level
open import Algebra.FunctionProperties
open import Data.Product
open import Function using (_∘_ ; flip)
open import Function.Inverse as Inv using (_↔_; module Inverse)
open import Relation.Binary.PropositionalEquality.NP hiding (_∙_)
... | {-# OPTIONS --without-K #-}
module Explore.GroupHomomorphism where
open import Level
open import Algebra.FunctionProperties
open import Data.Product
open import Function using (_∘_ ; flip)
open import Function.Inverse as Inv using (_↔_; module Inverse)
open import Relation.Binary.PropositionalEquality.NP hiding (_∙_)
... | refactor grouphomomorphism | refactor grouphomomorphism
| Agda | bsd-3-clause | crypto-agda/explore |
e4762e8af8591526fcb5395b9c63888ed89cadd2 | Syntax/Type/Plotkin.agda | Syntax/Type/Plotkin.agda | module Syntax.Type.Plotkin where
-- Types for language description à la Plotkin (LCF as PL)
--
-- Given base types, we build function types.
infixr 5 _⇒_
data Type (B : Set {- of base types -}) : Set where
base : (ι : B) → Type B
_⇒_ : (σ : Type B) → (τ : Type B) → Type B
-- Lift (Δ : B → B) to (Δtype : Type B ... | module Syntax.Type.Plotkin where
-- Types for language description à la Plotkin (LCF as PL)
--
-- Given base types, we build function types.
infixr 5 _⇒_
data Type (B : Set {- of base types -}) : Set where
base : (ι : B) → Type B
_⇒_ : (σ : Type B) → (τ : Type B) → Type B
-- Lift (Δ : B → Type B) to (Δtype : Ty... | Remove code duplication | agda: Remove code duplication
The current code defines two overloads of the same function independently, with
duplicated documentation. However, one can be defined in terms of the other.
Note: I could not fully test this code, since it is not yet clear which file is
the main one. I typechecked Syntax.Language.Atlas, ... | Agda | mit | inc-lc/ilc-agda |
23339dd5a9e56c3c31d42252c4020b716ec77725 | Base/Change/Algebra.agda | Base/Change/Algebra.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Change Structures.
--
-- This module defines the notion of change structures,
-- as well as change structures for groups, functions and lists.
--
-- This module corresponds to Section 2 of the PLDI paper.
----------... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Change Structures.
--
-- This module defines the notion of change structures,
-- as well as change structures for groups, functions and lists.
--
-- This module corresponds to Section 2 of the PLDI paper.
----------... | Update references to paper | Update references to paper
During revision, I added Lemma 2.5 to the paper, changing the numbering.
This commits updates the numbering in the formalization.
| Agda | mit | inc-lc/ilc-agda |
2f337fa6c912b4b71f8a6539911608241ebc8524 | 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... | Use helpers for nested applications. | Use helpers for nested applications.
Old-commit-hash: e4c7562ec14ff04d00f64f84b95725baa11a85ca
| Agda | mit | inc-lc/ilc-agda |
561e54d6fa752c3e41e0261fcb95b5fe132461b5 | 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 lift-η-const-rec to curryTermConstructor. | Rename lift-η-const-rec to curryTermConstructor.
Also delete the frivolous comment, which is no longer necessary
now that curryTermConstructor has a descriptive name and the
matching type signature.
Old-commit-hash: bcd82c9b32ab89ebe5c1badbec2d5714d0fce9bf
| Agda | mit | inc-lc/ilc-agda |
6e6a81d4cd5e6747138da920db56cf5c044c974c | 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* ... | rename parameter | agda: rename parameter
As suggested by Tillmann.
Old-commit-hash: 3b2f1506d9fc2595f06fb0d8e57a526bc30b03ac
| Agda | mit | inc-lc/ilc-agda |
b50b0f77764d63042aa5a88075d4320129b3681a | Syntactic/Terms/Total.agda | Syntactic/Terms/Total.agda | module Syntactic.Terms.Total where
-- TERMS with a primitive for TOTAL DERIVATIVES
--
-- This module defines the syntax of terms that support a
-- primitive (Δ e) for computing the total derivative according
-- to all free variables in e and all future arguments of e if e
-- is a function.
open import Syntactic.Types... | module Syntactic.Terms.Total where
-- TERMS with a primitive for TOTAL DERIVATIVES
--
-- This module defines the syntax of terms that support a
-- primitive (Δ e) for computing the total derivative according
-- to all free variables in e and all future arguments of e if e
-- is a function.
open import Syntactic.Types... | Change order of implicit arguments of term constructors. | Change order of implicit arguments of term constructors.
This simplifies extracting the argument type from a term
of function type.
Old-commit-hash: 2742a31a130e9d01c2283f3e7cb7fae6102a4062
| Agda | mit | inc-lc/ilc-agda |
53ffa41592e8de74ad057626e193d26cc8e3b78b | Theorem/Groups-Nehemiah.agda | Theorem/Groups-Nehemiah.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- About the group structure of integers and bags for Nehemiah plugin.
------------------------------------------------------------------------
module Theorem.Groups-Nehemiah where
open import Structure.Bag.Nehemiah ... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- About the group structure of integers and bags for Nehemiah plugin.
------------------------------------------------------------------------
module Theorem.Groups-Nehemiah where
open import Structure.Bag.Nehemiah ... | reorder theorems | Groups-Nehemiah: reorder theorems
| Agda | mit | inc-lc/ilc-agda |
8bb712cd1a8c9c9cc0885ef29918d9cc47588189 | Parametric/Denotation/Evaluation.agda | Parametric/Denotation/Evaluation.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Evaluation for languages described in Plotkin style
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parame... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Standard evaluation (Def. 3.3 and Fig. 4i)
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Deno... | Document P.D.Evaluation. | Document P.D.Evaluation.
Old-commit-hash: a346d6ffd091c3041ecb8d087a4171aeffa63576
| Agda | mit | inc-lc/ilc-agda |
7b8de230698933472e580b5ece63a74cf55998a4 | 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}
(Const : Term.Structure Base)
(ΔBase : ChangeType.Structure Base)
where
-- Terms that operate on changes
open Type.Structure Base
open Term.... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Terms that operate on changes (Fig. 3).
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.... | Document P.C.Term. | Document P.C.Term.
Old-commit-hash: 0263f48a6674e209dc10d253b3ffab2671e313cd
| Agda | mit | inc-lc/ilc-agda |
1da8d765d3b45cbc385435bbd6c113c680b6f896 | 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... | Generalize helper methods. | Generalize helper methods.
Before this commit, the helper methods worked for one particular context
that was inferred from the helper's use sites. I want to change the
helper's use suite in the next commit so that the context would no
longer get inferred automatically, so I have to generalize the helper
methods for ar... | Agda | mit | inc-lc/ilc-agda |
ef0b3de030e69c13f6abe2f657976fd6056b39d2 | example1.agda | example1.agda | module example1 where
open import Data.String.Base using (String)
open import Data.Product
open import Data.List.Base using (List; []; _∷_)
open import Data.Bool.Base
open import Function
open import Control.Process.Type
open import FFI.JS as JS
open import FFI.JS.Proc
import FFI.JS.Console as Console
import FFI.JS.... | module example1 where
open import Data.String.Base using (String)
open import Data.Product
open import Data.List.Base using (List; []; _∷_)
open import Data.Bool.Base
open import Function
open import Control.Process.Type
open import FFI.JS as JS
open import FFI.JS.Proc
import FFI.JS.Console as Console
import FFI.JS.... | Update example1 | Update example1
| Agda | bsd-3-clause | crypto-agda/agda-libjs |
b3651f102b65a31ef5dd4d541002915b3e5cc9fe | Base/Data/DependentList.agda | Base/Data/DependentList.agda | module Base.Data.DependentList where
open import Data.List.All public
using
( head
; tail
; map
; tabulate
)
renaming
( All to DependentList
; _∷_ to _•_
; [] to ∅
)
zipWith : ∀ {a p q r} {A : Set a} {P : A → Set p} {Q : A → Set q} {R : A → Set r} →
(f : {a : A} → P a → Q a →... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Reexport Data.List.All from the standard library.
--
-- At one point, we reinvented Data.List.All from the Agda
-- standard library, under the name dependent list. We later
-- replaced our reinvention by this adapte... | Improve commentary in Base.Data.DependentList. | Improve commentary in Base.Data.DependentList.
Old-commit-hash: 7a4d9aea2f3574b1b3f21022bced5f9ef112264c
| Agda | mit | inc-lc/ilc-agda |
eea966329ff9f953b7330cd87ef1188ffe40f0f0 | 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.Syntax.MType as MType
impor... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Caching evaluation
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Syntax.MType as MType
impor... | Correct caching for constants (by delegation) | Correct caching for constants (by delegation)
This defines the plugin interface for constants (with a type that makes
semantic sense), and delegates to that, while stipulating:
* what are the appropriate types;
* that constant arguments needn't be cached because they are values.
| Agda | mit | inc-lc/ilc-agda |
308d57f744384b21a2811f278b455dfb952dd324 | Syntax/Language/Popl14.agda | Syntax/Language/Popl14.agda | module Syntax.Language.Popl14 where
open import Syntax.Term.Popl14
open import Syntax.Context.Plotkin Popl14-type
open import Data.Integer
| module Syntax.Language.Popl14 where
open import Syntax.Term.Popl14
open import Syntax.Context.Plotkin Popl14-type
open import Data.Integer
import Syntax.Language.Calculus as Calc
ΔConst : ∀ {Γ Σ τ} →
Const Σ τ →
Term Γ
(internalizeContext
(Calc.ΔContext′ (Calc.Type Popl14-type) ΔType Σ) (ΔType τ))
--... | Define ΔConst for Popl14 and fill in calculus-with | Define ΔConst for Popl14 and fill in calculus-with
Old-commit-hash: c1cdbc71d45afdb85da9ac22b3207d1cb03e0bf7
| Agda | mit | inc-lc/ilc-agda |
5ea0220b999f1d1ef9f072ca4bedfb82dc747ca1 | 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... | Use a record for doe, as suggested by Tillmann | Use a record for doe, as suggested by Tillmann
Old-commit-hash: f1a0e47b6fd1c171f165e2a9ba96fd258042a8ae
| Agda | mit | inc-lc/ilc-agda |
de617d2ad76260052f9d6ecbf3c054fc7eb183ef | Parametric/Change/Value.agda | Parametric/Change/Value.agda | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Denotation.Value as Value
import Parametric.Change.Type as ChangeType
module Parametric.Change.Value
{Base : Type.Structure}
(Const : Term.Structure Base)
(⟦_⟧Base : Value.Structure Base)
(ΔBase : ChangeType.S... | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Denotation.Value as Value
import Parametric.Change.Type as ChangeType
module Parametric.Change.Value
{Base : Type.Structure}
(Const : Term.Structure Base)
(⟦_⟧Base : Value.Structure Base)
(ΔBase : ChangeType.S... | Remove unused imports violating architectural constraints | Agda: Remove unused imports violating architectural constraints
The parametric formalization shouldn't import stuff specific to the
POPL14 calculus.
Old-commit-hash: 30c3071e33a99422b2c878f7bca7937e8b1c216f
| Agda | mit | inc-lc/ilc-agda |
b0acfde8e76ff27fb9d7b8609c3d7acf1ccf1ef2 | PLDI14-List-of-Theorems.agda | PLDI14-List-of-Theorems.agda | module PLDI14-List-of-Theorems where
-- 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 names. For example,
-- after this file type check... | module PLDI14-List-of-Theorems where
-- 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 names. For example,
-- after this file type check... | update PLDI14-List-of-Theorems.agda for consistency with #4 | update PLDI14-List-of-Theorems.agda for consistency with #4
Camera-ready version inserts a "lemma 2.5", which means math items
2.5--2.9 should be renumbered 2.6--2.10.
Relevant commits:
23339dd5a9e56c3c31d42252c4020b716ec77725
0c1e97fbf3b62bddf23559545a4c801b4189cb29
| Agda | mit | inc-lc/ilc-agda |
8fbacc398d3d884274c0a5d0564e3802b8ff356b | lib/Explore/Dice.agda | lib/Explore/Dice.agda | {-# OPTIONS --without-K #-}
open import Type
open import Data.Fin using (Fin; zero; suc; #_)
import Function.Inverse.NP as Inv
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
open Inv using (_↔_)
open import Explore.Core
open import Explore.Properties
open import Explore.Explorable
open import Expl... | {-# OPTIONS --without-K #-}
open import Type
open import Data.Fin using (Fin; zero; suc; #_)
import Function.Inverse.NP as Inv
open import Relation.Binary.PropositionalEquality using (_≡_; refl)
open Inv using (_↔_)
open import Explore.Core
open import Explore.Properties
open import Explore.Explorable
open import Expl... | use the second flavor of Fin exploration to show that it behave as expected | Dice: use the second flavor of Fin exploration to show that it behave as expected
| Agda | bsd-3-clause | crypto-agda/explore |
c691b85f8bfd7f9b4a97533c4013b53d694c2eb0 | Parametric/Syntax/MTerm.agda | Parametric/Syntax/MTerm.agda | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Syntax.MType as MType
module Parametric.Syntax.MTerm
{Base : Type.Structure}
(Const : Term.Structure Base)
where
open Type.Structure Base
open MType.Structure Base
open Term.Structure Base Const
-- Our extension p... | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Syntax.MType as MType
module Parametric.Syntax.MTerm
{Base : Type.Structure}
(Const : Term.Structure Base)
where
open Type.Structure Base
open MType.Structure Base
open Term.Structure Base Const
-- Our extension p... | Drop more dead comments | Drop more dead comments
| Agda | mit | inc-lc/ilc-agda |
c1960f9f07f5b25dbb7225149d30534a5c8f3464 | Theorem/Groups-Nehemiah.agda | Theorem/Groups-Nehemiah.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- About the group structure of integers and bags for Nehemiah plugin.
------------------------------------------------------------------------
module Theorem.Groups-Nehemiah where
open import Structure.Bag.Nehemiah ... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- About the group structure of integers and bags for Nehemiah plugin.
------------------------------------------------------------------------
module Theorem.Groups-Nehemiah where
open import Structure.Bag.Nehemiah ... | add variant of 4-way-shuffle for naturals | Groups-Nehemiah: add variant of 4-way-shuffle for naturals
| Agda | mit | inc-lc/ilc-agda |
f8bd15f415762af0fce2117302889b7e97a25936 | 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 diff to diff-base. | Rename diff to diff-base.
I want to move code between Parametric.Syntax.Term and
Atlas.Syntax.Term, but I have to unify the naming conventions first.
Old-commit-hash: 73a829a379ce12d2c01dbaf184ae2d380ad9abb1
| Agda | mit | inc-lc/ilc-agda |
be6f1fa3a0adbb680ac349286c28d45c17722184 | Prob.agda | Prob.agda | module Prob where
open import Data.Bool
open import Data.Nat
open import Data.Vec
open import Function
open import Relation.Binary.PropositionalEquality.NP
open import Relation.Nullary
record ]0,1]-ops (]0,1] : Set) : Set where
field
1E : ]0,1]
_+E_ : ]0,1] → ]0,1] → ]0,1]
_·E_ : ]0,1] → ]0,1] → ... | module Prob where
open import Data.Bool
open import Data.Nat
open import Data.Vec
open import Data.Unit using (⊤)
open import Data.Empty using (⊥)
open import Function
open import Relation.Binary.PropositionalEquality.NP
open import Relation.Nullary
record ]0,1]-ops (]0,1] : Set) (_≤E_ : ]0,1] → ]0,1] → Set) : Set ... | Fix some concrete non-sense about the division | Fix some concrete non-sense about the division
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
a0c26d1d2731a3ccca7b00c77068c7bb3491ecab | 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... | {-# 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
... | rename ℤq to 𝔽 | FiniteField.JS: rename ℤq to 𝔽
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
0f09d9f4ac44a07ba808622a5206a04b696a6f76 | derivation.agda | derivation.agda | module derivation where
open import lambda
-- CHANGE TYPES
Δ-Type : Type → Type
Δ-Type (τ₁ ⇒ τ₂) = τ₁ ⇒ Δ-Type τ₂
Δ-Type bool = {!!}
apply : ∀ {τ Γ} → Term Γ (Δ-Type τ ⇒ τ ⇒ τ)
apply {τ₁ ⇒ τ₂} =
abs (abs (abs (app (app apply (app (var (that (that this))) (var this))) (app (var (that this)) (var this)))))
-- λd... | module derivation where
open import lambda
-- CHANGE TYPES
Δ-Type : Type → Type
Δ-Type (τ₁ ⇒ τ₂) = τ₁ ⇒ Δ-Type τ₂
Δ-Type bool = {!!}
apply : ∀ {τ Γ} → Term Γ (Δ-Type τ ⇒ τ ⇒ τ)
apply {τ₁ ⇒ τ₂} =
abs (abs (abs (app (app apply (app (var (that (that this))) (var this))) (app (var (that this)) (var this)))))
-- λd... | correct Δ-term, more comments | agda/derivation.agda: correct Δ-term, more comments
In the previous commit I forgot some comments and I forgot applying some
changes, something the typechecker unfortunately would not detect. Fix that.
Old-commit-hash: 9a72bde5058103929f5d3c0eda97b9850a5d7c9c
| Agda | mit | inc-lc/ilc-agda |
8f895d5906dc2d743ba0dc39c4f907e17931b4f9 | Denotational/ValidChanges.agda | Denotational/ValidChanges.agda | module Denotational.ValidChanges where
open import Data.Product
open import Data.Unit
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
open import Syntactic.Types
open import Denotational.Notation
open import Denotational.Values
open import Denotational.Equivalence
open import Changes
... | module Denotational.ValidChanges where
open import Data.Product
open import Data.Unit
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
open import Syntactic.Types
open import Denotational.Notation
open import Denotational.Values
open import Denotational.Equivalence
open import Changes
... | implement proof-decorated environments (#33) | agda: implement proof-decorated environments (#33)
Old-commit-hash: eb0097a135a39c572cfb62c967a388632b42f839
| Agda | mit | inc-lc/ilc-agda |
7c497fbc194526d5d3f1a4335a6f74574050c633 | TotalNaturalSemantics.agda | TotalNaturalSemantics.agda | module TotalNaturalSemantics where
open import Relation.Binary.PropositionalEquality
open import meaning
open import Model
--open import Changes
--open import ChangeContexts
open import binding Type ⟦_⟧Type
open import TotalTerms
-- NATURAL SEMANTICS
-- (without support for Δ for now)
-- Syntax
data Env : Context... | module TotalNaturalSemantics where
open import Relation.Binary.PropositionalEquality
open import meaning
open import Model
--open import Changes
--open import ChangeContexts
open import binding Type ⟦_⟧Type
open import TotalTerms
open import Relation.Binary.PropositionalEquality
-- NATURAL SEMANTICS
-- (without su... | Fix TotalNaturalSemantics.agda (fix #32). | Fix TotalNaturalSemantics.agda (fix #32).
Old-commit-hash: 3665667d355c2d049d92115cd27f98cc9dc4f3a2
| Agda | mit | inc-lc/ilc-agda |
3ecae75aaafb233597792507020b6d74bee0ecfe | Data/NatBag.agda | Data/NatBag.agda | -- An agda type isomorphic to bags of natural numbers
-- How to import this file from anywhere in the world
--
-- 1. M-x customize-group RET agda2 RET
-- 2. Look for the option `Agda2 Include Dirs`
-- 3. Insert "$ILC/agda", where $ILC is path to ILC repo on your computer
-- 4. "Save for future sessions"
-- 5. open imp... | -- An agda type isomorphic to bags of natural numbers
-- How to import this file from anywhere in the world
--
-- 1. M-x customize-group RET agda2 RET
-- 2. Look for the option `Agda2 Include Dirs`
-- 3. Insert "$ILC/agda", where $ILC is path to ILC repo on your computer
-- 4. "Save for future sessions"
-- 5. open imp... | Implement map, union, difference on bags of natural numbers (#51) | Implement map, union, difference on bags of natural numbers (#51)
TODO before closing the issue:
- Introduce bags and prove the stupid derivative of map correct.
Old-commit-hash: 76c8ff03739579a6839431ba637557395ccbf8b2
| Agda | mit | inc-lc/ilc-agda |
f44ff9c8dc76e1365c69137588490cc7705c8477 | Denotational/ValidChanges.agda | Denotational/ValidChanges.agda | module Denotational.ValidChanges where
open import Data.Product
open import Data.Unit
open import Relation.Binary.PropositionalEquality
open import Syntactic.Types
open import Denotational.Notation
open import Denotational.Values
open import Denotational.Equivalence
open import Changes
-- DEFINITION of valid chang... | module Denotational.ValidChanges where
open import Data.Product
open import Data.Unit
open import Relation.Binary.PropositionalEquality
open import Syntactic.Types
open import Denotational.Notation
open import Denotational.Values
open import Denotational.Equivalence
open import Changes
-- DEFINITION of valid chang... | rename datatype valid-Δ |-> Valid-Δ | agda: rename datatype valid-Δ |-> Valid-Δ
Old-commit-hash: 37b8db1e2601a886b5bcd31b170ad1560352b8a7
| Agda | mit | inc-lc/ilc-agda |
2c0998148ca4d0f531c98144173c0d27ec548b8a | ZK/Schnorr.agda | ZK/Schnorr.agda | module ZK.Schnorr where
open import Type
open import Data.Two
open import Relation.Binary.PropositionalEquality.NP
import ZK.Sigma-Protocol
module Shnorr-protocol
(G ℤq : ★)
(g : G)
(_^_ : G → ℤq → G)
(_·_ : G → G → G)
(_/_ : G → G → G)
(_+_ : ℤq → ℤq → ℤq)
(_*_ : ℤq → ℤq → ℤq... | open import Type using (Type)
open import Data.Bool.Minimal using (Bool) renaming (T to ✓)
open import Relation.Binary.PropositionalEquality.NP using (_≡_; idp; ap; ap₂; !_; module ≡-Reasoning)
open import ZK.Types using (Cyclic-group; module Cyclic-group
; Cyclic-group-properties; module Cyc... | Update and extend ZK/Schnorr | Update and extend ZK/Schnorr
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
70def950c8925dc369db199a79e13cb59ff30970 | adder.agda | adder.agda | {-# OPTIONS --without-K #-}
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... | {-# OPTIONS --without-K #-}
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... | use mapAccum | adder: use mapAccum
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
1b5c3931a31ac1d019f7a68f56a036201f92a46e | lambda.agda | lambda.agda | 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... | 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... | Fix mixed-if. | Fix mixed-if.
Old-commit-hash: 18ad0d9a08607bece81abf4bedc81a7763b56b9a
| Agda | mit | inc-lc/ilc-agda |
998682f0d09f06ad7918732abe550b386afe02e2 | Syntax/Type/Popl14.agda | Syntax/Type/Popl14.agda | module Syntax.Type.Popl14 where
-- Types of Calculus Popl14
infixr 5 _⇒_
data Type : Set where
int : Type
bag : Type
_⇒_ : (σ : Type) → (τ : Type) → Type
ΔType : Type → Type
ΔType int = int
ΔType bag = bag
ΔType (σ ⇒ τ) = σ ⇒ ΔType σ ⇒ ΔType τ
| module Syntax.Type.Popl14 where
-- Types of Calculus Popl14
data Popl14-type : Set where
base-int : Popl14-type
base-bag : Popl14-type
open import Syntax.Type.Plotkin Popl14-type public
pattern int = base base-int
pattern bag = base base-bag
Popl14-Δbase : Popl14-type → Popl14-type
Popl14-Δbase base-int = base... | Make Syntax.Type.Popl14 use Syntax.Type.Plotkin | Make Syntax.Type.Popl14 use Syntax.Type.Plotkin
Old-commit-hash: 031c97aee2022a85ee855ec3149f0f8cd160d5af
| Agda | mit | inc-lc/ilc-agda |
47b55ae0449921322131bd6dbdab41837ccb68c8 | 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
`Bits : ℕ → T
`Bit : T
_`×_ : T → T → T
_`→_ : T → T → Set
infixr 2 _`×_
infix 0 _`→_
record FlatFunsOps {t} {T ... | 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
... | Add support for general vector to our flat-funs abstraction | Add support for general vector to our flat-funs abstraction
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
fce4641e9e8aec601f2ab48e128ad529e5ac3a98 | Thesis/SIRelBigStep/DeriveCorrect.agda | Thesis/SIRelBigStep/DeriveCorrect.agda | --
-- In this module we conclude our proof: we have shown that t, derive-dterm t
-- and produce related values (in the sense of the fundamental property,
-- rfundamental3), and for related values v1, dv and v2 we have v1 ⊕ dv ≡
-- v2 (because ⊕ agrees with validity, rrelV3→⊕).
--
-- We now put these facts together via ... | --
-- In this module we conclude our proof: we have shown that t, derive-dterm t
-- and produce related values (in the sense of the fundamental property,
-- rfundamental3), and for related values v1, dv and v2 we have v1 ⊕ dv ≡
-- v2 (because ⊕ agrees with validity, rrelV3→⊕).
--
-- We now put these facts together via ... | Clarify the problem even more | Clarify the problem even more
| Agda | mit | inc-lc/ilc-agda |
6ecbb2d5d6f0f6024afa19dfbd12fdcad3b23439 | 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 _⇒_
-- Denotational Semantics
Dom⟦_⟧ : Type -> Set
Dom⟦ τ₁ ⇒ τ₂ ⟧ = Dom⟦ τ₁ ⟧ → Dom⟦ τ₂ ⟧
-- TYPING CONTEXTS
-- Syntax
data Context : Set where
∅ : Context
_•_ : (τ : Type) (Γ : Context) → Contex... | Implement natural semantics. | Implement natural semantics.
Natural semantics (= big-step operational semantics) came up in
a Skype chat with Paolo.
Old-commit-hash: 40138450230bdc6326bbd4d47b011921433466b1
| Agda | mit | inc-lc/ilc-agda |
64e621c3d2a135c31988f71656671c97b59d8eca | arrow.agda | arrow.agda | data Bool : Set where
true : Bool
false : Bool
_or_ : Bool → Bool → Bool
true or true = true
true or false = true
false or true = true
false or false = false
----------------------------------------
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
{-# BUILTIN NATURAL ℕ #-}
_≡_ : ℕ → ℕ → Bool
zero ≡ zero ... | data Bool : Set where
true : Bool
false : Bool
_or_ : Bool → Bool → Bool
true or true = true
true or false = true
false or true = true
false or false = false
----------------------------------------
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
{-# BUILTIN NATURAL ℕ #-}
_≡_ : ℕ → ℕ → Bool
zero ≡ zero ... | Add separations | Add separations
| Agda | mit | louisswarren/hieretikz |
af9d23c116a68842dcbe0843b111aba0220b3560 | Atlas/Change/Term.agda | Atlas/Change/Term.agda | module Atlas.Change.Term where
open import Atlas.Syntax.Type
open import Atlas.Syntax.Term
open import Atlas.Change.Type
-- nil-changes
nil-const : ∀ {ι : Base} → Const ∅ (base (ΔBase ι))
nil-const {ι} = neutral {ΔBase ι}
nil-term : ∀ {ι Γ} → Term Γ (base (ΔBase ι))
nil-term {Bool} = curriedConst (nil-const {Boo... | module Atlas.Change.Term where
open import Atlas.Syntax.Type
open import Atlas.Syntax.Term
open import Atlas.Change.Type
-- nil-changes
nil-const : ∀ {ι : Base} → Const ∅ (base (ΔBase ι))
nil-const {ι} = neutral {ΔBase ι}
nil-term : ∀ {ι Γ} → Term Γ (base (ΔBase ι))
nil-term {Bool} = curriedConst (nil-const {Boo... | Rename Atlas-apply to apply-base. | Rename Atlas-apply to apply-base.
Old-commit-hash: aa571d5b9c41b6b4aa16886b55721dc3dbd9e033
| Agda | mit | inc-lc/ilc-agda |
aa15436d10416e76d1a5f6494f6bf9dfde53c404 | Thesis/SIRelBigStep/DSyntax.agda | Thesis/SIRelBigStep/DSyntax.agda | module Thesis.SIRelBigStep.DSyntax where
open import Thesis.SIRelBigStep.Syntax public
-- data DType : Set where
-- _⇒_ : (σ τ : DType) → DType
-- int : DType
DType = Type
import Base.Syntax.Context
module DC = Base.Syntax.Context DType
Δτ : Type → DType
Δτ (σ ⇒ τ) = σ ⇒ Δτ σ ⇒ Δτ τ
Δτ (pair τ1 τ2) = pair (Δτ τ... | module Thesis.SIRelBigStep.DSyntax where
open import Thesis.SIRelBigStep.Syntax public
-- data DType : Set where
-- _⇒_ : (σ τ : DType) → DType
-- int : DType
DType = Type
import Base.Syntax.Context
module DC = Base.Syntax.Context DType
Δτ : Type → DType
Δτ (σ ⇒ τ) = σ ⇒ Δτ σ ⇒ Δτ τ
Δτ (pair τ1 τ2) = pair (Δτ τ... | Drop unused redundant case | Drop unused redundant case
| Agda | mit | inc-lc/ilc-agda |
9e3f211e88b705e21001d83b692c5504a15a4f1a | lib/Data/Bits.agda | lib/Data/Bits.agda | module Data.Bits where
-- cleanup
open import Category.Applicative
open import Category.Monad
open import Data.Nat.NP hiding (_≤_; _==_)
open import Data.Nat.DivMod
open import Data.Bool.NP hiding (_==_)
open import Data.Bool.Properties using (not-involutive)
open import Data.Maybe
import Data.Fin as Fin
open Fin usin... | module Data.Bits where
-- cleanup
open import Category.Applicative
open import Category.Monad
open import Data.Nat.NP hiding (_≤_; _==_)
open import Data.Nat.DivMod
open import Data.Bool.NP hiding (_==_)
open import Data.Bool.Properties using (not-involutive)
open import Data.Maybe
import Data.Fin as Fin
open Fin usin... | use 2^ instead of _^_ 2 in allBits and #⟨_⟩ | Data.Bits: use 2^ instead of _^_ 2 in allBits and #⟨_⟩
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
00065eb75ec8eb897e66dfd3bfb4c202d976fd57 | Denotational/Values.agda | Denotational/Values.agda | module Denotational.Values where
-- VALUES
--
-- This module defines the model theory of simple types, that is,
-- it defines for every type, the set of values of that type.
--
-- In fact, we only describe a single model here.
import Relation.Binary as B
open import Relation.Binary using
(IsEquivalence; Setoid; Re... | module Denotational.Values where
-- VALUES
--
-- This module defines the model theory of simple types, that is,
-- it defines for every type, the set of values of that type.
--
-- In fact, we only describe a single model here.
open import Data.Bool public
import Relation.Binary as B
open import Relation.Binary usin... | Use booleans from Data.Bool (fix #31). | Use booleans from Data.Bool (fix #31).
Old-commit-hash: c2de96202cc68d0b06b45d3c977bdf935e14eec1
| Agda | mit | inc-lc/ilc-agda |
64a0d4678c9a3cfe69e473c9b5f335cd071c1e13 | Parametric/Change/Validity.agda | Parametric/Change/Validity.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Dependently typed changes (Def 3.4 and 3.5, Fig. 4b and 4e)
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Denotation.Value as Value... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Dependently typed changes (Def 3.4 and 3.5, Fig. 4b and 4e)
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Denotation.Value as Value... | Move import to more sensible place | Move import to more sensible place
| Agda | mit | inc-lc/ilc-agda |
a6bbe5d2b2206e1090e8303580a73956ec707683 | formalization/agda/Spire/Examples/DarkwingDuck/Primitive.agda | formalization/agda/Spire/Examples/DarkwingDuck/Primitive.agda | module Spire.Examples.DarkwingDuck.Primitive where
----------------------------------------------------------------------
infixr 4 _,_
infixr 5 _∷_
----------------------------------------------------------------------
postulate String : Set
{-# BUILTIN STRING String #-}
-------------------------------------------... | module Spire.Examples.DarkwingDuck.Primitive where
----------------------------------------------------------------------
infixr 4 _,_
infixr 5 _∷_
----------------------------------------------------------------------
postulate String : Set
{-# BUILTIN STRING String #-}
-------------------------------------------... | Add bot to primitives. | Add bot to primitives.
Consistency at last.
| Agda | bsd-3-clause | spire/spire |
6dbde1e52f3b14199a1e9ee7097d079561b3923e | Thesis/SIRelBigStep/FundamentalProperty.agda | Thesis/SIRelBigStep/FundamentalProperty.agda | module Thesis.SIRelBigStep.FundamentalProperty where
open import Data.Product
open import Relation.Binary.PropositionalEquality
open import Thesis.SIRelBigStep.IlcSILR
rfundamentalV3v : ∀ {Γ τ} (x : Var Γ τ) → (n : ℕ) → ∀ ρ1 dρ ρ2 (ρρ : rrelρ3 Γ ρ1 dρ ρ2 n) → rrelV3 τ (⟦ x ⟧Var ρ1) (D.⟦ x ⟧Var dρ) (⟦ x ⟧Var ρ2) n
rf... | module Thesis.SIRelBigStep.FundamentalProperty where
open import Data.Product
open import Relation.Binary.PropositionalEquality
open import Thesis.SIRelBigStep.IlcSILR
rfundamentalV3v : ∀ {Γ τ} (x : Var Γ τ) → (n : ℕ) → ∀ ρ1 dρ ρ2 (ρρ : rrelρ3 Γ ρ1 dρ ρ2 n) → rrelV3 τ (⟦ x ⟧Var ρ1) (D.⟦ x ⟧Var dρ) (⟦ x ⟧Var ρ2) n
rf... | Correct local variable name | Correct local variable name
| Agda | mit | inc-lc/ilc-agda |
fb73c4c68d0d9e00dac3fd35d9b93d3d01182522 | 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 Syntax.Context.Popl14 public
open import Data.Integer
open import Popl14.Syntax.Term publi... | 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 Syntax.Context.Popl14 public
open import Data.Integer
open import Popl14.Syntax.Term publi... | Use HOAS-enabled helpers for nested abstractions. | Use HOAS-enabled helpers for nested abstractions.
Old-commit-hash: cffcfea69d7b1877dc5d63b49ee0ed9f24dce0d2
| Agda | mit | inc-lc/ilc-agda |
9d1e02a049e0eac1e796dc1d74d47064871effb3 | otp-sem-sec.agda | otp-sem-sec.agda | module otp-sem-sec where
import Level as L
open import Function
open import Data.Nat.NP
open import Data.Bits
open import Data.Bool
open import Data.Bool.Properties
open import Data.Vec hiding (_>>=_)
open import Data.Product.NP hiding (_⟦×⟧_)
open import Relation.Nullary
open import Relation.Binary
open import Relati... | module otp-sem-sec where
import Level as L
open import Function
open import Data.Nat.NP
open import Data.Bits
open import Data.Bool
open import Data.Bool.Properties
open import Data.Vec hiding (_>>=_)
open import Data.Product.NP hiding (_⟦×⟧_)
open import Relation.Nullary
open import Relation.Binary
open import Relati... | Remove power from the guessing game | Remove power from the guessing game
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
242a602d070c3965f3dedd346bff306ec822c452 | lib/Algebra/Group/Homomorphism.agda | lib/Algebra/Group/Homomorphism.agda | {-# OPTIONS --without-K #-}
module Algebra.Group.Homomorphism where
open import Type using (Type_)
open import Function.NP using (Op₂; _∘_)
import Algebra.FunctionProperties.Eq
open Algebra.FunctionProperties.Eq.Implicits
open import Algebra.Monoid
open import Algebra.Monoid.Homomorphism
open import Algebra.Raw
open i... | {-# OPTIONS --without-K #-}
module Algebra.Group.Homomorphism where
open import Type using (Type_)
open import Function.NP using (Op₂; _∘_; id)
import Algebra.FunctionProperties.Eq
open Algebra.FunctionProperties.Eq.Implicits
open import Algebra.Monoid
open import Algebra.Monoid.Homomorphism
open import Algebra.Raw
op... | add id, ∘, Δ, zip, pair | Group.Homomorphism: add id, ∘, Δ, zip, pair
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
39d9e13ae25672af17181a0c3d1fee2118ac33c9 | 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 and use UncurriedTermConstructor. | Introduce and use UncurriedTermConstructor.
Old-commit-hash: d36f33b097ddb2444e6409de52048ef9bf94b001
| Agda | mit | inc-lc/ilc-agda |
81c758c5545a825b9152e8e2ab898c688bf0d4a9 | Solver/Linear/Parser.agda | Solver/Linear/Parser.agda | open import Data.Vec as Vec using ([]; _∷_)
open import Text.Parser
open import Data.One
open import Data.Char
open import Data.Nat
open import Data.List
open import Data.Product hiding (map)
open import Data.String as String renaming (toList to S▹L; fromList to L▹S)
open import Solver.Linear.Syntax
open import Data.Ma... | open import Data.Vec as Vec using ([]; _∷_)
open import Text.Parser
open import Data.One
open import Data.Char
open import Data.Nat
open import Data.List
open import Data.Product hiding (map)
open import Data.String as String renaming (toList to S▹L; fromList to L▹S)
open import Solver.Linear.Syntax
open import Data.Ma... | comment out the example (long to check) | Solver.Linear.Parser: comment out the example (long to check)
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
32b4e15a9837ed6e6276af1fd200e4a3dffc2223 | flipbased.agda | flipbased.agda | module flipbased where
open import Algebra
import Level as L
open L using () renaming (_⊔_ to _L⊔_)
open import Function hiding (_⟨_⟩_)
open import Data.Nat.NP
open import Data.Bool
open import Data.Nat.Properties
open import Data.Product using (proj₁; proj₂; _,_; swap; _×_)
open import Data.Bits hiding (replicateM)
o... | module flipbased where
open import Algebra
import Level as L
open L using () renaming (_⊔_ to _L⊔_)
open import Function hiding (_⟨_⟩_)
open import Data.Nat.NP
open import Data.Bool
open import Data.Nat.Properties
open import Data.Product using (proj₁; proj₂; _,_; swap; _×_)
open import Data.Bits hiding (replicateM)
o... | fix choose | flipbased: fix choose
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
df41c005d15604256ca7d340975689955ae6729f | protocols.agda | protocols.agda | module protocols where
import Control.Protocol
import Control.Protocol.Additive
import Control.Protocol.CLL
import Control.Protocol.ClientServer
import Control.Protocol.Examples
import Control.Protocol.MultiParty
import Control.Protocol.Multiplicative
import Control.Protocol.Relation
import Control.Protocol.Sequence
| module protocols where
import Control.Protocol
import Control.Protocol.Additive
import Control.Protocol.CLL
import Control.Protocol.ClientServer
import Control.Protocol.Examples
import Control.Protocol.Extend
import Control.Protocol.Lift
import Control.Protocol.MultiParty
import Control.Protocol.Multiplicative
import C... | update protocols.agda | update protocols.agda
| Agda | bsd-3-clause | crypto-agda/protocols |
a3a6c0d7b42940b151354af420f8d4469955d5c8 | Atlas/Change/Term.agda | Atlas/Change/Term.agda | module Atlas.Change.Term where
open import Atlas.Syntax.Type
open import Atlas.Syntax.Term
open import Atlas.Change.Type
-- nil-changes
nil-const : ∀ {ι : Base} → Const ∅ (base (ΔBase ι))
nil-const {ι} = neutral {ΔBase ι}
nil-term : ∀ {ι Γ} → Term Γ (base (ΔBase ι))
nil-term {Bool} = curriedConst (nil-const {Boo... | module Atlas.Change.Term where
open import Atlas.Syntax.Type
open import Atlas.Syntax.Term
open import Atlas.Change.Type
-- nil-changes
nil-const : ∀ {ι : Base} → Const ∅ (base (ΔBase ι))
nil-const {ι} = neutral {ΔBase ι}
nil-term : ∀ {ι Γ} → Term Γ (base (ΔBase ι))
nil-term {Bool} = curriedConst (nil-const {Boo... | Simplify Atlas-diff and Atlas-apply. | Simplify Atlas-diff and Atlas-apply.
Old-commit-hash: ada22ebb7416f8c4fb19882d4080166628b1b292
| Agda | mit | inc-lc/ilc-agda |
d41e35b9fb769cc937f3fa2787fe655ac719f13a | Syntax/Language/Atlas.agda | Syntax/Language/Atlas.agda | module Syntax.Language.Atlas where
-- Base types of the calculus Atlas
-- to be used with Plotkin-style language description
--
-- Atlas supports maps with neutral elements. The change type to
-- `Map κ ι` is `Map κ Δι`, where Δι is the change type of the
-- ground type ι. Such a change to maps can support insertions
... | module Syntax.Language.Atlas where
-- Base types of the calculus Atlas
-- to be used with Plotkin-style language description
--
-- Atlas supports maps with neutral elements. The change type to
-- `Map κ ι` is `Map κ Δι`, where Δι is the change type of the
-- ground type ι. Such a change to maps can support insertions
... | add primitives `lookup`, `fold` and various improvements | Atlas: add primitives `lookup`, `fold` and various improvements
Improvements:
- speed up derivative of zip
- less verbose term constructors for constants
- remove need to support conjunction and union directly
Future work:
- elimination forms: if-then-else, if-nonempty
Old-commit-hash: 9aafd0c2835ff027b57e44ed29... | Agda | mit | inc-lc/ilc-agda |
233ce4867a6fc1f8c29c642b2516cc11c7edd483 | 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... | Implement apply-term and diff-term directly. | Implement apply-term and diff-term directly.
Before this commit: Mutual recursion of apply-term and diff-term encoded
explicitly via a product type. After this commit: Mutual recursion
expressed with Agda mutual recursion.
Old-commit-hash: 9a7571f8ef5cf6765629a001c46870e002f54d7e
| Agda | mit | inc-lc/ilc-agda |
b51a3256a3c1252ef33def3ad7127f444c50c44e | 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 _... | Fix Δ-Context. | Fix Δ-Context.
Old-commit-hash: ce2c7324266f9f7511dd78f63accb2c3ae8c54fb
| Agda | mit | inc-lc/ilc-agda |
c1ff9f6bce16be7d52bc424c1c012656dec37587 | 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... | Implement apply-env and diff-env. | Implement apply-env and diff-env.
Old-commit-hash: 0a4d0485631257cbfb9ee522e8ac6facb88f0721
| Agda | mit | inc-lc/ilc-agda |
79eb1bff6fe6f19057332ff8737b10e85457ff5f | 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.Syntax.MType as MType
impor... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Caching evaluation
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Syntax.MType as MType
impor... | Drop dead comment | Drop dead comment
| Agda | mit | inc-lc/ilc-agda |
1dd4f0f861df9af4f01a33af2bb834b72be708cc | Base/Data/DependentList.agda | Base/Data/DependentList.agda | module Base.Data.DependentList where
open import Level
open import Data.Unit
open import Data.Product using (Σ ; _×_ ; _,_)
import Data.List as List
open List using (List ; [] ; _∷_)
data DependentList {a b} {A : Set a}
(F : A → Set b) : (type-args : List A) → Set (a ⊔ b)
where
∅ : DependentList F []
_•_ : ... | module Base.Data.DependentList where
open import Data.List.All public
renaming
( All to DependentList
; _∷_ to _•_
; [] to ∅
)
| Implement DependentList on top of Data.List.All. | Implement DependentList on top of Data.List.All.
Old-commit-hash: 32c7c7edadf9940f3c013ca3d4ebfdc8b3cbc4f4
| Agda | mit | inc-lc/ilc-agda |
816cffb53d3bae1af15f0f477ac1a68ccfa88b05 | Control/Protocol/Sequence.agda | Control/Protocol/Sequence.agda | {-# OPTIONS --without-K #-}
open import Function.NP
open import Type
open import Data.Product.NP using (Σ; _×_; _,_; first) renaming (proj₁ to fst; proj₂ to snd)
open import Data.Two hiding (_≟_)
open import Data.Nat hiding (_⊔_)
open import Relation.Binary.PropositionalEquality.NP using (_≡_; _∙_; refl; ap; coe; coe!;... | {-# OPTIONS --without-K #-}
open import Function.NP
open import Type
open import Data.Product.NP using (Σ; _×_; _,_; first) renaming (proj₁ to fst; proj₂ to snd)
open import Data.Two hiding (_≟_)
open import Data.Nat hiding (_⊔_)
open import Relation.Binary.PropositionalEquality.NP using (_≡_; _∙_; refl; ap; coe; coe!;... | add more composision with >> | add more composision with >>
| Agda | bsd-3-clause | crypto-agda/protocols |
11dd97138b62b839e6eff70a2897426660d4fd10 | 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... | Rename (ignore|update)-valid-change to (before|after). | Rename (ignore|update)-valid-change to (before|after).
Old-commit-hash: 16288a40704567fce8f03420af8050326b9b9b34
| Agda | mit | inc-lc/ilc-agda |
75429bb69a022fe800c050d4e53fdc2a9ccc9261 | 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 names. For example,
-- afte... | module PLDI14-List-of-Theorems where
-- 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 names. For example,
-- after this file type check... | Update PLDI14-List-of-Theorems.agda (for #275). | Update PLDI14-List-of-Theorems.agda (for #275).
The list included plugin requirements, but we left them out of the
paper, so the theorem numbers were off.
Old-commit-hash: d4ea643c7474f10c798fcb0d494db9f941e3deb5
| Agda | mit | inc-lc/ilc-agda |
ef3f46045d85fef7b038b4703fc7d2fee8d29a8a | Denotational/Equivalence.agda | Denotational/Equivalence.agda | module Denotational.Equivalence where
-- TERM EQUIVALENCE
--
-- This module defines term equivalence as the relation that
-- identifies terms with the same meaning.
open import Relation.Nullary using (¬_)
open import Relation.Binary hiding (_⇒_)
open import Relation.Binary.PropositionalEquality
open import Syntacti... | module Denotational.Equivalence where
-- TERM EQUIVALENCE
--
-- This module defines term equivalence as the relation that
-- identifies terms with the same meaning.
open import Relation.Nullary using (¬_)
open import Relation.Binary hiding (_⇒_)
open import Relation.Binary.PropositionalEquality
open import Denotati... | Generalize term equivalence to arbitrary calculi. | Generalize term equivalence to arbitrary calculi.
Old-commit-hash: 239a4be82a8af884669ca62db624782bee407ca1
| Agda | mit | inc-lc/ilc-agda |
90e62144b22dcc8d6181e110e5f313f406aff57f | 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... | change wording | change wording
| Agda | bsd-3-clause | spire/spire |
224bef483393cb10b22b2f51c63865cc5ddf471f | partial.agda | partial.agda | module partial where
-- INCREMENTAL λ-CALCULUS
-- with (one-variable) partial derivatives
--
-- Features:
-- * Changes and derivatives are different.
-- * Δ x e maps changes of x to changes of e.
-- * a full denotational semantics is given.
-- * the domain of change types `⟦Δ τ⟧` is uniformly defined as `⟦τ... | module partial where
-- INCREMENTAL λ-CALCULUS
-- with (one-variable) partial derivatives
--
-- Features:
-- * Changes and derivatives are different.
-- * Δ x dx e describes how e changes if x changes by dx.
-- * a full denotational semantics is given.
-- * the domain of change types `⟦Δ τ⟧` is uniformly de... | Fix comment (fix #20). | Fix comment (fix #20).
Old-commit-hash: d5a7ef44c7c38bf82aa00466ee0bac803dd860d3
| Agda | mit | inc-lc/ilc-agda |
64c7aa44ab0d86c66f744241c812cc27ab7fb2c6 | 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... | 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... | Add TODO | Add TODO
| Agda | mit | inc-lc/ilc-agda |
e0b2a2036942b7b9010a4d1e45e94ed00a26742d | Atlas/Change/Term.agda | Atlas/Change/Term.agda | module Atlas.Change.Term where
open import Atlas.Syntax.Type
open import Atlas.Syntax.Term
open import Atlas.Change.Type
-- nil-changes
nil-const : ∀ {ι : Base} → Const ∅ (base (ΔBase ι))
nil-const {ι} = neutral {ΔBase ι}
nil-term : ∀ {ι Γ} → Term Γ (base (ΔBase ι))
nil-term {Bool} = curriedConst (nil-const {Boo... | module Atlas.Change.Term where
open import Atlas.Syntax.Type
open import Atlas.Syntax.Term
open import Atlas.Change.Type
-- nil-changes
nil-const : ∀ {ι : Base} → Const ∅ (base (ΔBase ι))
nil-const {ι} = neutral {ΔBase ι}
nil-term : ∀ {ι Γ} → Term Γ (base (ΔBase ι))
nil-term {Bool} = curriedConst (nil-const {Boo... | Rename Atlas-diff to diff-base. | Rename Atlas-diff to diff-base.
Old-commit-hash: 8940b78431520f22d625a114d12ce0faee05542c
| Agda | mit | inc-lc/ilc-agda |
5a499d733fe3968065e0ae2b47d1393cf5980209 | lib/Data/Two.agda | lib/Data/Two.agda | {-# OPTIONS --without-K #-}
module Data.Two where
open import Data.Bool public hiding (if_then_else_) renaming (Bool to 𝟚; false to 0₂; true to 1₂; T to ✓)
open import Data.Bool.Properties
public
using (isCommutativeSemiring-∨-∧
;commutativeSemiring-∨-∧
;module RingSolver
;isCommutativeSem... | {-# OPTIONS --without-K #-}
module Data.Two where
open import Data.Bool public hiding (if_then_else_) renaming (Bool to 𝟚; false to 0₂; true to 1₂; T to ✓)
open import Data.Bool.Properties
public
using (isCommutativeSemiring-∨-∧
;commutativeSemiring-∨-∧
;module RingSolver
;isCommutativeSem... | add _² | Data.Two: add _²
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
6ad96baab8d36671b146b356a5a446ae10e1b832 | 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
open import Base.Denotation.Notation public
open import Relation.Bin... | 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
open import Base.Denotation.Notation public
open import Relation.Bin... | Remove apply-env and diff-env. | Remove apply-env and diff-env.
Old-commit-hash: 0901643e49a0e4ff70db8f16278c25bd28348d3a
| Agda | mit | inc-lc/ilc-agda |
973a194f1e408a138980b8d9e4156302e223bc75 | Thesis/SIRelBigStep/DeriveCorrect.agda | Thesis/SIRelBigStep/DeriveCorrect.agda | --
-- In this module we conclude our proof: we have shown that t, derive-dterm t
-- and produce related values (in the sense of the fundamental property,
-- rfundamental3), and for related values v1, dv and v2 we have v1 ⊕ dv ≡
-- v2 (because ⊕ agrees with validity, rrelV3→⊕).
--
-- We now put these facts together via ... | --
-- In this module we conclude our proof: we have shown that t, derive-dterm t
-- and produce related values (in the sense of the fundamental property,
-- rfundamental3), and for related values v1, dv and v2 we have v1 ⊕ dv ≡
-- v2 (because ⊕ agrees with validity, rrelV3→⊕).
--
-- We now put these facts together via ... | Define a correct nil on values and environments | Define a correct nil on values and environments
Compose is trickier because I must match on two validity proofs, need an
inversion lemma for that.
| Agda | mit | inc-lc/ilc-agda |
1da0c206672cf5880079e99b71f1940b6df8932e | lambda.agda | lambda.agda | 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... | 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... | Implement NbE for lambda calculus with conditionals (see #50). | Implement NbE for lambda calculus with conditionals (see #50).
This version is simpler than the code in NormalizationByEvaluation
in the following ways:
- Instead of supporting arbitrary base types and constants,
bool, true, false, and if are hard-coded.
- Instead of supporting arbitrary Kripke structures,
m... | Agda | mit | inc-lc/ilc-agda |
2bc86b16750cda8c1189ff286ba5405a47076a56 | 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 Agda version in README.agda | Update Agda version in README.agda
| Agda | mit | inc-lc/ilc-agda |
1fd2e308e6cbee61ce0c527c7a1c8fa86ae11694 | 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... | Remove more dead code | Remove more dead code
Old-commit-hash: 20e82287ead4c99b0bce90e095ed1f7711119d2a
| Agda | mit | inc-lc/ilc-agda |
e87a9fc0946ded53de5e1775b46c12ba9a8ba6dc | ZK/GroupHom/Types.agda | ZK/GroupHom/Types.agda | {-# OPTIONS --without-K #-}
open import Type using (Type)
open import Data.Bool.Base using (Bool) renaming (T to ✓)
open import Relation.Binary.PropositionalEquality.NP using (_≡_)
open import Algebra.Group
open import Algebra.Group.Homomorphism
module ZK.GroupHom.Types where
record GrpHom (G+ G* : Type)(P : G+ → Typ... | {-# OPTIONS --without-K #-}
open import Type using (Type)
open import Type.Eq
open import Relation.Binary.PropositionalEquality.NP using (_≡_)
open import Algebra.Group
open import Algebra.Group.Homomorphism
module ZK.GroupHom.Types where
-- P is the "valid witness" predicate.
record ZK-hom (G+ G* : Type)(P : G+ → Ty... | use Eq? | ZK.GroupHom.Types: use Eq?
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
61adc205859b99f216096bf10da4b6ffe56adfc7 | Base/Syntax/Context.agda | Base/Syntax/Context.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Variables and contexts
--
-- This module defines the syntax of contexts, prefixes of
-- contexts and variables and properties of these notions.
--
-- This module is parametric in the syntax of types, so it
-- can be... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Variables and contexts
--
-- This module defines the syntax of contexts, prefixes of
-- contexts and variables and properties of these notions.
--
-- This module is parametric in the syntax of types, so it
-- can be... | Simplify _⋎_ | Simplify _⋎_
| Agda | mit | inc-lc/ilc-agda |
b93733dc8edf5e1dc3e416dfa0bca1405b5ae331 | 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* ... | Break lines. | Break lines.
Old-commit-hash: c7c69f51c35066147017459aa226bebe26d68df2
| Agda | mit | inc-lc/ilc-agda |
fdb5d8f0195c9849f6e208db228bb650fe5eba97 | 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 Δbase to ΔBase. | Rename Δbase to ΔBase.
Old-commit-hash: e9efdc6e4dd5d76003e901e1ef557ec049d5e59c
| Agda | mit | inc-lc/ilc-agda |
7ed997a9f08476266fb59fb488eac08ad40048de | parametricity.agda | parametricity.agda | module parametricity where
import Data.Bool.Param.NatBool
import Data.Dec.Param.Binary
import Data.Dec.Param.Unary
import Data.Fin.Param.Binary
import Data.Maybe.Param.Binary
import Data.Maybe.Param.Unary
import Data.Nat.Param.Binary
import Data.One.Param.Binary
import Data.One.Param.Unary
import Data.Product.Param.Bin... | module parametricity where
import Data.Bool.Param.NatBool
import Data.Dec.Param.Binary
import Data.Dec.Param.Unary
import Data.Fin.Param.Binary
import Data.Maybe.Param.Binary
import Data.Maybe.Param.Unary
import Data.Nat.Param.Binary
import Data.One.Param.Binary
import Data.One.Param.Unary
import Data.Product.Param.Bin... | Disable reflection for now | Disable reflection for now
| Agda | bsd-3-clause | np/agda-parametricity |
5bd1cb31b6ff25934b1212da8538587845a850b9 | lib/Relation/Binary/PropositionalEquality/NP.agda | lib/Relation/Binary/PropositionalEquality/NP.agda | {-# OPTIONS --without-K #-}
-- move this to propeq
module Relation.Binary.PropositionalEquality.NP where
open import Type hiding (★)
open import Data.One using (𝟙)
open import Data.Product using (Σ; _,_)
open import Relation.Binary.PropositionalEquality public hiding (module ≡-Reasoning)
open import Relation.Binary.N... | {-# OPTIONS --without-K #-}
-- move this to propeq
module Relation.Binary.PropositionalEquality.NP where
open import Type hiding (★)
open import Data.One using (𝟙)
open import Data.Product using (Σ; _,_)
open import Relation.Binary.PropositionalEquality public hiding (module ≡-Reasoning; subst)
open import Relation.B... | Hide subst, expose tr... | ≡: Hide subst, expose tr...
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
690f2df38e24ddcd80d24056254c61364cc071fd | 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... | Add ≙-cong₂ | Add ≙-cong₂
Useful for next steps.
| Agda | mit | inc-lc/ilc-agda |
c68ae3394af059da44a270c4286cea18d3987019 | 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... | Document Term and Terms. | Document Term and Terms.
Old-commit-hash: 7f9cbb4cffc6d9343c93f495fd39e0d6b1bcd855
| Agda | mit | inc-lc/ilc-agda |
f5b981ea7905d4deb015eced08bb201e6b26490f | Crypto/JS/BigI/FiniteField.agda | Crypto/JS/BigI/FiniteField.agda | {-# OPTIONS --without-K #-}
open import Type.Eq
open import Data.Two hiding (_==_)
open import Relation.Binary.PropositionalEquality
open import FFI.JS using (Bool; trace-call; _++_)
open import FFI.JS.Check
renaming (check to check?)
--renaming (warn-check to check?)
open import FFI.JS.BigI
open import Data.Li... | {-# OPTIONS --without-K #-}
open import Type.Eq
open import Data.Two hiding (_==_)
open import Relation.Binary.PropositionalEquality
open import FFI.JS using (JS[_]; _++_; return; _>>_)
open import FFI.JS.Check
using (check!)
renaming (check to check?)
--renaming (warn-check to check?)
open import FFI.JS.B... | rename as ℤ[_], and improve imports from BigI | FiniteField: rename as ℤ[_], and improve imports from BigI
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
5d3aa98ffc0c22e45257913557e911cc654c4777 | Popl14/Change/Evaluation.agda | Popl14/Change/Evaluation.agda | module Popl14.Change.Evaluation where
open import Popl14.Syntax.Type
open import Popl14.Syntax.Term
open import Popl14.Change.Type
open import Popl14.Change.Term
open import Popl14.Change.Value
open import Popl14.Denotation.Value
open import Popl14.Denotation.Evaluation
open import Relation.Binary.PropositionalEquali... | module Popl14.Change.Evaluation where
open import Popl14.Syntax.Type
open import Popl14.Syntax.Term
open import Popl14.Change.Type
open import Popl14.Change.Term
open import Popl14.Change.Value
open import Popl14.Denotation.Value
open import Popl14.Denotation.Evaluation
open import Relation.Binary.PropositionalEquali... | Use ⟦⊕₍_₎⟧ and ⟦⊝₍_₎⟧ in Popl14.Change.Evaluation. | Use ⟦⊕₍_₎⟧ and ⟦⊝₍_₎⟧ in Popl14.Change.Evaluation.
Old-commit-hash: a05b08ff42508e49817f899523f4849e9334e057
| Agda | mit | inc-lc/ilc-agda |
69fe0b1567d5b5439ff7565a79deffd679e3a82b | Parametric/Change/Type.agda | Parametric/Change/Type.agda | module Parametric.Change.Type
(Base : Set)
where
import Parametric.Syntax.Type as Type
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 import Base.Ch... | 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... | Make P.C.Type conform to plugin pattern. | Make P.C.Type conform to plugin pattern.
Old-commit-hash: 8dc76b168a0b8d9f859a69834d52d91e2f34b235
| Agda | mit | inc-lc/ilc-agda |
799ecf7906eb3e8eafef355dc3f96dfd5a71014e | one-time-semantic-security.agda | one-time-semantic-security.agda | module one-time-semantic-security where
open import Function
open import Data.Nat
open import Data.Product using (∃; module Σ; _×_; _,_; proj₁; proj₂)
open import Data.Vec using (splitAt; take; drop)
import Relation.Binary.PropositionalEquality as ≡
open ≡ using (_≗_)
open import Data.Bits
open import flat-funs
open... | module one-time-semantic-security where
open import Function
open import Data.Nat
open import Data.Product using (∃; module Σ; _×_; _,_; proj₁; proj₂)
open import Data.Vec using (splitAt; take; drop)
import Relation.Binary.PropositionalEquality as ≡
open ≡ using (_≗_)
open import Data.Bits
open import flat-funs
open... | Improve change-adv and add ≗A→⇓ | one-time-semantic-security: Improve change-adv and add ≗A→⇓
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
ab1099f8573c544e98531d58aac709002e109268 | lib/Type.agda | lib/Type.agda | module Type where
★₂ : Set₃
★₂ = Set₂
★₁ : ★₂
★₁ = Set₁
★ : ★₁
★ = Set
| module Type where
open import Level
★₂ : Set₃
★₂ = Set₂
★₁ : ★₂
★₁ = Set₁
★₀ : ★₁
★₀ = Set
★ : ★₁
★ = ★₀
★_ : ∀ ℓ → Set (suc ℓ)
★_ ℓ = Set ℓ
| add ★_ for the universal type of type | Type: add ★_ for the universal type of type
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
244c3b4285d455271121fa1cc4982d804ffe9437 | Solver/Linear.agda | Solver/Linear.agda | -- NOTE with-K
module Solver.Linear where
open import FunUniverse.Types
open import FunUniverse.Rewiring.Linear
open import Data.Two hiding (_≟_)
open import Data.Nat as ℕ using (ℕ)
import Solver.Linear.Syntax as LinSyn
open import Relation.Nullary.Decidable
open import Relation.Binary
open import Relation.Binary.Prop... | -- NOTO with-K
module Solver.Linear where
open import FunUniverse.Types
open import FunUniverse.Rewiring.Linear
open import Data.Two hiding (_≟_)
open import Data.Nat as ℕ using (ℕ)
import Solver.Linear.Syntax as LinSyn
open import Relation.Nullary.Decidable
open import Relation.Binary
open import Relation.Binary.Prop... | Fix a note | Fix a note
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
23195232ac9f45758a208ab48715260ca5c37781 | FunUniverse/Rewiring/Linear.agda | FunUniverse/Rewiring/Linear.agda | {-# OPTIONS --without-K #-}
open import Level.NP
open import Type
open import FunUniverse.Types
open import Data.One using (𝟙)
import Data.Vec as V
open V using (Vec; []; _∷_)
open import Data.Nat.NP using (ℕ; zero; suc; _+_; _*_; 2^_)
import FunUniverse.Category
import FunUniverse.Defaults.FirstPart as Defaults⟨first... | {-# OPTIONS --without-K #-}
open import Level.NP
open import Type
open import FunUniverse.Types
open import Data.One using (𝟙)
import Data.Vec as V
open V using (Vec; []; _∷_)
open import Data.Nat.NP using (ℕ; zero; suc; _+_; _*_; 2^_)
import FunUniverse.Category
import FunUniverse.Defaults.FirstPart as Defaults⟨first... | add mapAccum | FunUniverse/Rewiring/Linear: add mapAccum
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
2c661467da93de9a39c40cddc61abeeca5350793 | 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 validVar explicit. | Make some arguments of validVar explicit.
Old-commit-hash: dc6d178e02b8bdd4f772dddbba1bf337f3b1d74c
| Agda | mit | inc-lc/ilc-agda |
3ee4b4fed60cc477d5e3672148d7f6f90db3368f | arrow.agda | arrow.agda | open import Data.Bool
open import Data.List
open import Data.Nat
----------------------------------------
_≡_ : ℕ → ℕ → Bool
zero ≡ zero = true
suc n ≡ suc m = n ≡ m
_ ≡ _ = false
----------------------------------------
_∈_ : ℕ → List ℕ → Bool
x ∈ [] = false
x ∈ (y ∷ ys) with x ≡ y
... ... | open import Agda.Builtin.Bool
_or_ : Bool → Bool → Bool
true or _ = true
_ or true = true
false or false = false
_and_ : Bool → Bool → Bool
false and _ = false
_ and false = false
true and true = true
----------------------------------------
data ℕ : Set where
zero : ℕ
suc : ℕ → ℕ
{-# BUILTIN... | Revert "Convert to stdlib" | Revert "Convert to stdlib"
This reverts commit 68af677d56d4f0a4c1aaa95134ae06f0813500c1.
| Agda | mit | louisswarren/hieretikz |
ca3585f55fde86ac7d664ac346618396c7308e11 | 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... | Implement apply-valid-change. | Implement apply-valid-change.
Old-commit-hash: 64cc4483b462c94a945aa312124cbdf090ffd619
| Agda | mit | inc-lc/ilc-agda |
fbf5d17dabb1058927efc56a1b0c092c4e68e355 | incremental.agda | incremental.agda | module incremental where
open import Relation.Binary.PropositionalEquality
open import meaning
-- SIMPLE TYPES
-- Syntax
data Type : Set where
_⇒_ : (τ₁ τ₂ : Type) → Type
-- `Δ τ` is the type of changes to `τ`
Δ : (τ : Type) → Type
infixr 5 _⇒_
-- Denotational Semantics
⟦_⟧Type : Type -> Set
⟦ τ₁ ⇒ τ₂ ⟧T... | module incremental where
open import Relation.Binary.PropositionalEquality
open import meaning
-- SIMPLE TYPES
-- Syntax
data Type : Set where
_⇒_ : (τ₁ τ₂ : Type) → Type
-- `Δ τ` is the type of changes to `τ`
Δ : (τ : Type) → Type
infixr 5 _⇒_
-- Denotational Semantics
⟦_⟧Type : Type -> Set
⟦ τ₁ ⇒ τ₂ ⟧T... | Change Δ to expect the change in a free variable. | Change Δ to expect the change in a free variable.
Proposed by Paolo in a whiteboard discussion today.
Old-commit-hash: bce0357c249c6ae66ad8fe002147ad07623d842f
| Agda | mit | inc-lc/ilc-agda |
1d32ad0cbc8582d30660167abe83ddda4a4cf6d1 | lib/Relation/Nullary/NP.agda | lib/Relation/Nullary/NP.agda | module Relation.Nullary.NP where
open import Type
open import Data.Sum
open import Relation.Nullary public
module _ {a b} {A : ★_ a} {B : ★_ b} where
Dec-⊎ : Dec A → Dec B → Dec (A ⊎ B)
Dec-⊎ (yes p) _ = yes (inj₁ p)
Dec-⊎ (no ¬p) (yes p) = yes (inj₂ p)
Dec-⊎ (no ¬p) (no ¬q) = no [ ¬p , ¬q ]
... | module Relation.Nullary.NP where
open import Type
open import Function
open import Data.Zero
open import Data.One
open import Data.Sum
open import Data.Product renaming (proj₁ to fst; proj₂ to snd)
open import Relation.Nullary public
Dec-𝟘 : Dec 𝟘
Dec-𝟘 = no id
Dec-𝟙 : Dec 𝟙
Dec-𝟙 = yes _
module _ {a b} {A : ... | add Dec-{𝟘,𝟙,×,→} | Dec: add Dec-{𝟘,𝟙,×,→}
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
0ea795d1835bb4e398a04244310fe6e1eed4388f | one-time-semantic-security.agda | one-time-semantic-security.agda | module one-time-semantic-security where
open import Function
open import Data.Nat
open import Data.Product
open import Data.Vec using (splitAt; take; drop)
import Relation.Binary.PropositionalEquality as ≡
open ≡ using (_≗_)
open import Data.Bits
open import flat-funs
open import program-distance
open import flipbas... | module one-time-semantic-security where
open import Function
open import Data.Nat
open import Data.Product using (∃; module Σ; _×_; _,_; proj₁; proj₂)
open import Data.Vec using (splitAt; take; drop)
import Relation.Binary.PropositionalEquality as ≡
open ≡ using (_≗_)
open import Data.Bits
open import flat-funs
open... | add ♭EncParams² | one-time-semantic-security: add ♭EncParams²
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
00a7767b9e6a38ec98ff6336651129e2786a6a98 | lib/Data/Fin/Logical.agda | lib/Data/Fin/Logical.agda | -- NOTE with-K
module Data.Fin.Logical where
open import Data.Nat.Param.Binary
open import Data.Fin.Param.Binary
open import Function
open import Data.Fin
open import Relation.Binary
open import Relation.Binary.Logical
private
module ⟦ℕ⟧s = Setoid ⟦ℕ⟧-setoid
{-
data ⟦Fin⟧ : (⟦ℕ⟧ ⟦→⟧ ⟦★₀⟧) Fin Fin where
⟦zero⟧ :... | {-# OPTIONS --with-K #-}
module Data.Fin.Logical where
open import Data.Nat.Logical
open import Data.Nat.Param.Binary
-- open import Data.Fin.Param.Binary
open import Function
open import Data.Fin
open import Relation.Binary
open import Relation.Binary.Logical
private
module ⟦ℕ⟧s = Setoid ⟦ℕ⟧-setoid
data ⟦Fin⟧ : ... | Fix Data.Fin.Logical | Fix Data.Fin.Logical
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
8403c80b80206ebcbe4f1d3acfac2cfce30552ca | 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 ... | Drop unused defs | Drop unused defs
| Agda | mit | inc-lc/ilc-agda |
c7ad461731109d522f831464e795886500cbf40d | README.agda | README.agda | module README where
-- INCREMENTAL λ-CALCULUS
-- with total derivatives
--
-- Features:
-- * changes and derivatives are unified (following Cai)
-- * multiple calculi
import Popl14.Syntax.Term
import Base.Syntax.Context
import Base.Change.Context
import Popl14.Change.Derive
{- Language definition of Calc. Atla... | module README where
-- INCREMENTAL λ-CALCULUS
-- with total derivatives
--
-- Features:
-- * changes and derivatives are unified (following Cai)
-- * multiple calculi
--
-- To typecheck this formalization, you need to install the appropriate version
-- of Agda, the Agda standard library (version 0.7), generate E... | Add instructions for users to README.agda | Add instructions for users to README.agda
Old-commit-hash: c0018596eda8908801ba4aa7eeec5aa0ef9452b5
| Agda | mit | inc-lc/ilc-agda |
97ac1ebb0cbaecc1af38b1d9916fb946e06656a7 | 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... | remove redundant comment | remove redundant comment
Old-commit-hash: 72138e09941c4514d0acef9dc39a91cd83e8077c
| Agda | mit | inc-lc/ilc-agda |
ceb7acd1c67116365b51503065e55f947cda63a5 | 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
--
-- Work in Progress:
-- ... | 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
--
-- Work in Progress:
-- ... | simplify weakenMore | agda/...: simplify weakenMore
* Inline some definitions where appropriate.
* Remove useless pattern matching on context.
Old-commit-hash: a4c4aee377597f7c17b5fa7d8b1c8a02492041c0
| Agda | mit | inc-lc/ilc-agda |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.