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 |
|---|---|---|---|---|---|---|---|---|---|
90aff21d03b068f50fef74f2c22666b5ea68c76b | 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} : (... | module Control.Strategy where
open import Function
open import Type using (★)
open import Category.Monad
open import Data.Product hiding (map)
open import Relation.Binary.PropositionalEquality.NP
data Strategy (Q : ★) (R : Q → ★) (A : ★) : ★ where
ask : (q? : Q) (cont : R q? → Strategy Q R A) → Strategy Q R A
do... | Improve Strategy to have a the response type depend on the query type | Improve Strategy to have a the response type depend on the query type
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
f1f55119854a27617ba6d8786230e7ca527ff616 | agda2/Text/Greek/Smyth.agda | agda2/Text/Greek/Smyth.agda | module Text.Greek.Smyth where
open import Data.Char
open import Data.Maybe
open import Relation.Nullary using (¬_)
-- Smyth §1
data Letter : Set where
α β γ δ ε ζ η θ ι κ λ′ μ ν ξ ο π ρ σ τ υ φ χ ψ ω : Letter
data LetterCase : Set where
capital small : LetterCase
form : Letter → LetterCase → Char
form α capital... | module Text.Greek.Smyth where
open import Data.Char
open import Data.Maybe
open import Relation.Nullary using (¬_)
-- Smyth §1
data Letter : Set where
α β γ δ ε ζ η θ ι κ λ′ μ ν ξ ο π ρ σ τ υ φ χ ψ ω : Letter
data LetterCase : Set where
capital small : LetterCase
form : Letter → LetterCase → Char
form α capital... | Add more Smyth encoding. | Add more Smyth encoding.
| Agda | mit | scott-fleischman/greek-grammar,scott-fleischman/greek-grammar |
f6544cdf2b41aa0730418c4d5d83b346e2b74f2e | 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 variant of delta-ext | Base.Change.Equivalence: add variant of delta-ext
Since I was confused myself for a while on the correct statement for
delta-ext, clarify it explicitly.
| Agda | mit | inc-lc/ilc-agda |
8f017c6136524d1546c71e1484d6011f82180f52 | 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... | Cut out power | Cut out power
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
f97ff6f67a4cac4360ae09731c7f0ab22eca83b7 | src/Holes/Test/Limited.agda | src/Holes/Test/Limited.agda | module Holes.Test.Limited where
open import Holes.Prelude hiding (_⊛_)
open import Holes.Util
open import Holes.Term
open import Holes.Cong.Limited
open import Agda.Builtin.Equality using (_≡_; refl)
module Contrived where
infixl 5 _⊕_
infixl 6 _⊛_
infix 4 _≈_
-- A type of expression trees for natural numbe... | module Holes.Test.Limited where
open import Holes.Prelude hiding (_⊛_)
open import Holes.Util
open import Holes.Term
open import Holes.Cong.Limited
open import Agda.Builtin.Equality using (_≡_; refl)
module Contrived where
infixl 5 _⊕_
infixl 6 _⊛_
infix 4 _≈_
-- A type of expression trees for natural numbe... | Add a new test | Add a new test
| Agda | mit | bch29/agda-holes |
ee97a3e6749a3dd5f7faa559198900ab683eb47d | 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:
-- ... | Revise walkthrough in README.agda (for #275). | Revise walkthrough in README.agda (for #275).
Old-commit-hash: 97b77b8c0bb96fc3d4df29ee914a158019dd3cdd
| Agda | mit | inc-lc/ilc-agda |
11413469714bba635b972f40607b808e31925650 | 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... | Remove spurious imports | Remove spurious imports
Old-commit-hash: fc57d2d6ee3ff6f548c16e7073aeb6ae12646d85
| Agda | mit | inc-lc/ilc-agda |
1832c6af3f90a6b9fc8c06181cccfcb95932c5fc | lib/Relation/Binary/NP.agda | lib/Relation/Binary/NP.agda | {-# OPTIONS --universe-polymorphism #-}
module Relation.Binary.NP where
open import Level
open import Relation.Binary public
import Relation.Binary.PropositionalEquality as PropEq
-- could this be moved in place of Trans is Relation.Binary.Core
Trans' : ∀ {a b c ℓ₁ ℓ₂ ℓ₃} {A : Set a} {B : Set b} {C : Set c} →
... | {-# OPTIONS --universe-polymorphism #-}
module Relation.Binary.NP where
open import Level
open import Relation.Binary public
import Relation.Binary.PropositionalEquality as PropEq
-- could this be moved in place of Trans is Relation.Binary.Core
Trans' : ∀ {a b c ℓ₁ ℓ₂ ℓ₃} {A : Set a} {B : Set b} {C : Set c} →
... | Fix Preorder-Reasoning and Setoid-Reasoning | Fix Preorder-Reasoning and Setoid-Reasoning
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
7257505604e7df0478b8f19eb563905418431bcb | Parametric/Change/Specification.agda | Parametric/Change/Specification.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
module Parametric.Change.Specification
{Base : Type.Structure}
(Const : Term.Structure Base... | ------------------------------------------------------------------------
-- 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... | Document P.C.Specification. | Document P.C.Specification.
Old-commit-hash: e6e682df0d2f25bc8c50a5872acd4540f0116289
| Agda | mit | inc-lc/ilc-agda |
351737b9010e4a14a8b06675017e628dfb7d6269 | PTT/Translation.agda | PTT/Translation.agda | open import Function
open import Data.Product hiding (zip)
renaming (_,_ to ⟨_,_⟩; proj₁ to fst; proj₂ to snd;
map to ×map)
open import Data.Zero
open import Data.One
open import Data.Two
open import PTT.Dom
import PTT.Session as Session
import PTT.Map as Map... | -- UNFINISHED
open import Function
open import Data.Product hiding (zip)
renaming (_,_ to ⟨_,_⟩; proj₁ to fst; proj₂ to snd;
map to ×map)
open import Data.Zero
open import Data.One
open import Data.Two
open import PTT.Dom
import PTT.Session as Session
import... | Mark the Translation module as unfinished | Mark the Translation module as unfinished
| Agda | bsd-3-clause | crypto-agda/protocols |
c5b9953cdc3f8a48882f01493714cec1f0d16c61 | arrow.agda | arrow.agda | 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... | data Bool : Set where
true : Bool
false : 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 : ℕ
su... | Revert "Import bool" - The agda stdlib is too slow to be worthwhile | Revert "Import bool" - The agda stdlib is too slow to be worthwhile
This reverts commit e449e00f2c1e586ddf5a78a508185eb30347d0fc.
| Agda | mit | louisswarren/hieretikz |
c6df8251b159a6d5d0490726b27d486890c82882 | Neglible.agda | Neglible.agda | {-# OPTIONS --copatterns #-}
open import Algebra
open import Function
open import Data.Nat.NP
open import Data.Nat.Distance
open import Data.Nat.Properties
open import Data.Two
open import Data.Zero
open import Data.Product
open import Relation.Binary
open import Relation.Binary.PropositionalEquality.NP
open import... | {-# OPTIONS --copatterns #-}
open import Algebra
open import Function
open import Data.Nat.NP
open import Data.Nat.Distance
open import Data.Nat.Properties
open import Data.Two
open import Data.Zero
open import Data.Product
open import Relation.Binary
open import Relation.Binary.PropositionalEquality.NP
open import... | Update to Neglible | Update to Neglible
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
905379564a50f91a3435bb015a582178b9bc39e2 | README.agda | README.agda | module README where
----------------------------
-- INCREMENTAL λ-CALCULUS --
----------------------------
--
--
-- IMPORTANT FILES
--
-- modules.pdf
-- The graph of dependencies between Agda modules.
--
-- README.agda
-- This file. A coarse-grained introduction to the Agda formalization.
--
-- PLDI14-List-of-Theo... | ------------------------------------------------------------------------
-- 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:
-- ... | Revise agda/README.md (for #275). | Revise agda/README.md (for #275).
Old-commit-hash: 88f72736101147e9754ea68565ed89d6702452bb
| Agda | mit | inc-lc/ilc-agda |
5e28e95336edd7da4ef18ee12d86f53112e719a2 | Denotational/Evaluation/Total.agda | Denotational/Evaluation/Total.agda | module Denotational.Evaluation.Total where
-- EVALUATION with a primitive for TOTAL DERIVATIVES
--
-- This module defines the semantics 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... | module Denotational.Evaluation.Total where
-- EVALUATION with a primitive for TOTAL DERIVATIVES
--
-- This module defines the semantics 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... | Use if_then_else in ⟦_⟧Term. | Use if_then_else in ⟦_⟧Term.
Old-commit-hash: f469e7f3aa20a7cdade4976d8bea10180b56dedb
| Agda | mit | inc-lc/ilc-agda |
e8b0a2064d7927030a67be90fa6130d3a7099cf3 | Parametric/Denotation/CachingMValue.agda | Parametric/Denotation/CachingMValue.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Values for caching evaluation of MTerm
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.MType as MType
import Parametric.Denota... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Values for caching evaluation of MTerm
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.MType as MType
import Parametric.Denota... | Maintain ⟦_⟧CompTypeHidCacheWrong | Maintain ⟦_⟧CompTypeHidCacheWrong
This got out of sync with the other version. Probably this belongs to
history though.
| Agda | mit | inc-lc/ilc-agda |
bce471b3be844f987aa2bd3e748f542683de4829 | 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... | Correct wrong comment on changes of products | Correct wrong comment on changes of products
| Agda | mit | inc-lc/ilc-agda |
30936886bb410fbf699a91bd25fbf51d2878e09f | 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.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 a1 da from f1 a1 to f2 ... | module New.NewNew where
open import New.Changes
open import New.LangChanges
open import New.Lang
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 a1 da from f1 a1 to f2 ... | Fix argument order for fromto→valid | Fix argument order for fromto→valid
Also make some arguments explicit where it's going to be required soon.
| Agda | mit | inc-lc/ilc-agda |
9806377d17063141d1be0d07fda712feb086d8b0 | Syntactic/Changes.agda | Syntactic/Changes.agda | module Syntactic.Changes where
-- TERMS that operate on CHANGES
--
-- This module defines terms that correspond to the basic change
-- operations, as well as some other helper terms.
open import Syntactic.Types
open import Syntactic.Contexts Type
open import Syntactic.Terms.Total
open import Changes
_and_ : ∀ {Γ} →... | module Syntactic.Changes where
-- TERMS that operate on CHANGES
--
-- This module defines terms that correspond to the basic change
-- operations, as well as some other helper terms.
open import Syntactic.Types
open import Syntactic.Contexts Type
open import Syntactic.Terms.Total
open import Changes
_and_ : ∀ {Γ} →... | clarify implementation of diff-term by adding pseudocode | agda: clarify implementation of diff-term by adding pseudocode
Old-commit-hash: 531f469c648998b9b89cff66da12e2dbc01a3aea
| Agda | mit | inc-lc/ilc-agda |
9df1056695e49ba8d199081681450dbf409ca429 | 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-apply to apply-term. | Rename lift-apply to apply-term.
Old-commit-hash: b02f9113ba8fab93ce132d5a8abe88b8d4ce471c
| Agda | mit | inc-lc/ilc-agda |
a1b1e5915214625b81e1399a850d92f16cf11d05 | 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... | Delete copy-n-pasted-by-mistake comment | Delete copy-n-pasted-by-mistake comment
This comes directly from Relation.Binary.PropositionalEquality, and is
totally irrelevant here.
Old-commit-hash: d8c5accf1966a913db36fefe149720366811965c
| Agda | mit | inc-lc/ilc-agda |
71d3cf829a84e65c7c028a11e8b02c35297f9f49 | 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 Data.Product
open import Data.Maybe
open import Data.Bool
open imp... | {-# 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 the Agda specification of `coerce` useful for humans | make the Agda specification of `coerce` useful for humans
Type-safety is sacrificed to describe `coerce` without prohibitive
administrative overhead. Unfortunately, `coerce` calls a postulate
on every encounter of a recursive type. It is only good for humans
to read right now; it is not executable.
| Agda | mit | yfcai/CREG |
c4286bde265ec051c1ed0b2dc4b3f95ba028710d | Denotation/Implementation/Popl14.agda | Denotation/Implementation/Popl14.agda | module Denotation.Implementation.Popl14 where
-- Notions of programs being implementations of specifications
-- for Calculus Popl14
open import Denotation.Specification.Canon-Popl14 public
open import Popl14.Syntax.Type
open import Popl14.Syntax.Term
open import Popl14.Change.Derive
open import Relation.Binary.Propo... | module Denotation.Implementation.Popl14 where
-- Notions of programs being implementations of specifications
-- for Calculus Popl14
open import Denotation.Specification.Canon-Popl14 public
open import Popl14.Syntax.Type
open import Popl14.Syntax.Term
open import Popl14.Change.Derive
open import Relation.Binary.Propo... | Support type arguments for infix ≈. | Support type arguments for infix ≈.
Old-commit-hash: e96c855b72f3792e2bc0279596338ed2c82c4c8b
| Agda | mit | inc-lc/ilc-agda |
be5009e736f000abc308cda35f51ca8c075da427 | 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
... | 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
... | Use subst instead of rewrite. | Use subst instead of rewrite.
For unknown reasons, this seems to play better with type inference.
Old-commit-hash: 55d911c0be0ad7f2ae6e77af9d5250bf4e4932b2
| Agda | mit | inc-lc/ilc-agda |
5c780ccbd5c829ffabcb3aa2ec8905291fcbc87a | 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.
----------... | Convert Base.Change.Algebra to Agda 2.4.2 | Convert Base.Change.Algebra to Agda 2.4.2
| Agda | mit | inc-lc/ilc-agda |
1fd25d4aff13f116be831b1d538e1df362ba14e5 | experimental/Embed62.agda | experimental/Embed62.agda | module Embed62 where
open import TaggedDeltaTypes
open import ExplicitNil using (ext³)
open import Relation.Binary.PropositionalEquality
open import Data.Product using (_×_ ; _,_ ; proj₁ ; proj₂)
open import Data.Unit using (⊤ ; tt)
open import Data.Nat
Δ-Type : Type → Type
Δ-Type nats = (nats ⇒ nats ⇒ nats) ⇒ nats -... | module Embed62 where
open import TaggedDeltaTypes
open import ExplicitNil using (ext³)
open import Relation.Binary.PropositionalEquality
open import Data.Product using (_×_ ; _,_ ; proj₁ ; proj₂)
open import Data.Unit using (⊤ ; tt)
open import Data.Nat
natPairVisitor : Type
natPairVisitor = nats ⇒ nats ⇒ nats
Δ-Typ... | refactor proof of embed (#62) | Agda: refactor proof of embed (#62)
This refactoring makes the code of embed readable to humans (say, me).
(One should remember that programming should be about communicating with
humans).
Old-commit-hash: bf8e0402fab99cc5be02c0d14d407dd6c8123e06
| Agda | mit | inc-lc/ilc-agda |
46ea55a1cff1a55f5e77fd87b7af72362e358405 | Syntax/Derive/Plotkin.agda | Syntax/Derive/Plotkin.agda | import Parametric.Syntax.Type as Type
import Base.Syntax.Context as Context
import Parametric.Syntax.Term as Term
import Base.Change.Context as DeltaContext
import Parametric.Change.Type as ChangeType
module Syntax.Derive.Plotkin
{Base : Set {- of base types -}}
{Constant : Context.Context (Type.Type Base) → T... | import Parametric.Syntax.Type as Type
import Base.Syntax.Context as Context
import Parametric.Syntax.Term as Term
import Base.Change.Context as ChangeContext
import Parametric.Change.Type as ChangeType
module Syntax.Derive.Plotkin
{Base : Set {- of base types -}}
{Constant : Context.Context (Type.Type Base) → ... | Update qualified import for new module name. | Update qualified import for new module name.
Old-commit-hash: d14bfe564331d1fd643bdd11a759bb2a5c9338dc
| Agda | mit | inc-lc/ilc-agda |
f0143fea39cd9ef10ecc18c39c4bcb147cf3dc0f | 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* ... | implement apply-term (see #25) | agda: implement apply-term (see #25)
The mutual recursion is accepted by Agda.
Old-commit-hash: 22f8cd2f280a41e9e8e4578726267f3f2a199d3f
| Agda | mit | inc-lc/ilc-agda |
cbe1ca6e8fe8ab815052c5862ecc57d1c11fd7f7 | 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... | ------------------------------------------------------------------------
-- 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... | Document P.C.Validity. | Document P.C.Validity.
Old-commit-hash: 35c83b38382aa41cf8d8162e7cb4e14ec2cd75f0
| Agda | mit | inc-lc/ilc-agda |
50819fad2a9bd8093c7722e7d88f99deb1ca7fc2 | 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... | Move parameter to module level. | Move parameter to module level.
Old-commit-hash: 46e0ad74c26c053c33e0317365ac3c7047809529
| Agda | mit | inc-lc/ilc-agda |
d109d6a26c2ede68c53dd2c7f83ec7f6e6508725 | Syntax/Context/Popl14.agda | Syntax/Context/Popl14.agda | module Syntax.Context.Popl14 where
-- Context specific to Popl14 version of the calculus
--
-- This module exports Syntax.Context specialized to
-- Syntax.Type.Popl14.Type and declares ΔContext appropriate
-- to Popl14 version of the incrementalization system.
-- This ΔContext may not make sense for other systems.
op... | module Syntax.Context.Popl14 where
-- Context specific to Popl14 version of the calculus
--
-- This module exports Syntax.Context specialized to
-- Syntax.Type.Popl14.Type and declares ΔContext appropriate
-- to Popl14 version of the incrementalization system.
-- This ΔContext may not make sense for other systems.
op... | remove redundant 'open' in Syntax.Context.Popl14 | Agda: remove redundant 'open' in Syntax.Context.Popl14
https://github.com/ps-mr/ilc/commit/02bb5ef8bf31b80d9b640a440b4ec1801aa500fe#commitcomment-3645919
Old-commit-hash: 97db5813bea3cc8a973f051efb3b6d3f075681d0
| Agda | mit | inc-lc/ilc-agda |
ac5970524f01ba1d4dfda134c9486fe83efe0e35 | lib/Data/Bool/NP.agda | lib/Data/Bool/NP.agda | {-# OPTIONS --universe-polymorphism #-}
module Data.Bool.NP where
open import Data.Bool using (Bool; true; false; T; if_then_else_; not)
import Algebra
import Data.Bool.Properties
open import Data.Unit using (⊤)
open import Data.Sum
open import Function
open import Relation.Binary.NP
open import Relation.Binary.Logica... | {-# OPTIONS --universe-polymorphism #-}
module Data.Bool.NP where
open import Data.Bool using (Bool; true; false; T; if_then_else_; not)
import Algebra
import Data.Bool.Properties as B
open import Data.Unit using (⊤)
open import Data.Product
open import Data.Sum
open import Function
open import Relation.Binary.NP
open... | Use more the stdlib | Use more the stdlib
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
23b3e5376bd66a7bc1239a94dff9d2749e9a1aee | 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}(f= : ∀ x → f₀ x ≡ f₁ x){{fe : FunExt}} → f₀ ≡ f₁
-- This should be derivable if I ... | {-# 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... | change argument order | FunExt: change argument order
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
89f99238ec73533604712e27553bd981c818d86a | 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 lots of duplication across abs₁ .. abs₆ | Remove lots of duplication across abs₁ .. abs₆
The new code is much more clever. Still not perfect, with varying
arities we can probably do better.
| Agda | mit | inc-lc/ilc-agda |
30e1935a87b6ee45bd8266999805c80b80dd4bd0 | 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 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 ]
... | add map-Dec | add map-Dec
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
bd3c7e9ede5e1077663b478e2d90ba337c971567 | lib/FFI/JS/BigI.agda | lib/FFI/JS/BigI.agda | {-# OPTIONS --without-K #-}
open import FFI.JS hiding (toString)
module FFI.JS.BigI where
postulate BigI : Set
postulate BigI▹JSValue : BigI → JSValue
{-# COMPILED_JS BigI▹JSValue function(x) { return x; } #-}
postulate unsafe-JSValue▹BigI : JSValue → BigI
{-# COMPILED_JS unsafe-JSValue▹BigI function(x) { return x;... | {-# OPTIONS --without-K #-}
open import FFI.JS hiding (toString)
open import Type.Eq using (Eq?)
open import Data.Bool.Base using (Bool; true; false) renaming (T to ✓)
open import Relation.Binary.Core using (_≡_; refl)
open import Relation.Binary.PropositionalEquality.TrustMe using (trustMe)
module FFI.JS.BigI where
... | add Eq? instance, thus depends on nplib | FFI.JS.BigI: add Eq? instance, thus depends on nplib
| Agda | bsd-3-clause | crypto-agda/agda-libjs |
68af677d56d4f0a4c1aaa95134ae06f0813500c1 | arrow.agda | arrow.agda | 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... | 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
... ... | Convert to stdlib | Convert to stdlib
| Agda | mit | louisswarren/hieretikz |
fed88a10935d042bd79da68f2e7233104f1a0536 | program-distance.agda | program-distance.agda | module program-distance where
open import flipbased-implem
open import Data.Bits
open import Data.Bool
open import Data.Vec.NP using (Vec; count; countᶠ)
open import Data.Nat.NP
open import Data.Nat.Properties
open import Relation.Binary
open import Relation.Binary.PropositionalEquality.NP
import Data.Fin as Fin
reco... | module program-distance where
open import flipbased-implem
open import Data.Bits
open import Data.Bool
open import Data.Vec.NP using (Vec; count; countᶠ)
open import Data.Nat.NP
open import Data.Nat.Properties
open import Relation.Nullary
open import Relation.Binary
open import Relation.Binary.PropositionalEquality.NP... | upgrade count, and add antisym | distance: upgrade count, and add antisym
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
74ad4a9a6900f8062300b3ca1cc4b318038c4af5 | 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... | Use HOAS-enabled helpers for nested abstractions. | Use HOAS-enabled helpers for nested abstractions.
Old-commit-hash: 4efbb3abc5e02e14285a2e9c6998ee6f663cbc2d
| Agda | mit | inc-lc/ilc-agda |
b1fdb10a5e323a77a174af8dfdcaab062c73405f | flat-funs-implem.agda | flat-funs-implem.agda | module flat-funs-implem where
open import Data.Unit using (⊤)
open import Data.Fin using (Fin)
open import Data.Nat.NP using (ℕ)
open import Data.Bool using (if_then_else_)
import Data.Vec.NP as V
import Function as F
import Data.Product as ×
open F using (const; _∘′_)
open V using (Vec; []; _∷_; _++_; [_])
open × usi... | module flat-funs-implem where
open import Data.Unit using (⊤)
open import Data.Fin using (Fin)
open import Data.Nat.NP using (ℕ)
open import Data.Bool using (if_then_else_)
import Data.Vec.NP as V
import Function as F
import Data.Product as ×
open F using (const; _∘′_)
open V using (Vec; []; _∷_; _++_; [_])
open × usi... | Upgrade flat-funs-implem | Upgrade flat-funs-implem
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
9b763493d067a9d574644c9fdbeec64fc16872f0 | ZK/JSChecker/Proof.agda | ZK/JSChecker/Proof.agda | {-# OPTIONS --without-K #-}
open import ZK.JSChecker using (verify-PoK-CP-EG-rnd; PoK-CP-EG-rnd; module PoK-CP-EG-rnd)
open import FFI.JS.BigI using (BigI)
open import Data.Product using (_,_)
open import Crypto.JS.BigI.FiniteField
open import Crypto.JS.BigI.CyclicGroup
open import Relation.Binary.PropositionalEquality... | {-# OPTIONS --without-K #-}
open import ZK.Types using (PoK-CP-EG-rnd; module PoK-CP-EG-rnd)
open import FFI.JS.BigI using (BigI)
open import Data.Product using (_,_)
open import Crypto.JS.BigI.FiniteField
open import Crypto.JS.BigI.CyclicGroup
open import Relation.Binary.PropositionalEquality.Base using (_≡_; refl)
im... | Fix imports | ZK.JSChecker.Proof: Fix imports
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
7e41bea4c8fdf5515c5d163b86c4b01ce7e0e399 | 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
_ 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 : ℕ
su... | Add classification | Add classification
| Agda | mit | louisswarren/hieretikz |
5e583450a3104dc6cb3ffb9b3876a297c6a9baf8 | 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... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- The values of terms in Parametric.Change.Term.
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.... | Document P.C.Value. | Document P.C.Value.
Old-commit-hash: 1a3643a6990f5380e0a80e97aa83d76b6a2e2244
| Agda | mit | inc-lc/ilc-agda |
1d37d5dc7cf104062e0fa00000b3b1486d05ea34 | Parametric/Syntax/Term.agda | Parametric/Syntax/Term.agda | import Parametric.Syntax.Type as Type
import Base.Syntax.Context as Context
module Parametric.Syntax.Term
{Base : Set}
(C : Context.Context (Type.Type Base) → Type.Type Base → Set {- of constants -})
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Pr... | import Parametric.Syntax.Type as Type
import Base.Syntax.Context as Context
module Parametric.Syntax.Term
{Base : Set}
(Constant : Context.Context (Type.Type Base) → Type.Type Base → Set {- of constants -})
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import ... | Rename C to Const. | Rename C to Const.
Old-commit-hash: ed6d806588b71d4c3272db594c241e23d0c12a79
| Agda | mit | inc-lc/ilc-agda |
3d721fa8ec4e3e2ec1bf00e4dc87ad1cc5a00225 | 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.Maybe
import Data.Fin as Fin
open Fin using (Fin; zero; suc; #_; inject₁; inject+; raise)
open imp... | 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.Maybe
import Data.Fin as Fin
open Fin using (Fin; zero; suc; #_; inject₁; inject+; raise)
open imp... | Update to stdlib | Update to stdlib
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
4c58b009165ce674a87c1d45177df0c30d306d41 | lib/Explore/Summable.agda | lib/Explore/Summable.agda | module Explore.Summable where
open import Type
open import Function.NP
import Relation.Binary.PropositionalEquality.NP as ≡
open ≡ using (_≡_ ; _≗_ ; _≗₂_)
open import Explore.Type
open import Explore.Product
open import Data.Product
open import Data.Nat.NP
open import Data.Nat.Properties
open import Data.Bool.NP rena... | module Explore.Summable where
open import Type
open import Function.NP
import Relation.Binary.PropositionalEquality.NP as ≡
open ≡ using (_≡_ ; _≗_ ; _≗₂_)
open import Explore.Type
open import Explore.Product
open import Data.Product
open import Data.Nat.NP
open import Data.Nat.Properties
open import Data.Bool.NP rena... | Make Explore.Summable typecheck | Make Explore.Summable typecheck
| Agda | bsd-3-clause | crypto-agda/explore |
818dfccaa5b7e626b635720fbf80318263d4c8d9 | 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
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... | Change strucure for products | Change strucure for products
| Agda | mit | inc-lc/ilc-agda |
da063111bdead7bc9476b14520d957b8057cba93 | 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 Description introductions to operational semantics. | Add Description introductions to operational semantics.
| Agda | bsd-3-clause | spire/spire |
5d7647a9747da1890100da0dfd670ed16f37961a | 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 apply to apply-base. | Rename apply to apply-base.
Old-commit-hash: d8eae9079296e08a6b1db1db97ac5c9722947b28
| Agda | mit | inc-lc/ilc-agda |
abeda4b342c437d506e6e55cef2e20b34d09e7dd | Atlas/Change/Derive.agda | Atlas/Change/Derive.agda | module Atlas.Change.Derive where
open import Atlas.Syntax.Type
open import Atlas.Syntax.Term
open import Atlas.Change.Type
open import Atlas.Change.Term
ΔConst : ∀ {Γ Σ τ} → (c : Const Σ τ) →
Term Γ (internalizeContext (ΔContext′ Σ) (ΔType τ))
ΔConst true = false!
ΔConst false = false!
ΔConst xor = abs₄ (λ x Δx ... | module Atlas.Change.Derive where
open import Atlas.Syntax.Type
open import Atlas.Syntax.Term
open import Atlas.Change.Type
open import Atlas.Change.Term
ΔConst : ∀ {Γ Σ τ} →
Const Σ τ →
Terms (ΔContext Γ) (ΔContext Σ) →
Term (ΔContext Γ) (ΔType τ)
ΔConst true ∅ = false!
ΔConst false ∅ = false!
ΔConst xor (Δx... | Convert ΔConst to new derivation interface. | Convert ΔConst to new derivation interface.
Old-commit-hash: 7b59661ce496b2c2659e20c6f9c4f528ddbd6102
| Agda | mit | inc-lc/ilc-agda |
6d4ce38ab949f2a79c7caa46d5283b91888d5b61 | FunUniverse/Fin.agda | FunUniverse/Fin.agda | {-# OPTIONS --without-K #-}
module FunUniverse.Fin where
open import Type
open import Data.Nat using (ℕ)
open import Data.Fin using (Fin)
open import FunUniverse.Data
open import FunUniverse.Core
_→ᶠ_ : ℕ → ℕ → ★
_→ᶠ_ i o = Fin i → Fin o
finFunU : FunUniverse ℕ
finFunU = Fin-U , _→ᶠ_
module FinFunUniverse = FunUni... | {-# OPTIONS --without-K #-}
module FunUniverse.Fin where
open import Type
open import Function
open import Data.Nat using (ℕ)
open import Data.Fin using (Fin)
open import FunUniverse.Data
open import FunUniverse.Core
open import FunUniverse.Category
open import FunUniverse.Rewiring.Linear
_→ᶠ_ : ℕ → ℕ → ★
_→ᶠ_ i o =... | add finCat | FunUniverse.Fin: add finCat
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
f53c070dcba6e92a79746f5762bb453a510cf059 | README.agda | README.agda | module README 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 README 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*... | comment fix | agda: comment fix
Old-commit-hash: d5ff611d7aaf67a4b7821fedb255e43d07c53504
| Agda | mit | inc-lc/ilc-agda |
2cf425c915364c989a28b50e75f8d096d98a2b30 | 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* ... | Prepare for using ≈-Reasoning to prove derive-term-correct (see #25). | Prepare for using ≈-Reasoning to prove derive-term-correct (see #25).
Old-commit-hash: b0ca315e1dcaa44e39fdfa67bb29e1da512641a6
| Agda | mit | inc-lc/ilc-agda |
5084db0b3e01eca253b247da48daf55234039968 | derivation.agda | derivation.agda | module derivation where
open import lambda
-- KO: Is it correct that this file is supposed to contain the syntactic
-- variants of the operations in Changes.agda?
-- If so, why does it have a different (and rather strange) Δ-Type definition?
-- Why are the base cases (bool) all missing? The inductive cases look
-- b... | module derivation where
open import lambda
-- KO: Is it correct that this file is supposed to contain the syntactic
-- variants of the operations in Syntactic.Changes.agda?
-- If so, why does it have a different (and rather strange) Δ-Type definition?
-- Why are the base cases (bool) all missing? The inductive cases... | Update derivation.agda | Update derivation.agda
typo
Old-commit-hash: 719b7f355a6ddb5cacf3f0d3a90f563748f921a0
| Agda | mit | inc-lc/ilc-agda |
0ea931fffedcc73acbb0013981dff55d1c0d69ce | Thesis/LangChanges.agda | Thesis/LangChanges.agda | module Thesis.LangChanges where
open import Thesis.Changes
open import Thesis.IntChanges
open import Thesis.Lang
open import Relation.Binary.PropositionalEquality
Chτ : (τ : Type) → Set
Chτ τ = ⟦ Δt τ ⟧Type
ΔΓ : Context → Context
ΔΓ ∅ = ∅
ΔΓ (τ • Γ) = Δt τ • τ • ΔΓ Γ
ChΓ : ∀ (Γ : Context) → Set
ChΓ Γ = ⟦ ΔΓ Γ ⟧Cont... | module Thesis.LangChanges where
open import Thesis.Changes
open import Thesis.IntChanges
open import Thesis.Lang
open import Relation.Binary.PropositionalEquality
Chτ : (τ : Type) → Set
Chτ τ = ⟦ Δt τ ⟧Type
ΔΓ : Context → Context
ΔΓ ∅ = ∅
ΔΓ (τ • Γ) = Δt τ • τ • ΔΓ Γ
ChΓ : ∀ (Γ : Context) → Set
ChΓ Γ = ⟦ ΔΓ Γ ⟧Cont... | Revert "Show we can define e⊕ using base values in changes" | Revert "Show we can define e⊕ using base values in changes"
That was a demonstration, but the old definition is the one I prefer.
This reverts commit 47190645cc58ddea24ef59e6877fda0473ae4818.
| Agda | mit | inc-lc/ilc-agda |
4c8990f1323496415af84ce8c49e276f0c366745 | 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... | Improve commentary in Base.Syntax.Context. | Improve commentary in Base.Syntax.Context.
Old-commit-hash: 4886ab0c5f6e2cdc47142a8ae0c717890f449f93
| Agda | mit | inc-lc/ilc-agda |
a3b1db76fbdbf97e5638eca08c0475817ff1afca | lib/Algebra/Monoid.agda | lib/Algebra/Monoid.agda | {-# OPTIONS --without-K #-}
open import Type using () renaming (Type_ to Type)
open import Level.NP
open import Function.NP
open import Data.Product.NP
open import Data.Nat
using (ℕ; zero)
renaming (_+_ to _+ℕ_; _*_ to _*ℕ_; suc to 1+_)
import Data.Nat.Properties.Simple as ℕ°
open import Data.Integer.NP
using ... | {-# OPTIONS --without-K #-}
open import Type using (Type_)
open import Function.NP
open import Function.Extensionality
open import Data.Product.NP
open import Relation.Binary.PropositionalEquality.NP using (_≡_; idp; ap; ap₂)
import Algebra.FunctionProperties.Eq
open Algebra.FunctionProperties.Eq.Implicits
module Alge... | add the Pointwise construction | Monoid: add the Pointwise construction
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
b6915db12b7c450d87def9967c9830d36ca626b4 | 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 change semantics | Simplify change semantics
| Agda | mit | inc-lc/ilc-agda |
5c76b2f48299a010ec3ccf23921c0a130d17d754 | 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.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 a1 da from f1 a1 to f2 ... | Drop redundant import | Drop redundant import
| Agda | mit | inc-lc/ilc-agda |
e6b366592e727138ab845e5190ed6c35fa3d28d4 | js-experiment/prelude.agda | js-experiment/prelude.agda | module _ where
open import Agda.Primitive public
using (Level; _⊔_)
renaming (lzero to ₀; lsuc to ₛ)
-- open import Function.NP
id : ∀ {a} {A : Set a} (x : A) → A
id x = x
infixr 9 _∘_
_∘_ : ∀ {a b c}
{A : Set a} {B : A → Set b} {C : {x : A} → B x → Set c} →
(∀ {x} (y : B x) → C y) → (g : (x :... | module _ where
open import Agda.Primitive public
using (Level; _⊔_)
renaming (lzero to ₀; lsuc to ₛ)
-- open import Function.NP
id : ∀ {a} {A : Set a} (x : A) → A
id x = x
infixr 9 _∘_
_∘_ : ∀ {a b c}
{A : Set a} {B : A → Set b} {C : {x : A} → B x → Set c} →
(∀ {x} (y : B x) → C y) → (g : (x :... | make × universe polymorphic | make × universe polymorphic
| Agda | bsd-3-clause | crypto-agda/protocols |
5760ecf94ca99d0cf810abe16aba48c31d177ad8 | Structure/Bag/Nehemiah.agda | Structure/Bag/Nehemiah.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Bags of integers, for Nehemiah plugin.
--
-- This module imports postulates about bags of integers
-- with negative multiplicities as a group under additive union.
---------------------------------------------------... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Bags of integers, for Nehemiah plugin.
--
-- This module imports postulates about bags of integers
-- with negative multiplicities as a group under additive union.
---------------------------------------------------... | Simplify code | Simplify code
| Agda | mit | inc-lc/ilc-agda |
5013dd25be51aea4374492d685bcc066ae526e82 | 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... | Define setoid for d.o.e. (not very succesfully) | Agda: Define setoid for d.o.e. (not very succesfully)
This setoid can be defined, but using it for equational reasoning seems
not so convenient. I guess a reason is that unifying against _≙_ might
be harder (see comments at the end).
The other, bigger problem is that most reasonings here need to rewrite
dx₁ ≙ dx₂ int... | Agda | mit | inc-lc/ilc-agda |
57da8ab233fdca3b992d585fa703f2c305a61295 | sha1.agda | sha1.agda | {-# OPTIONS --without-K #-}
-- https://upload.wikimedia.org/wikipedia/commons/e/e2/SHA-1.svg
-- http://www.faqs.org/rfcs/rfc3174.html
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 Data.Product
open import Function.NP h... | {-# OPTIONS --without-K #-}
-- https://upload.wikimedia.org/wikipedia/commons/e/e2/SHA-1.svg
-- http://www.faqs.org/rfcs/rfc3174.html
open import Data.Nat.NP using (ℕ; zero; suc; _+_; _∸_)
import Data.Vec as V
open V using (Vec; []; _∷_)
open import Function.NP using (Endo; _∘_)
open import FunUniverse.Core hiding (_,_... | Fix sha1... | Fix sha1...
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
bfcd2eb5d4fab7bcb698719c3f02fc2aea768cf3 | lib/Data/Tree/Binary.agda | lib/Data/Tree/Binary.agda | {-# OPTIONS --without-K #-}
open import Type hiding (★)
module Data.Tree.Binary where
data BinTree {a} (A : ★ a) : ★ a where
empty : BinTree A
leaf : A → BinTree A
fork : (ℓ r : BinTree A) → BinTree A
| {-# OPTIONS --without-K #-}
open import Type hiding (★)
open import Level
open import Data.Zero
open import Data.Sum
module Data.Tree.Binary where
data BinTree {a} (A : ★ a) : ★ a where
empty : BinTree A
leaf : A → BinTree A
fork : (ℓ r : BinTree A) → BinTree A
Any : ∀ {a p}{A : ★ a}(P : A → ★ p) → BinTree ... | Add Any predicate for binary tree | Add Any predicate for binary tree
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
5c1ef9d73912d2e59b329ff1866bf20c6dddefc2 | Crypto/JS/BigI/CyclicGroup.agda | Crypto/JS/BigI/CyclicGroup.agda | {-# OPTIONS --without-K #-}
open import Type.Eq
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.List.Base using (List; foldr)
open import Data.Two hiding (_==_)
open import Relation.B... | {-# OPTIONS --without-K #-}
open import Type.Eq
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.List.Base using (List; foldr)
open import Data.Two hiding (_==_)
open import Relation.B... | Remove a useless check: the point of ℤp★ is to not have 0 | Remove a useless check: the point of ℤp★ is to not have 0
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
e6dc4b68e44d8d340a5227f0ad0a4240a5f086a9 | Attack/Compression.agda | Attack/Compression.agda | {-# OPTIONS --copatterns #-}
-- Compression can be used an an Oracle to defeat encryption.
-- Here we show how compressing before encrypting lead to a
-- NOT semantically secure construction (IND-CPA).
module Attack.Compression where
open import Type using (★)
open import Function
open import Data.Nat.NP
open import D... | {-# OPTIONS --copatterns #-}
-- Compression can be used an an Oracle to defeat encryption.
-- Here we show how compressing before encrypting lead to a
-- NOT semantically secure construction (IND-CPA).
module Attack.Compression where
open import Type using (★)
open import Function.NP
open import Data.Nat.NP
open impor... | work around the instance argument becoming weaker... | Attack.Compression: work around the instance argument becoming weaker...
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
eb332321cb55523e6068bacced76b6f0bc2f6f7b | 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... | Simplify reexports. | Simplify reexports.
Merge open declarations, reexport everything.
Old-commit-hash: 69a4b0415ae43f3db65282495914ddf7a6fe06fd
| Agda | mit | inc-lc/ilc-agda |
9e4e42995f871b15f24591bd95cac30bfecb1bda | Game/Transformation/CPAd-CPA.agda | Game/Transformation/CPAd-CPA.agda |
{-# OPTIONS --without-K --copatterns #-}
open import Type
open import Data.Bit
open import Data.Maybe
open import Data.Product
open import Data.One
open import Control.Strategy renaming (run to runStrategy; map to mapStrategy)
open import Function
open import Relation.Binary.PropositionalEquality
import Game.IND-C... |
{-# OPTIONS --without-K --copatterns #-}
open import Type
open import Data.Bit
open import Data.Maybe
open import Data.Product
open import Data.One
open import Control.Strategy renaming (run to runStrategy; map to mapStrategy)
open import Function
open import Relation.Binary.PropositionalEquality
import Game.IND-C... | fix copattern error in CPAd-CPA | fix copattern error in CPAd-CPA
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.