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 |
|---|---|---|---|---|---|---|---|---|---|
07045b7aa32a14de23ec233029b6fc6134b24685 | experiment/liftVec.agda | experiment/liftVec.agda | open import Function
open import Data.Nat using (ℕ ; suc ; zero)
open import Data.Fin using (Fin)
open import Data.Vec
open import Data.Vec.N-ary.NP
open import Relation.Binary.PropositionalEquality
module liftVec where
module single (A : Set)(_+_ : A → A → A)where
data Tm : Set where
var : Tm
cst : A → Tm
... | open import Function
open import Data.Nat using (ℕ ; suc ; zero)
open import Data.Fin using (Fin)
open import Data.Vec
open import Data.Vec.N-ary.NP
open import Relation.Binary.PropositionalEquality
module liftVec where
module single (A : Set)(_+_ : A → A → A)where
data Tm : Set where
var : Tm
cst : A → Tm
... | Upgrade to Data.Two | Upgrade to Data.Two
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
a79e9939c6512db4827fc831f2689871d99cfc26 | Base/Change/Context.agda | Base/Change/Context.agda | module Base.Change.Context
{Type : Set}
(ΔType : Type → Type) where
-- Transform a context of values into a context of values and
-- changes.
open import Base.Syntax.Context Type
ΔContext : Context → Context
ΔContext ∅ = ∅
ΔContext (τ • Γ) = ΔType τ • τ • ΔContext Γ
-- like ΔContext, but ΔType τ and τ are s... | module Base.Change.Context
{Type : Set}
(ΔType : Type → Type) where
open import Base.Syntax.Context Type
-- Transform a context of values into a context of values and
-- changes.
ΔContext : Context → Context
ΔContext ∅ = ∅
ΔContext (τ • Γ) = ΔType τ • τ • ΔContext Γ
-- like ΔContext, but ΔType τ and τ are s... | Move function-specific comment right before function | Move function-specific comment right before function
Currently, this seems a comment about the whole module.
Old-commit-hash: c25e918e712496981adfe4c74f94a8d80e8e5052
| Agda | mit | inc-lc/ilc-agda |
06d988ce4bc3692e4e60e39bdb8f2e1daddb660e | Denotation/Change/Popl14.agda | Denotation/Change/Popl14.agda | module Denotation.Change.Popl14 where
-- Changes for Calculus Popl14
--
-- Contents
-- - Mutually recursive concepts: ΔVal, validity.
-- Under module Syntax, the corresponding concepts of
-- ΔType and ΔContext reside in separate files.
-- Now they have to be together due to mutual recursiveness.
-- - `diff... | module Denotation.Change.Popl14 where
-- Changes for Calculus Popl14
--
-- Contents
-- - Mutually recursive concepts: ΔVal, validity.
-- Under module Syntax, the corresponding concepts of
-- ΔType and ΔContext reside in separate files.
-- Now they have to be together due to mutual recursiveness.
-- - `diff... | add type annotations to Denotation.Change.Popl14 | [WIP] add type annotations to Denotation.Change.Popl14
Old-commit-hash: 90b06722aecf9d0b5c6c69547217cb2c522912be
| Agda | mit | inc-lc/ilc-agda |
d9a3d68c58bd5c8ae49738e7a8f68fd5e89b4bce | lambda.agda | lambda.agda | module lambda where
open import Relation.Binary.PropositionalEquality
open import Denotational.Notation
-- SIMPLE TYPES
-- Syntax
data Type : Set where
_⇒_ : (τ₁ τ₂ : Type) → Type
bool : Type
infixr 5 _⇒_
-- Denotational Semantics
data Bool : Set where
true false : Bool
⟦_⟧Type : Type -> Set
⟦ τ₁ ⇒ τ₂ ⟧T... | module lambda where
open import Relation.Binary.PropositionalEquality
open import Syntactic.Types public
open import Syntactic.Contexts Type public
open import Denotational.Notation
open import Denotational.Values public
open import Denotational.Environments Type ⟦_⟧Type public
-- TERMS
-- Syntax
data Term : Cont... | Improve reuse (see #28). | Improve reuse (see #28).
Old-commit-hash: 7da11aabf971e192ab71542164b98c80cbe26325
| Agda | mit | inc-lc/ilc-agda |
a883bca1e4dcf18cbd172d5af888116a00518e15 | Parametric/Change/Term.agda | Parametric/Change/Term.agda | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.Type as ChangeType
module Parametric.Change.Term
{Base : Set}
(Constant : Term.Structure Base)
(ΔBase : ChangeType.Structure Base)
where
-- Terms that operate on changes
open Type.Structure Base
open Te... | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.Type as ChangeType
module Parametric.Change.Term
{Base : Set}
(Constant : Term.Structure Base)
(ΔBase : ChangeType.Structure Base)
where
-- Terms that operate on changes
open Type.Structure Base
open Te... | Rename lift-diff to diff-term. | Rename lift-diff to diff-term.
Old-commit-hash: 64cb73fbed07060d460e4d9ee85fcec48281d13a
| Agda | mit | inc-lc/ilc-agda |
b01d8abafe916c9d2d8af12b12d2adb5f2ae8340 | Syntax/Term/Plotkin.agda | Syntax/Term/Plotkin.agda | module Syntax.Term.Plotkin where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Product
open import Syntax.Type.Plotkin
open import Syntax.Context
data Term
{B : Set {- of base types -}}
{C : Set {- of constants -}}
{type-of : C → Type B}
(Γ : Context {Type... | module Syntax.Term.Plotkin
{B : Set {- of base types -}}
{C : Set {- of constants -}}
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Product
open import Syntax.Type.Plotkin
open import Syntax.Context
data Term
{type-of : C → Type B}
(Γ : Context... | Move parameters to module level. | Move parameters to module level.
All definitions in this module depend on the parameters {B} and
{C} which never change inside this module. So it is easier to
parameterize the whole module instead of each separate
definition.
Old-commit-hash: 1303320f48d486d11152713c604275c2c7bcdc18
| Agda | mit | inc-lc/ilc-agda |
9755ab9f86f1e00b28c36e99421e4e9be389a95f | Base/Change/Products.agda | Base/Change/Products.agda | module Base.Change.Products where
open import Relation.Binary.PropositionalEquality
open import Level
open import Base.Change.Algebra
open import Data.Product
-- Also try defining sectioned change structures on the positives halves of
-- groups? Or on arbitrary subsets?
-- Restriction: we pair sets on the same lev... | module Base.Change.Products where
open import Relation.Binary.PropositionalEquality
open import Level
open import Base.Change.Algebra
open import Data.Product
-- Also try defining sectioned change structures on the positives halves of
-- groups? Or on arbitrary subsets?
-- Restriction: we pair sets on the same lev... | Comment out holes to ensure Everything compiles again | Comment out holes to ensure Everything compiles again
Old-commit-hash: dfc28a00f9301015066e19d4be2c4179f8e0849b
| Agda | mit | inc-lc/ilc-agda |
07b3b64ff9795f6941b64231e7b2a0dd630e0de4 | lib/Explore/Examples.agda | lib/Explore/Examples.agda | {-# OPTIONS --without-K #-}
module Explore.Examples where
open import Type
open import Level.NP
open import Data.Maybe.NP
open import Data.List
open import Data.Two
open import Data.Product
open import Data.Sum.NP
open import Data.One
open import HoTT using (UA)
open import Function.Extensionality using (FunExt)
open ... | {-# OPTIONS --without-K #-}
module Explore.Examples where
open import Type
open import Level.NP
open import Data.Maybe.NP
open import Data.List
open import Data.Zero
open import Data.One
open import Data.Two
open import Data.Product
open import Data.Sum.NP
open import HoTT using (UA)
open import Function.NP
open impor... | Update the Examples | Update the Examples
| Agda | bsd-3-clause | crypto-agda/explore |
b4c39231ae725a5b759926a08d76642ed2df680d | Base/Change/Products.agda | Base/Change/Products.agda | module Base.Change.Products where
open import Relation.Binary.PropositionalEquality
open import Level
open import Base.Change.Algebra
open import Data.Product
-- Also try defining sectioned change structures on the positives halves of
-- groups? Or on arbitrary subsets?
-- Restriction: we pair sets on the same lev... | module Base.Change.Products where
open import Relation.Binary.PropositionalEquality
open import Level
open import Base.Change.Algebra
open import Data.Product
-- Also try defining sectioned change structures on the positives halves of
-- groups? Or on arbitrary subsets?
-- Restriction: we pair sets on the same lev... | Simplify code | Base.Change.Products: Simplify code
These simplifications are inspired by Base.Change.Sums. But they're
still modest.
| Agda | mit | inc-lc/ilc-agda |
5957a0a5f21ebc9ad88ea001c4afa6b381372c04 | Parametric/Change/Type.agda | Parametric/Change/Type.agda | import Parametric.Syntax.Type as Type
module Parametric.Change.Type
(Base : Type.Structure)
where
open Type.Structure Base
Structure : Set
Structure = Base → Base
module Structure (ΔBase : Structure) where
ΔType : Type → Type
ΔType (base ι) = base (ΔBase ι)
ΔType (σ ⇒ τ) = σ ⇒ ΔType σ ⇒ ΔType τ
open im... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Simply-typed changes (Fig. 3 and Fig. 4d)
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
module Parametric.Change.Type
(Base : Type.Structure)
wh... | Document P.C.Type. | Document P.C.Type.
Old-commit-hash: 11e38d018843f21411d014020ce42181e1f77d32
| Agda | mit | inc-lc/ilc-agda |
27037592477c7d9112554d56337e06c5a2c6f0b9 | Parametric/Syntax/Term.agda | Parametric/Syntax/Term.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- The syntax of terms (Fig. 1a and 1b).
------------------------------------------------------------------------
-- The syntax of terms depends on the syntax of simple types
-- (because terms are indexed by types in ... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- The syntax of terms (Fig. 1a and 1b).
------------------------------------------------------------------------
-- The syntax of terms depends on the syntax of simple types
-- (because terms are indexed by types in ... | Remove remaining duplication between abs₁ ... abs₆ | Remove remaining duplication between abs₁ ... abs₆
This relies on Agda 2.4.0's varying arity in a more essential way.
| Agda | mit | inc-lc/ilc-agda |
05536450804504640dcab4d2a372088bbc7ef7b3 | src/fot/FOTC/Program/McCarthy91/PropertiesATP.agda | src/fot/FOTC/Program/McCarthy91/PropertiesATP.agda | ------------------------------------------------------------------------------
-- Main properties of the McCarthy 91 function
------------------------------------------------------------------------------
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
-- The main properties proved of the McCar... | ------------------------------------------------------------------------------
-- Main properties of the McCarthy 91 function
------------------------------------------------------------------------------
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
-- The main properties proved of the McCar... | Revert "Added a non-required totality hypothesis." | Revert "Added a non-required totality hypothesis."
This reverts commit 57708b770c00d1ba6276cda0f02752e147f2f533.
| Agda | mit | asr/fotc,asr/fotc |
f04e665aed5f41deea97dd4b7160ad5ee957e41a | Nehemiah/Change/Validity.agda | Nehemiah/Change/Validity.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Dependently typed changes with the Nehemiah plugin.
------------------------------------------------------------------------
module Nehemiah.Change.Validity where
open import Nehemiah.Syntax.Type
open import Nehem... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Dependently typed changes with the Nehemiah plugin.
------------------------------------------------------------------------
module Nehemiah.Change.Validity where
open import Nehemiah.Syntax.Type
open import Nehem... | Update Nehemiah.Change.Validity | Update Nehemiah.Change.Validity
* Adapt to weaker instance resolution.
* Omit module application that runs into agda/agda#1985.
| Agda | mit | inc-lc/ilc-agda |
94c667f3d542af3d0d5f3f603fe4d1aeccaf6e95 | New/Changes.agda | New/Changes.agda | module New.Changes where
open import Relation.Binary.PropositionalEquality
open import Level
open import Data.Unit
open import Data.Product
record IsChAlg {ℓ : Level} (A : Set ℓ) (Ch : Set ℓ) : Set (suc ℓ) where
field
_⊕_ : A → Ch → A
_⊝_ : A → A → Ch
valid : A → Ch → Set ℓ
⊝-valid : ∀ (a b : A) → v... | module New.Changes where
open import Relation.Binary.PropositionalEquality
open import Level
open import Data.Unit
open import Data.Product
open import Data.Sum
record IsChAlg {ℓ : Level} (A : Set ℓ) (Ch : Set ℓ) : Set (suc ℓ) where
field
_⊕_ : A → Ch → A
_⊝_ : A → A → Ch
valid : A → Ch → Set ℓ
⊝-va... | Add change structure for changes | Add change structure for changes
| Agda | mit | inc-lc/ilc-agda |
f1c2df98ed89a3de0f4b42407cb950eded1c5ed4 | total.agda | total.agda | module total where
-- INCREMENTAL λ-CALCULUS
-- with total derivatives
--
-- Features:
-- * changes and derivatives are unified (following Cai)
-- * Δ e describes how e changes when its free variables or its arguments change
-- * denotational semantics including semantics of changes
--
-- Note that Δ is *not* ... | module total where
-- INCREMENTAL λ-CALCULUS
-- with total derivatives
--
-- Features:
-- * changes and derivatives are unified (following Cai)
-- * Δ e describes how e changes when its free variables or its arguments change
-- * denotational semantics including semantics of changes
--
-- Note that Δ is *not* ... | Increase overloading and confusion. | Increase overloading and confusion.
Old-commit-hash: df682306832e5b833f837c92dec32b3c428a7ab9
| Agda | mit | inc-lc/ilc-agda |
757995f811b789374410d560566e8717a68f1e24 | Base/Change/Equivalence.agda | Base/Change/Equivalence.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Delta-observational equivalence
------------------------------------------------------------------------
module Base.Change.Equivalence where
open import Relation.Binary.PropositionalEquality
open import Base.Chang... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Delta-observational equivalence
------------------------------------------------------------------------
module Base.Change.Equivalence where
open import Relation.Binary.PropositionalEquality
open import Base.Chang... | Revert "Show how badly reasoning for ≙ and ≡ combine" | Revert "Show how badly reasoning for ≙ and ≡ combine"
This reverts commit 24faa2c5edd91d1db64977d5124ef40e01de433f. The commit
showed how badly something worked, so let's leave in the old version for
now.
Old-commit-hash: 9f5f49cf0319ba809356655a204ec83725dfceb4
| Agda | mit | inc-lc/ilc-agda |
c1d53d1c793d91e002e6c8b4ffbbcc8dca4c6eda | README.agda | README.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Machine-checked formalization of the theoretical results presented
-- in the paper:
--
-- Yufei Cai, Paolo G. Giarrusso, Tillmann Rendel, Klaus Ostermann.
-- A Theory of Changes for Higher-Order Languages:
-- ... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Machine-checked formalization of the theoretical results presented
-- in the paper:
--
-- Yufei Cai, Paolo G. Giarrusso, Tillmann Rendel, Klaus Ostermann.
-- A Theory of Changes for Higher-Order Languages:
-- ... | Update recommended version of Agda | README.agda: Update recommended version of Agda
Rationale: 2.4.0 doesn't install any more.
| Agda | mit | inc-lc/ilc-agda |
464a985aa70ecceb7a7917d62fc7cb3e05dd59c2 | models/Desc.agda | models/Desc.agda | {-# OPTIONS --type-in-type
--no-termination-check
--no-positivity-check #-}
module Desc where
--********************************************
-- Prelude
--********************************************
-- Some preliminary stuffs, to avoid relying on the stdlib
--****************
-- Sigma and fr... | {-# OPTIONS --type-in-type #-}
module Desc where
--********************************************
-- Prelude
--********************************************
-- Some preliminary stuffs, to avoid relying on the stdlib
--****************
-- Sigma and friends
--****************
data Sigma (A : Set) (B : A -> Set) : Set ... | Update Desc model. Follow ICFP paper. With type-in-type, but termination-checker-friendly. | Update Desc model. Follow ICFP paper. With type-in-type, but termination-checker-friendly. | Agda | mit | kwangkim/pigment,kwangkim/pigment,brixen/Epigram,kwangkim/pigment |
7f1a4e72fc0081b46fe06904e4627bb80b3240ac | proposal/examples/TacticsMatchingFunctionCalls.agda | proposal/examples/TacticsMatchingFunctionCalls.agda | {-
This file demonstrates a technique that simulates the ability to
pattern match against function calls rather than just variables
or constructors.
This technique is necessary to write certain kinds of tactics
as generic functions.
-}
module TacticsMatchingFunctionCalls where
open import Data.Bool hiding ( _≟_ )
op... | {-
This file demonstrates a technique that simulates the ability to
pattern match against function calls rather than just variables
or constructors.
This technique is necessary to write certain kinds of tactics
as generic functions.
-}
module TacticsMatchingFunctionCalls where
open import Data.Bool hiding ( _≟_ )
op... | Add Coq's "simp" tactic. | Add Coq's "simp" tactic.
| Agda | bsd-3-clause | spire/spire |
71b3a14edcb512975548e8df67858a30b1f62d68 | Syntax/Term/Plotkin.agda | Syntax/Term/Plotkin.agda | import Syntax.Type.Plotkin as Type
import Syntax.Context as Context
module Syntax.Term.Plotkin
{B : Set {- of base types -}}
{C : Context.Context {Type.Type B} → Type.Type B → Set {- of constants -}}
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Pr... | import Syntax.Type.Plotkin as Type
import Syntax.Context as Context
module Syntax.Term.Plotkin
{B : Set {- of base types -}}
{C : Context.Context {Type.Type B} → Type.Type B → Set {- of constants -}}
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Pr... | Rename TermConstructor to CurriedTermConstructor. | Rename TermConstructor to CurriedTermConstructor.
This rename prepares for introducing UncurriedTermConstructor which
will allow to clarify the role of lift-η-const-rec.
Old-commit-hash: b9de3c413f5a2a2015d3114bfb8483ab3078cc06
| Agda | mit | inc-lc/ilc-agda |
6538c1e3a868c0dc095139fc2243a8683b77c995 | Data/NatBag/Properties.agda | Data/NatBag/Properties.agda | module Data.NatBag.Properties where
import Data.Nat as ℕ
open import Relation.Binary.PropositionalEquality
open import Data.NatBag
open import Data.Integer
open import Data.Sum hiding (map)
open import Data.Product hiding (map)
-- This import is too slow.
-- It causes Agda 2.3.2 to use so much memory that cai's
-- co... | module Data.NatBag.Properties where
import Data.Nat as ℕ
open import Relation.Binary.PropositionalEquality
open import Data.NatBag
open import Data.Integer
open import Data.Sum hiding (map)
open import Data.Product hiding (map)
-- This import is too slow.
-- It causes Agda 2.3.2 to use so much memory that cai's
-- co... | Remove dead code of Data.NatBag.Properties Checkpoint: Recast property proofs using set theoretic methods (#55) | Remove dead code of Data.NatBag.Properties
Checkpoint: Recast property proofs using set theoretic methods (#55)
Old-commit-hash: 04b32e5d92152cdab089a25c0d8f9f4c39279fb0
| Agda | mit | inc-lc/ilc-agda |
2971c097d16d13188929ef857808539310db0b8e | meaning.agda | meaning.agda | module meaning where
open import Level
record Meaning (Syntax : Set) {ℓ : Level} : Set (suc ℓ) where
constructor
meaning
field
{Semantics} : Set ℓ
⟦_⟧ : Syntax → Semantics
open Meaning {{...}} public
| module meaning where
open import Level
record Meaning (Syntax : Set) {ℓ : Level} : Set (suc ℓ) where
constructor
meaning
field
{Semantics} : Set ℓ
⟨_⟩⟦_⟧ : Syntax → Semantics
open Meaning {{...}} public
renaming (⟨_⟩⟦_⟧ to ⟦_⟧)
open Meaning public
using (⟨_⟩⟦_⟧)
| Improve printing of resolved overloading. | Improve printing of resolved overloading.
After this change, the semantic brackets will contain the syntactic
thing even if Agda displays explicitly resolved overloaded notation.
Old-commit-hash: c8cbc43ed8e715342e0cc3bccc98e0be2dd23560
| Agda | mit | inc-lc/ilc-agda |
b5190556d5bc58a768c39b9fa871dea8b2d6f0f1 | Parametric/Change/Term.agda | Parametric/Change/Term.agda | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.Type as ChangeType
module Parametric.Change.Term
{Base : Set}
(Constant : Term.Structure Base)
(ΔBase : ChangeType.Structure Base)
where
-- Terms that operate on changes
open Type.Structure Base
open Te... | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.Type as ChangeType
module Parametric.Change.Term
{Base : Set}
(Constant : Term.Structure Base)
(ΔBase : ChangeType.Structure Base)
where
-- Terms that operate on changes
open Type.Structure Base
open Te... | Fix bug in diff-term. | Fix bug in diff-term.
Old-commit-hash: 01ada999b676d2a8a2ab289b3a0c79f1524620e5
| Agda | mit | inc-lc/ilc-agda |
011116b87218eb84d5010b97f93c495b4f090fae | incremental.agda | incremental.agda | module incremental where
-- SIMPLE TYPES
-- Syntax
data Type : Set where
_⇒_ : (τ₁ τ₂ : Type) → Type
infixr 5 _⇒_
-- Semantics
Dom⟦_⟧ : Type -> Set
Dom⟦ τ₁ ⇒ τ₂ ⟧ = Dom⟦ τ₁ ⟧ → Dom⟦ τ₂ ⟧
-- TYPING CONTEXTS
-- Syntax
data Context : Set where
∅ : Context
_•_ : (τ : Type) (Γ : Context) → Context
infixr 9 _... | module incremental where
-- SIMPLE TYPES
-- Syntax
data Type : Set where
_⇒_ : (τ₁ τ₂ : Type) → Type
infixr 5 _⇒_
-- Semantics
Dom⟦_⟧ : Type -> Set
Dom⟦ τ₁ ⇒ τ₂ ⟧ = Dom⟦ τ₁ ⟧ → Dom⟦ τ₂ ⟧
-- TYPING CONTEXTS
-- Syntax
data Context : Set where
∅ : Context
_•_ : (τ : Type) (Γ : Context) → Context
infixr 9 _... | Implement nil changes. | Implement nil changes.
Old-commit-hash: da546d60ec48fe5f6f8b261aac1fdbb71b18fa69
| Agda | mit | inc-lc/ilc-agda |
f2fde70dc52c3050e537b787efd3c7efa9778118 | Syntax/Term/Plotkin.agda | Syntax/Term/Plotkin.agda | import Syntax.Type.Plotkin as Type
import Syntax.Context as Context
module Syntax.Term.Plotkin
{B : Set {- of base types -}}
{C : Context.Context {Type.Type B} → Type.Type B → Set {- of constants -}}
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Pr... | import Syntax.Type.Plotkin as Type
import Syntax.Context as Context
module Syntax.Term.Plotkin
{B : Set {- of base types -}}
{C : Context.Context {Type.Type B} → Type.Type B → Set {- of constants -}}
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Pr... | Introduce HOAS-like smart constructors for lambdas | Introduce HOAS-like smart constructors for lambdas
Old-commit-hash: 6bf4939f8ec84c611d98f6f2395332943573dfe5
| Agda | mit | inc-lc/ilc-agda |
8514aefef6973b813691fb922e6d44e072cfc75d | generic-zero-knowledge-interactive.agda | generic-zero-knowledge-interactive.agda | open import Type
open import Data.Bool.NP as Bool hiding (check)
open import Data.Nat
open import Data.Maybe
open import Data.Product.NP
open import Data.Bits
open import Function.NP
open import Relation.Binary.PropositionalEquality.NP
open import sum
module generic-zero-knowledge-interactive where
-- A random argum... | open import Type
open import Data.Bool.NP as Bool hiding (check)
open import Data.Nat
open import Data.Maybe
open import Data.Product.NP
open import Data.Bits
open import Function.NP
open import Relation.Binary.PropositionalEquality.NP
open import sum
module generic-zero-knowledge-interactive where
-- A random argum... | update generic ZK | update generic ZK
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
569e98b5b6d8a84329f54249ad3f83477357f717 | flipbased-implem.agda | flipbased-implem.agda | module flipbased-implem where
open import Function
open import Data.Bits
open import Data.Nat.NP
open import Data.Vec
open import Relation.Binary
import Relation.Binary.PropositionalEquality as ≡
import Data.Fin as Fin
open ≡ using (_≗_; _≡_)
open Fin using (Fin; suc)
import flipbased
-- “↺ n A” reads like: “toss n ... | module flipbased-implem where
open import Function
open import Data.Bits
open import Data.Nat.NP
open import Data.Vec
open import Relation.Binary
import Relation.Binary.PropositionalEquality as ≡
import Data.Fin as Fin
open ≡ using (_≗_; _≡_)
open Fin using (Fin; suc)
import flipbased
-- “↺ n A” reads like: “toss n ... | Switch count↺ to be based on search | Switch count↺ to be based on search
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
b590f8a3ed001a65516e5f2211013e1a46683692 | ZK/PartialHeliosVerifier.agda | ZK/PartialHeliosVerifier.agda | {-# OPTIONS --without-K #-}
module ZK.PartialHeliosVerifier where
open import Type
open import Function hiding (case_of_)
open import Data.Bool.Base
open import Data.Product
open import Data.List.Base using (List; []; _∷_; and; foldr)
open import Data.String.Base using (String)
open import FFI.JS as JS hiding (_+_; ... | {-# OPTIONS --without-K #-}
module ZK.PartialHeliosVerifier where
open import Type
open import Function hiding (case_of_)
open import Data.Bool.Base
open import Data.Product
open import Data.List.Base using (List; []; _∷_; and; foldr)
open import Data.String.Base using (String)
open import FFI.JS as JS hiding (_+_; ... | Update binds | Update binds
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
24e0a0189105b8f3f2766a604a1ad5423b51b77e | Parametric/Change/Derive.agda | Parametric/Change/Derive.agda | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.Type as ChangeType
module Parametric.Change.Derive
{Base : Type.Structure}
(Const : Term.Structure Base)
(ΔBase : ChangeType.Structure Base)
where
open Type.Structure Base
open Term.Structure Base Const
... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Incrementalization as term-to-term transformation (Fig. 4g).
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
impo... | Document P.C.Derive. | Document P.C.Derive.
Old-commit-hash: 962425cf9bb190e1b8fb2c400bd9765180081dd0
| Agda | mit | inc-lc/ilc-agda |
8d4599155dc64db203782bdd39087df1a8014331 | Popl14/Change/Term.agda | Popl14/Change/Term.agda | module Popl14.Change.Term where
-- Terms Calculus Popl14
--
-- Contents
-- - Term constructors
-- - Weakening on terms
-- - `fit`: weaken a term to its ΔContext
-- - diff-term, apply-term and their syntactic sugars
open import Data.Integer
open import Popl14.Syntax.Type public
open import Popl14.Syntax.Term public
o... | module Popl14.Change.Term where
-- Terms Calculus Popl14
--
-- Contents
-- - Term constructors
-- - Weakening on terms
-- - `fit`: weaken a term to its ΔContext
-- - diff-term, apply-term and their syntactic sugars
open import Data.Integer
open import Popl14.Syntax.Type public
open import Popl14.Syntax.Term public
o... | Move (apply|diff)-base to the top of the module. | Move (apply|diff)-base to the top of the module.
This commit separates the POPL14-specific code from the
language-independent code in this module. The following commits will
remove the language-independent code.
Old-commit-hash: 245a7b618b2ac811d28d702089482e9aed8b8425
| Agda | mit | inc-lc/ilc-agda |
c68a9b8870e9eaca8c1a746f2ec67e2c84d97fd5 | Crypto/JS/BigI/CyclicGroup.agda | Crypto/JS/BigI/CyclicGroup.agda | {-# OPTIONS --without-K #-}
open import Type.Eq
open import FFI.JS using (JS[_]; return; Bool; _++_; _>>_)
open import FFI.JS.Check using (check!)
open import FFI.JS.BigI
open import Data.List.Base using (List; foldr)
open import Data.Two hiding (_==_)
open import Relation.Binary.PropositionalEquality
open import Alge... | {-# OPTIONS --without-K #-}
open import Type.Eq
open import FFI.JS using (JS[_]; return; _++_; _>>_)
open import FFI.JS.Check using (check!)
open import FFI.JS.BigI
open import Data.List.Base using (List; foldr)
open import Data.Two hiding (_==_)
open import Relation.Binary.PropositionalEquality
open import Algebra.Ra... | remove useless import | CyclicGroup: remove useless import
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
3a1143b9db99b9ec7e1431f08aab91f27cf9bd7a | Postulate/Extensionality.agda | Postulate/Extensionality.agda | module Postulate.Extensionality where
-- POSTULATE EXTENSIONALITY
--
-- Justification on Agda mailing list:
-- http://permalink.gmane.org/gmane.comp.lang.agda/2343
open import Relation.Binary.PropositionalEquality
postulate ext : ∀ {a b} → Extensionality a b
-- Convenience of using extensionality 3 times in a row
-... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Postulate extensionality of functions.
--
-- Justification on Agda mailing list:
-- http://permalink.gmane.org/gmane.comp.lang.agda/2343
------------------------------------------------------------------------
modu... | Document Postulate.Extensionality regularly. | Document Postulate.Extensionality regularly.
Old-commit-hash: 35222e92088dbd2313ec7252e50cd68e85b340bf
| Agda | mit | inc-lc/ilc-agda |
e7d0ffc6976dc3270e58e80326cf78dc7e9dcb2e | flat-funs.agda | flat-funs.agda | module flat-funs where
open import Data.Nat
import Level as L
open import composable
open import vcomp
record FlatFuns {t} (T : Set t) : Set (L.suc t) where
constructor mk
field
`⊤ : T
`Bit : T
_`×_ : T → T → T
_`^_ : T → ℕ → T
_`→_ : T → T → Set
`Vec : T → ℕ → T
`Vec A n = A `^ n
... | module flat-funs where
open import Data.Nat
open import Data.Bits using (Bits)
import Level as L
import Function as F
open import composable
open import vcomp
open import universe
record FlatFuns {t} (T : Set t) : Set (L.suc t) where
constructor mk
field
universe : Universe T
_`→_ : T → T → Set
infix... | put the type interface in the universe module | flat-funs: put the type interface in the universe module
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
785dddce82b3dc294f8d52a3a8a96b64366b1ac4 | 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 | Remove more
No Structure in Base.
Old-commit-hash: 81cee315c1ade9b842f0400fbc2bd215a189e8dc
| Agda | mit | inc-lc/ilc-agda |
2aa331ecc397f402c621e7b4b53886eb5ca53e91 | 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 HOAS-enabled helpers for nested abstractions. | Use HOAS-enabled helpers for nested abstractions.
Old-commit-hash: f5006b448dcc30a8ff103cf5de501e945e14faa1
| Agda | mit | inc-lc/ilc-agda |
24ce7b62d29582982f0f0c2694ebd10a473113aa | Game/IND-CCA2.agda | Game/IND-CCA2.agda |
{-# OPTIONS --without-K #-}
open import Type
open import Data.Bit
open import Data.Maybe
open import Data.Product
open import Data.Unit
open import Data.Nat.NP
open import Rat
open import Explore.Type
open import Explore.Explorable
open import Explore.Product
open Operators
open import Relation.Binary.Propositional... |
{-# OPTIONS --without-K #-}
open import Type
open import Data.Bit
open import Data.Maybe
open import Data.Product
open import Data.Unit
open import Data.Nat.NP
--open import Rat
open import Explore.Type
open import Explore.Explorable
open import Explore.Product
open Operators
open import Relation.Binary.Proposition... | Hide the Rat code | IND-CCA2: Hide the Rat code
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
16f8a95227efdacdb93599ca7b8ddfd847c2e47a | Parametric/Denotation/Value.agda | Parametric/Denotation/Value.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Value domains for languages described in Plotkin style
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
module Parametric.Denotation.Value
(Base : ... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Values for standard evaluation (Def. 3.1 and 3.2, Fig. 4c and 4f).
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
module Parametric.Denotation.Value
... | Document P.D.Value. | Document P.D.Value.
Old-commit-hash: bfaab88fbd6365ff0b9046dd999ccd1362c526d6
| Agda | mit | inc-lc/ilc-agda |
a2f7958b6a6e7245442d1e150092aacdc7c8707d | examples/Propositional.agda | examples/Propositional.agda | module Propositional where
open import Data.Nat
open import Relation.Binary.PropositionalEquality
open import Holes.Term using (⌞_⌟)
open import Holes.Cong.Propositional
open ≡-Reasoning
--------------------------------------------------------------------------------
-- Some easy lemmas
---------------------------... | module Propositional where
open import Data.Nat
open import Relation.Binary.PropositionalEquality
open import Holes.Term using (⌞_⌟)
open import Holes.Cong.Propositional
open ≡-Reasoning
--------------------------------------------------------------------------------
-- Some easy lemmas
---------------------------... | Add a hole in the examples that's strictly unnecessary | Add a hole in the examples that's strictly unnecessary
... but potentially confusing if it isn't there
| Agda | mit | bch29/agda-holes |
48d1be2bb4bb61634b15fbd0cff064c02be1f4f9 | 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... | Comment on handling of contexts | Comment on handling of contexts
Old-commit-hash: 0bfc0dfdc024921016f8df0d8252aa20f5f0f8d6
| Agda | mit | inc-lc/ilc-agda |
7ec8bed818d248b395b4b0b2c2d2f21361f940bc | Thesis/LangOps.agda | Thesis/LangOps.agda | module Thesis.LangOps where
open import Thesis.Lang
open import Thesis.Changes
open import Thesis.LangChanges
open import Relation.Binary.PropositionalEquality
open import Postulate.Extensionality
oplusτo : ∀ {Γ} τ → Term Γ (τ ⇒ Δt τ ⇒ τ)
ominusτo : ∀ {Γ} τ → Term Γ (τ ⇒ τ ⇒ Δt τ)
onilτo : ∀ {Γ} τ → Term Γ (τ ⇒ Δt τ... | module Thesis.LangOps where
open import Thesis.Lang
open import Thesis.Changes
open import Thesis.LangChanges
open import Relation.Binary.PropositionalEquality
open import Postulate.Extensionality
oplusτo : ∀ {Γ} τ → Term Γ (τ ⇒ Δt τ ⇒ τ)
ominusτo : ∀ {Γ} τ → Term Γ (τ ⇒ τ ⇒ Δt τ)
onilτo : ∀ {Γ} τ → Term Γ (τ ⇒ Δt τ... | Add lemmas I present in thesis | Add lemmas I present in thesis
| Agda | mit | inc-lc/ilc-agda |
965133f11d3863769cb8e636eff326a49bc7321b | 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... | rename 𝔾 as ℤ[ p ]★ | CyclicGroup: rename 𝔾 as ℤ[ p ]★
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
da7ed128a0220380c3109913af5f58760ad241d3 | Base/Denotation/Notation.agda | Base/Denotation/Notation.agda | module Base.Denotation.Notation where
-- OVERLOADING ⟦_⟧ NOTATION
--
-- This module defines a general mechanism for overloading the
-- ⟦_⟧ notation, using Agda’s instance arguments.
open import Level
record Meaning (Syntax : Set) {ℓ : Level} : Set (suc ℓ) where
constructor
meaning
field
{Semantics} : Set... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Overloading ⟦_⟧ notation
--
-- This module defines a general mechanism for overloading the
-- ⟦_⟧ notation, using Agda’s instance arguments.
------------------------------------------------------------------------
... | Improve commentary in Base.Denotation.Notation. | Improve commentary in Base.Denotation.Notation.
Old-commit-hash: f51d5958c73259a9120fc8a2ad20854bb12f8870
| Agda | mit | inc-lc/ilc-agda |
66a643a5678be6f131477803e19ed0cb52159556 | agda/Equality.agda | agda/Equality.agda | -- This is an implementation of the equality type for Sets. Agda's
-- standard equality is more powerful. The main idea here is to
-- illustrate the equality type.
module Equality where
open import Level
-- The equality of two elements of type A. The type a ≡ b is a family
-- of types which captures the statement of e... | -- This is an implementation of the equality type for Sets. Agda's
-- standard equality is more powerful. The main idea here is to
-- illustrate the equality type.
module Equality where
open import Level
-- The equality of two elements of type A. The type a ≡ b is a family
-- of types which captures the statement of e... | use the standard terminology refl. | use the standard terminology refl.
| Agda | unlicense | piyush-kurur/sample-code |
5303d7901af55944be2ec4695ee17bbd01624291 | Theorem/CongApp.agda | Theorem/CongApp.agda | module Theorem.CongApp where
-- Theorem CongApp.
-- If f ≡ g and x ≡ y, then (f x) ≡ (g y).
open import Relation.Binary.PropositionalEquality public
infixl 0 _⟨$⟩_
_⟨$⟩_ : ∀ {a b} {A : Set a} {B : Set b}
{f g : A → B} {x y : A} →
f ≡ g → x ≡ y → f x ≡ g y
_⟨$⟩_ = cong₂ (λ x y → x y)
| ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Congruence of application.
--
-- If f ≡ g and x ≡ y, then (f x) ≡ (g y).
------------------------------------------------------------------------
module Theorem.CongApp where
open import Relation.Binary.Propositio... | Document Theorem.CongApp regularly. | Document Theorem.CongApp regularly.
Old-commit-hash: f16f3e3d0b8e59230bd86a0c223af263a8db75e8
| Agda | mit | inc-lc/ilc-agda |
b87eb75ad51669de831d389ef1a78b415b31a18d | lib/Data/Nat/Distance.agda | lib/Data/Nat/Distance.agda | open import Data.Nat.NP
open import Data.Nat.Properties as Props
open import Data.Product
open import Relation.Binary.PropositionalEquality.NP
module Data.Nat.Distance where
dist : ℕ → ℕ → ℕ
dist zero y = y
dist x zero = x
dist (suc x) (suc y) = dist x y
dist-refl : ∀ x → dist x x ≡ 0
dist-refl zer... | open import Function.NP
open import Data.Nat.NP
open import Data.Nat.Properties as Props
open import Data.Nat.Properties.Simple
open import Data.Product.NP
open import Relation.Binary.PropositionalEquality.NP
open import Relation.Binary
open import Relation.Nullary
module Data.Nat.Distance where
{-
dist : ℕ → ℕ → ℕ
d... | add the `symIter` from Conor and some lemmas | Dist: add the `symIter` from Conor and some lemmas
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
1dd4fe7a8a920498ea83e46ad2707edca7f6f4bf | 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 → Type B) to (Δtype : Ty... | module Syntax.Type.Plotkin where
-- Types for language description à la Plotkin (LCF as PL)
--
-- Given base types, we build function types.
open import Function
infixr 5 _⇒_
data Type (B : Set {- of base types -}) : Set where
base : (ι : B) → Type B
_⇒_ : (σ : Type B) → (τ : Type B) → Type B
-- Lift (Δ : B → ... | move import to top of file in Syntax.Type.Plotkin | Agda: move import to top of file in Syntax.Type.Plotkin
Old-commit-hash: 0d789d2318a5215ac4ba2f68286e7db5826593ec
| Agda | mit | inc-lc/ilc-agda |
fa1e5e6ba14f3f7038a0a46052c8f81d12ed2e9d | Base/Change/Equivalence/Base.agda | Base/Change/Equivalence/Base.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Delta-observational equivalence - base definitions
------------------------------------------------------------------------
module Base.Change.Equivalence.Base where
open import Relation.Binary.PropositionalEqualit... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Delta-observational equivalence - base definitions
------------------------------------------------------------------------
module Base.Change.Equivalence.Base where
open import Relation.Binary.PropositionalEqualit... | Clarify Agda comment | Clarify Agda comment
Old-commit-hash: e00f9f0bb80cb86372669d674900a9abd43b7ef4
| Agda | mit | inc-lc/ilc-agda |
e2d49c81f464ab9449818f964e0078660f4315da | Syntactic/Contexts.agda | Syntactic/Contexts.agda | module Syntactic.Contexts
(Type : Set)
where
-- 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 reused for different calculi.
open import Relation.Binary
open... | module Syntactic.Contexts
(Type : Set)
where
-- 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 reused for different calculi.
open import Relation.Binary
open... | add lemma about syntactic contexts | Agda: add lemma about syntactic contexts
Old-commit-hash: 3613bba9a32778eaaa8f9d22419c23a8505be346
| Agda | mit | inc-lc/ilc-agda |
0ecf1536814a880e8cdbe60b6eef1ff1106504bf | 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
... | make main theorem correspond to the one stated in the paper | make main theorem correspond to the one stated in the paper
Old-commit-hash: 84979b2067c54a685110f1bad744ba106a962a0f
| Agda | mit | inc-lc/ilc-agda |
272abae5605c8fd8c5385376ffe4f4d4c26d2a9d | 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 and use a congruence lemma | Add and use a congruence lemma
To reduce explicit wrapping/unwrapping of proofs of ≙.
Old-commit-hash: 2bc64b5b9f3b074a70918e11f66512232fb6796b
| Agda | mit | inc-lc/ilc-agda |
57dd579828aa8a7c7ff8b0546dd51520584eb18e | 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... | add extended comment on semantics of Δ | agda: add extended comment on semantics of Δ
During my walk-throughs on the code, explaining this line was a bit
hard and required a small example. After writing it here during the
walkthrough, I decided to extend it and save it.
Old-commit-hash: 279b6047512b8c934cae49bda5977fa104077e12
| Agda | mit | inc-lc/ilc-agda |
beadc4c6bf5a0654b270878f150131cb18ada078 | 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)
open import Data.Unit using (⊤)
open import Data.Sum
open import Function
open import Relation.Binary.NP
open import Relation.Binary.Logical
open import Relation.Nullary
open import ... | {-# 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... | add ring modules Xor°, Bool° | Data.Bool.NP: add ring modules Xor°, Bool°
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
09aa7263bcfccc0537afdaba6875c6d31a8fa0e1 | lib/Algebra/Group.agda | lib/Algebra/Group.agda | {-# OPTIONS --without-K #-}
-- TODO
-- If you are looking for a proof of:
-- f (Σ(xᵢ∈A) g(x₁)) ≡ Π(xᵢ∈A) (f(g(xᵢ)))
-- Have a look to:
-- https://github.com/crypto-agda/explore/blob/master/lib/Explore/GroupHomomorphism.agda
open import Type using (Type_)
open import Data.Product.NP using (_,_)
import Alge... | {-# OPTIONS --without-K #-}
-- TODO
-- If you are looking for a proof of:
-- f (Σ(xᵢ∈A) g(x₁)) ≡ Π(xᵢ∈A) (f(g(xᵢ)))
-- Have a look to:
-- https://github.com/crypto-agda/explore/blob/master/lib/Explore/GroupHomomorphism.agda
open import Type using (Type_)
open import Data.Product.NP using (_,_;fst;snd)
imp... | update Group to include left and right inverse | update Group to include left and right inverse
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
bd4721cbfeecd02bd82f2eb2bb19570e836dac3a | 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.Denotation.Value
open import Popl14.Change.Deri... | 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.Denotation.Value
open import Popl14.Change.Deri... | Change argument order of carry-over. | Change argument order of carry-over.
This commit prepares for uncurrying cary-over.
Old-commit-hash: e1a21bdcbe7ee2b217917bd6ac9dfc576487102a
| Agda | mit | inc-lc/ilc-agda |
9028d1ebd71caa01d4b8a57cbb884b32e787ebe1 | 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:
-- ... | Revert "agda/...: misc (to revert)" | Revert "agda/...: misc (to revert)"
This reverts commit ae3a9db6fb87ddc01573ae236f8850b322bec8db.
Old-commit-hash: fa2ae9742c4282275b8f242a197b35ef1acf5932
| Agda | mit | inc-lc/ilc-agda |
2e98871b50826699f6f16a2718f8f2361a559c4d | Thesis/ANormalUntyped.agda | Thesis/ANormalUntyped.agda | module Thesis.ANormalUntyped where
open import Data.Nat.Base
open import Data.Integer.Base
open import Relation.Binary.PropositionalEquality
{- Typed deBruijn indexes for untyped languages. -}
-- Using a record gives an eta rule saying that all types are equal.
record Type : Set where
constructor Uni
open import ... | module Thesis.ANormalUntyped where
open import Data.Empty
open import Data.Product
open import Data.Nat.Base
import Data.Integer.Base as I
open I using (ℤ)
open import Data.Integer.Base using (ℤ)
open import Relation.Binary.PropositionalEquality
{- Typed deBruijn indexes for untyped languages. -}
-- Using a record g... | Write down real step-indexed logical relation for untyped terms | Write down real step-indexed logical relation for untyped terms
Sadly, Agda does not recognize this is terminating, because recursing on k with
k < n is not a structurally recursive call on a subterm. SAD!
| Agda | mit | inc-lc/ilc-agda |
7849a93dd727b32c2606d958173b08212260367d | Game/Transformation/ReceiptFreeness-CCA2d/Valid.agda | Game/Transformation/ReceiptFreeness-CCA2d/Valid.agda | {-# OPTIONS --copatterns #-}
open import Type
open import Function
open import Data.One
open import Data.Two
open import Data.Maybe
open import Data.Product
open import Data.Nat
open import Data.Vec hiding (_>>=_ ; _∈_)
open import Data.List as L
open import Data.Fin as Fin using (Fin)
open import Relation.Binary.Propo... | {-# OPTIONS --copatterns #-}
open import Type
open import Function
open import Data.One
open import Data.Two
open import Data.Maybe
open import Data.Product
open import Data.Nat
open import Data.Vec hiding (_>>=_ ; _∈_)
open import Data.List as L
open import Data.Fin as Fin using (Fin)
open import Relation.Binary.Propo... | update the validity for the simulator | update the validity for the simulator
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
41898751fdcc62758217e161ad60e93a20db6f51 | lib/Algebra/Monoid.agda | lib/Algebra/Monoid.agda | open import Function.NP
open import Data.Product.NP
open import Data.Nat
using (ℕ; fold; zero)
renaming (_+_ to _+ℕ_; _*_ to _*ℕ_; suc to 1+_)
open import Data.Integer
using (ℤ; +_; -[1+_]; _⊖_)
renaming (_+_ to _+ℤ_; _*_ to _*ℤ_)
open import Relation.Binary.PropositionalEquality.NP renaming (_∙_ to _♦_)
... | open import Function.NP
open import Data.Product.NP
open import Data.Nat
using (ℕ; zero)
renaming (_+_ to _+ℕ_; _*_ to _*ℕ_; suc to 1+_)
open import Data.Integer
using (ℤ; +_; -[1+_]; _⊖_)
renaming (_+_ to _+ℤ_; _*_ to _*ℤ_)
open import Relation.Binary.PropositionalEquality.NP renaming (_∙_ to _♦_)
open i... | use nest and not fold | Monoid: use nest and not fold
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
7826abee6b67c7b55aa70968ca7fd6b637d30857 | 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 and subcontexts,
-- together with variables and properties of these notions.
--
-- This module is parametric in the syntax of types, so it
-- c... | Drop Prefixes | Drop Prefixes
| Agda | mit | inc-lc/ilc-agda |
d4d74883fdfb5330e27bb48434b046f8291b5f3d | Denotation/Change/Popl14.agda | Denotation/Change/Popl14.agda | module Denotation.Change.Popl14 where
-- Changes for Calculus Popl14
--
-- Contents
-- - Mutually recursive concepts: ΔVal, validity.
-- Under module Syntax, the corresponding concepts of
-- ΔType and ΔContext reside in separate files.
-- Now they have to be together due to mutual recursiveness.
-- - `diff... | module Denotation.Change.Popl14 where
-- Changes for Calculus Popl14
--
-- Contents
-- - Mutually recursive concepts: ΔVal, validity.
-- Under module Syntax, the corresponding concepts of
-- ΔType and ΔContext reside in separate files.
-- Now they have to be together due to mutual recursiveness.
-- - `diff... | Improve documentation of ΔVal. | Improve documentation of ΔVal.
Old-commit-hash: fb71a0ea6af97c62b01a9d8b7d3089e5cd3139ed
| Agda | mit | inc-lc/ilc-agda |
a0c0e331a5839a6f7cd2921fe50b2acfdf977244 | 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* ... | Resolve implicit arguments. | Resolve implicit arguments.
When I filled the last hole in total.agda in the previous commit,
Agda told me to 'resolve implicit argument', so I added explicit
implicit arguments until Agda was satisfied. I don't know whether
or why it matters to do this.
Old-commit-hash: ed138bd06659ab2caac47a670b7d3d60c4d97f3a
| Agda | mit | inc-lc/ilc-agda |
db5307718bfbf262aa80ac0a0dd4b8da3799363b | Denotational/WeakValidChanges.agda | Denotational/WeakValidChanges.agda | module Denotational.WeakValidChanges where
open import Data.Product
open import Data.Unit
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
open import Syntactic.Types
open import Syntactic.ChangeTypes.ChangesAreDerivatives
open import Denotational.Notation
open import Denotational.Value... | module Denotational.WeakValidChanges where
open import Data.Product
open import Data.Unit
open import Relation.Nullary
open import Relation.Binary.PropositionalEquality
open import Syntactic.Types
open import Syntactic.ChangeTypes.ChangesAreDerivatives
open import Denotational.Notation
open import Denotational.Value... | Change where-clause to let-expr so that agda 2.3.2 typechecks README | Change where-clause to let-expr so that agda 2.3.2 typechecks README
Old-commit-hash: 6ffa74c100a7ee9d51e15d960db14c801f06e27c
| Agda | mit | inc-lc/ilc-agda |
cad090cf1face3e9ee7c8e4575440a427c74e66a | lib/Explore/BinTree.agda | lib/Explore/BinTree.agda | {-# OPTIONS --without-K #-}
module Explore.BinTree where
open import Data.Tree.Binary
open import Explore.Core
open import Explore.Properties
fromBinTree : ∀ {m} {A} → BinTree A → Explore m A
fromBinTree empty = empty-explore
fromBinTree (leaf x) = point-explore x
fromBinTree (fork ℓ r) = merge-explore (fromB... | {-# OPTIONS --without-K #-}
module Explore.BinTree where
open import Level.NP
open import Type hiding (★)
open import Data.Tree.Binary
open import Data.Zero
open import Data.Product
open import Relation.Binary.PropositionalEquality.NP
open import HoTT
open Equivalences
open import Type.Identities
open import Function... | Add more exploration functions about binary trees | Add more exploration functions about binary trees
| Agda | bsd-3-clause | crypto-agda/explore |
15cd0eafd613a991286818c276496c93db0ada5d | 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... | Drop ⟦_⟧*TypeHidCacheWrong | Drop ⟦_⟧*TypeHidCacheWrong
This wrong definition should not be counted among the failures before
CBPV, since it was created after and it is due to a separate limitation.
| Agda | mit | inc-lc/ilc-agda |
e7b75259e34cf9de11a2696f75d1384a4dc62f8d | agda/Nat.agda | agda/Nat.agda | module Nat where
data ℕ : Set where
zero : ℕ
succ : ℕ → ℕ
_+_ : ℕ → ℕ → ℕ
zero + b = b
succ a + b = succ (a + b)
_×_ : ℕ → ℕ → ℕ
zero × b = zero
succ a × b = (a × b) + b
open import Relation.Binary.PropositionalEquality
0-is-right-identity-of-+ : ∀ (n : ℕ) → n + zero ≡ n
0-is-right-identity-of-+ zero ... | module Nat where
data ℕ : Set where
zero : ℕ
succ : ℕ → ℕ
{-# BUILTIN NATURAL ℕ #-}
{-# BUILTIN ZERO zero #-}
{-# BUILTIN SUC succ #-}
_+_ : ℕ → ℕ → ℕ
zero + b = b
succ a + b = succ (a + b)
_×_ : ℕ → ℕ → ℕ
zero × b = zero
succ a × b = (a × b) + b
open import Relation.Binary.PropositionalEquality
0-is-ri... | allow the use of more natural notation in Nat | allow the use of more natural notation in Nat
| Agda | unlicense | piyush-kurur/sample-code |
8e1932027422fbfd5254b377ea26f80df138163c | Parametric/Change/Term.agda | Parametric/Change/Term.agda | import Parametric.Syntax.Type as Type
import Base.Syntax.Context as Context
module Parametric.Change.Term
{Base : Set}
(Constant : Context.Context (Type.Type Base) → Type.Type Base → Set {- of constants -})
where
-- Terms that operate on changes
open Type Base
open Context Type
open import Parametric.Chan... | import Parametric.Syntax.Type as Type
import Base.Syntax.Context as Context
module Parametric.Change.Term
{Base : Set}
(Constant : Context.Context (Type.Type Base) → Type.Type Base → Set {- of constants -})
{Δbase : Base → Type.Type Base}
where
-- Terms that operate on changes
open Type Base
open Conte... | Move parameter to module level. | Move parameter to module level.
All definitions in this module take the same parameter, so moving that
parameter to the module level makes it easier to instantiate all of the
definitions at once.
Old-commit-hash: c9a73b24cd02aed1ee75b46416c1893c8c37b130
| Agda | mit | inc-lc/ilc-agda |
bdfd1c903bebb00f241b98797e6544d8970bea49 | Crypto/JS/BigI/FiniteField.agda | Crypto/JS/BigI/FiniteField.agda | {-# OPTIONS --without-K #-}
open import Type.Eq using (_==_; Eq?; ≡⇒==; ==⇒≡)
open import Data.Two.Base using (𝟚; ✓)
open import Relation.Binary.PropositionalEquality.Base using (_≡_; refl; ap)
open import FFI.JS using (JS[_]; _++_; return; _>>_)
open import FFI.JS.Check
using (check!)
renaming (check to c... | {-# OPTIONS --without-K #-}
open import Type.Eq using (_==_; Eq?; ≡⇒==; ==⇒≡)
open import Data.Two.Base using (𝟚; ✓)
open import Relation.Binary.PropositionalEquality.Base using (_≡_; refl; ap)
open import FFI.JS using (JS[_]; _++_; return; _>>_)
open import FFI.JS.Check
using (check!)
--renaming (check to c... | Use warn-check since check is monadic now... | ℤq: Use warn-check since check is monadic now...
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
3be2477097d1bfe6056a5d1fbcef0fb70636e4dc | lib/Relation/Binary/PropositionalEquality/NP.agda | lib/Relation/Binary/PropositionalEquality/NP.agda | {-# OPTIONS --universe-polymorphism #-}
-- move this to propeq
module Relation.Binary.PropositionalEquality.NP where
open import Relation.Binary.PropositionalEquality public hiding (module ≡-Reasoning)
open import Relation.Binary.NP
open import Relation.Binary.Bijection
open import Relation.Binary.Logical
open import ... | {-# OPTIONS --universe-polymorphism #-}
-- move this to propeq
module Relation.Binary.PropositionalEquality.NP where
open import Relation.Binary.PropositionalEquality public hiding (module ≡-Reasoning)
open import Relation.Binary.NP
open import Relation.Binary.Bijection
open import Relation.Binary.Logical
open import ... | add ≗₂ | add ≗₂
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
89da077b4d098d6e0939d860c48061f66c5d3369 | 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 elimBool to operational semantics. | Add elimBool to operational semantics.
| Agda | bsd-3-clause | spire/spire |
d28029e6a6b72c675115285102a2d423b1c0b3f9 | prg.agda | prg.agda | module prg where
open import fun-universe
open import Function
open import Data.Nat.NP hiding (_==_)
open import Data.Bool.NP hiding (_==_)
open import Data.Nat.Properties
open import Data.Bool.Properties
open import Data.Bits
open import Data.Fin using (Fin; zero; suc)
open import Data.Product
open import Data.Empty... | module prg where
open import fun-universe
open import Function
open import Data.Nat.NP hiding (_==_)
open import Data.Bool.NP hiding (_==_)
open import Data.Nat.Properties
open import Data.Bool.Properties
open import Data.Bits
open import Data.Fin using (Fin; zero; suc)
open import Data.Product
open import Data.Empty... | fix argument order | prg: fix argument order
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
f274de0be6b9f871bb446ee6381969cac1a7ad8a | 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... | Fix order of returned caches | Fix order of returned caches
| Agda | mit | inc-lc/ilc-agda |
a127cbe0afe5735ec22de57b718586c54a38c33b | arrow.agda | arrow.agda | 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... | 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... | Fix testd | Fix testd
| Agda | mit | louisswarren/hieretikz |
3682d42d35e0734a6a4d6a4ee62cbad3965309b9 | Parametric/Change/Term.agda | Parametric/Change/Term.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Terms that operate on changes (Fig. 3).
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Terms that operate on changes (Fig. 3).
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Change.... | Make _⊕_ more coherent with _⊝_ | Make _⊕_ more coherent with _⊝_
| Agda | mit | inc-lc/ilc-agda |
5cd94161fed3259ba24dc7c2099fc439a5fdadb1 | New/Derive.agda | New/Derive.agda | module New.Derive where
open import New.Lang
open import New.Changes
open import New.LangOps
ΔΓ : Context → Context
ΔΓ ∅ = ∅
ΔΓ (τ • Γ) = Δt τ • τ • ΔΓ Γ
Γ≼ΔΓ : ∀ {Γ} → Γ ≼ ΔΓ Γ
Γ≼ΔΓ {∅} = ∅
Γ≼ΔΓ {τ • Γ} = drop Δt τ • keep τ • Γ≼ΔΓ
deriveConst : ∀ {τ} →
Const τ →
Term ∅ (Δt τ)
-- dplus = λ m dm n dn → (m + dm) +... | module New.Derive where
open import New.Lang
open import New.Changes
open import New.LangOps
deriveConst : ∀ {τ} →
Const τ →
Term ∅ (Δt τ)
-- dplus = λ m dm n dn → (m + dm) + (n + dn) - (m + n) = dm + dn
deriveConst plus = abs (abs (abs (abs (app₂ (const plus) (var (that (that this))) (var this)))))
-- minus = λ m... | Reorder definitions | Reorder definitions
Move definitions about change contexts next to their uses.
| Agda | mit | inc-lc/ilc-agda |
42316d32e1b90cea16ece1ad29627cb678610bc6 | 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... | Clarify that change algebra operations trivially preserve d.o.e. | Clarify that change algebra operations trivially preserve d.o.e.
Old-commit-hash: c11fb0c1abae938f0c7ec3dacff96f112f6bbee4
| Agda | mit | inc-lc/ilc-agda |
b3c29af8a0e31056b3efe8dd76723fe0d834058a | 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)
open import Relation.Binary.N... | Add Pullback | Add Pullback
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
e58fdcf2bd3f99745f653c3ee049cb1244bcb092 | lib/Relation/Binary/NP.agda | lib/Relation/Binary/NP.agda | {-# OPTIONS --without-K #-}
{-# 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 : ... | {-# OPTIONS --without-K #-}
{-# 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 : ... | Rename by-definition combinator for eq-reasoning | Rename by-definition combinator for eq-reasoning
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
a0cb2129d6925e76e7c69250fbe510b3a711b245 | Parametric/Denotation/Evaluation.agda | Parametric/Denotation/Evaluation.agda | ------------------------------------------------------------------------
-- 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... | ------------------------------------------------------------------------
-- 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... | Correct code in comment | Correct code in comment
map-IVT does not exist currently (not sure it ever did, I did not
investigate); what we want and does not work is simply map. Hence, fix
the comment to clarify it.
| Agda | mit | inc-lc/ilc-agda |
caab0f0a9ebc53432d697d8dfef61fb6cae09b67 | 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... | Prepare for splitting | Equivalence: Prepare for splitting
The file has become too big.
Splitting the anonymous modules requires more work out of type inference
and introduces one type inference failure, which is fixed in this commmit.
Old-commit-hash: 32f42f80b60cd3dd45e879d7a367b4fe933bb9d8
| Agda | mit | inc-lc/ilc-agda |
26feb31d8f07b57839d5ad020a366816d0ae21fb | Parametric/Denotation/Evaluation.agda | Parametric/Denotation/Evaluation.agda | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Denotation.Value as Value
module Parametric.Denotation.Evaluation
{Base : Type.Structure}
(Const : Term.Structure Base)
(⟦_⟧Base : Value.Structure Base)
where
open Type.Structure Base
open Term.Structure Base C... | import Parametric.Syntax.Type as Type
import Parametric.Syntax.Term as Term
import Parametric.Denotation.Value as Value
module Parametric.Denotation.Evaluation
{Base : Type.Structure}
(Const : Term.Structure Base)
(⟦_⟧Base : Value.Structure Base)
where
open Type.Structure Base
open Term.Structure Base C... | insert missing space (cosmetic) | insert missing space (cosmetic)
Old-commit-hash: 4d559497f68fabe2674c6d523508f715c78256c8
| Agda | mit | inc-lc/ilc-agda |
321249014d14436b6f3f84e01fdeb73f0d5faf7b | crypto-agda.agda | crypto-agda.agda | module crypto-agda where
import Cipher.ElGamal.Generic
import Composition.Forkable
import Composition.Horizontal
import Composition.Vertical
import Crypto.Schemes
--import FiniteField.FinImplem
import FunUniverse.Agda
import FunUniverse.BinTree
import FunUniverse.Bits
import FunUniverse.Category
import FunUniverse.Cate... | module crypto-agda where
import Attack.Compression
import Attack.Reencryption
import Attack.Reencryption.OneBitMessage
import Cipher.ElGamal.Generic
import Cipher.ElGamal.Homomorphic
import Composition.Forkable
import Composition.Horizontal
import Composition.Vertical
import Crypto.Schemes
import FiniteField.FinImplem
... | update crypto-agda.agda | update crypto-agda.agda
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
bc0f697e345522fad65844eed07cba984158e3b7 | 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... | Comment out bug-triggering code | Parametric.Change.Validity: Comment out bug-triggering code
This code is exported and used elsewhere :-(
| Agda | mit | inc-lc/ilc-agda |
ac25a046e34905a5fd630275f7f19cf585a2f9ab | ZK/JSChecker.agda | ZK/JSChecker.agda | {-# OPTIONS --without-K #-}
module ZK.JSChecker where
open import Function using (id; _∘′_; case_of_)
open import Data.Bool.Base using (Bool; true; false; _∧_)
open import Data.List.Base using (List; []; _∷_; and; foldr)
open import Data.String.Base using (String)
open import FFI.JS
open import FFI.JS.Che... | {-# OPTIONS --without-K #-}
module ZK.JSChecker where
open import Function using (id; _∘′_; case_of_)
open import Data.Bool.Base using (Bool; true; false; _∧_)
open import Data.List.Base using (List; []; _∷_; and; foldr)
open import Data.String.Base using (String)
open import FFI.JS
open import FFI.JS.Che... | Remove no longer relevant TODO | Remove no longer relevant TODO
| Agda | bsd-3-clause | crypto-agda/crypto-agda |
a6dfe1f553ba79964ad12503ce1a9095fe79ffe2 | arrow.agda | arrow.agda | 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... | 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 test | Add test
| Agda | mit | louisswarren/hieretikz |
51432b971511d6e3b28904b1d33fc55d32888906 | lib/Function/Extensionality.agda | lib/Function/Extensionality.agda | {-# 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 :... | {-# 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 a version with implicit arguments | FunExt: add a version with implicit arguments
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
702fcd37b6983eaf128ea29fca185751c2444c69 | lib/Relation/Binary/Permutation.agda | lib/Relation/Binary/Permutation.agda | --TODO {-# OPTIONS --without-K #-}
module Relation.Binary.Permutation where
open import Level
open import Data.Product.NP
open import Data.Zero
open import Data.One
open import Data.Sum
open import Data.List
open import Relation.Nullary
open import Relation.Binary
import Relation.Binary.PropositionalEquality as ≡
open... | --TODO {-# OPTIONS --without-K #-}
module Relation.Binary.Permutation where
open import Level
open import Data.Product.NP
open import Data.Zero
open import Data.One
open import Data.Sum
open import Data.List
open import Relation.Nullary
open import Relation.Binary
import Relation.Binary.PropositionalEquality as ≡
open... | Fix in Relation.Binary.Permutation | Fix in Relation.Binary.Permutation
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
3822d110c060a75d914e9d0e4fc105f00e99980a | 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
... | fix bug in `union` by postulating conjunction | Atlas: fix bug in `union` by postulating conjunction
Old-commit-hash: 69ed9a83b2b162709e5dfcf541f9d0bf18c7e970
| Agda | mit | inc-lc/ilc-agda |
080a08a480530a0bfbe7ee42fb486407caea4a5e | Parametric/Change/Equivalence.agda | Parametric/Change/Equivalence.agda | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Delta-observational equivalence
------------------------------------------------------------------------
import Parametric.Syntax.Type as Type
import Parametric.Denotation.Value as Value
module Parametric.Change.Eq... | ------------------------------------------------------------------------
-- INCREMENTAL λ-CALCULUS
--
-- Delta-observational equivalence
------------------------------------------------------------------------
module Parametric.Change.Equivalence where
open import Base.Denotation.Notation public
open import Relation.... | Remove extra imports | Remove extra imports
Old-commit-hash: 3a9775f6afd97585f6b425390b5431b43807b03e
| Agda | mit | inc-lc/ilc-agda |
3409935502fb668aa913b86adee0b90b81efb211 | arrow.agda | arrow.agda | 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... | 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... | Use standard syntax | Use standard syntax
| Agda | mit | louisswarren/hieretikz |
20a1abbafdf38b144be117be78c688be2786fbee | 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 |
f7a0824e23aa553c512f0fbff1879941ee29f6d0 | lib/FFI/JS.agda | lib/FFI/JS.agda | module FFI.JS where
open import Data.Empty public renaming (⊥ to 𝟘)
open import Data.Unit.Base public renaming (⊤ to 𝟙)
open import Data.Char.Base public using (Char)
open import Data.String.Base public using (String)
open import Data.Bool.Base public using (Bool; true; false)
open import Data.List.Base ... | module FFI.JS where
open import Data.Empty public renaming (⊥ to 𝟘)
open import Data.Unit.Base public renaming (⊤ to 𝟙)
open import Data.Char.Base public using (Char)
open import Data.String.Base public using (String)
open import Data.Bool.Base public using (Bool; true; false)
open import Data.List.Base ... | add is-null | JS: add is-null
| Agda | bsd-3-clause | crypto-agda/agda-libjs |
7b2c31fcd7415cecc448653df3d386001cbebf1b | Syntax/Term/Plotkin.agda | Syntax/Term/Plotkin.agda | import Syntax.Type.Plotkin as Type
module Syntax.Term.Plotkin
{B : Set {- of base types -}}
{C : Type.Type B → Set {- of constants -}}
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Product
open Type B
open import Syntax.Context {Type}
data Term
... | import Syntax.Type.Plotkin as Type
module Syntax.Term.Plotkin
{B : Set {- of base types -}}
{C : Type.Type B → Set {- of constants -}}
where
-- Terms of languages described in Plotkin style
open import Function using (_∘_)
open import Data.Product
open Type B
open import Syntax.Context {Type}
data Term
... | Put constructor arguments on different lines. | Put constructor arguments on different lines.
Old-commit-hash: 02f9c59c59ddef7050c2c035457c98ecb00464dc
| Agda | mit | inc-lc/ilc-agda |
fbbd955ba2c82259764f220c075ee5ab09f0a3c1 | models/Desc.agda | models/Desc.agda | {-# OPTIONS --type-in-type
--no-termination-check
--no-positivity-check #-}
module Desc where
--********************************************
-- Prelude
--********************************************
-- Some preliminary stuffs, to avoid relying on the stdlib
--****************
-- Sigma and fr... | {-# OPTIONS --type-in-type #-}
module Desc where
--********************************************
-- Prelude
--********************************************
-- Some preliminary stuffs, to avoid relying on the stdlib
--****************
-- Sigma and friends
--****************
data Sigma (A : Set) (B : A -> Set) : Set ... | Update Desc model. Follow ICFP paper. With type-in-type, but termination-checker-friendly. | Update Desc model. Follow ICFP paper. With type-in-type, but termination-checker-friendly.
| Agda | mit | mietek/epigram2,larrytheliquid/pigit,mietek/epigram2 |
bb08669e1bdc2f7d2df9bb9289bda1b42f3dece8 | lib/Algebra/FunctionProperties/Eq.agda | lib/Algebra/FunctionProperties/Eq.agda | {-# OPTIONS --without-K #-}
-- Like Algebra.FunctionProperties but specialized to _≡_ and using implict arguments
-- Moreover there is some extensions such as:
-- * interchange
-- * non-zero inversions
-- * cancelation and non-zero cancelation
-- These properties can (for instance) be used to define algebraic
-- struc... | {-# OPTIONS --without-K #-}
-- Like Algebra.FunctionProperties but specialized to _≡_ and using implict arguments
-- Moreover there is some extensions such as:
-- * interchange
-- * non-zero inversions
-- * cancelation and non-zero cancelation
-- These properties can (for instance) be used to define algebraic
-- struc... | add Endo.Cycle | Alegbra.FunctionProperties.Eq: add Endo.Cycle
| Agda | bsd-3-clause | crypto-agda/agda-nplib |
675459709ff3563cde300754c35f229c6b963f10 | 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 ΔEnv-Entry to ValidChange. | Rename ΔEnv-Entry to ValidChange.
Also rename operations related to ΔEnv-Entry.
Old-commit-hash: 35ab981b89bab6eced9a7b20753bb140f6caf7a8
| Agda | mit | inc-lc/ilc-agda |
0e5b51a126b354cb6a2c34c080deb1fdcc75c7cb | Denotational/Environments.agda | Denotational/Environments.agda | module Denotational.Environments
(Type : Set)
(⟦_⟧Type : Type → Set)
where
-- ENVIRONMENTS
--
-- This module defines the meaning of contexts, that is,
-- the type of environments that fit a context, together
-- with operations and properties of these operations.
--
-- This module is parametric in the syntax ... | module Denotational.Environments
(Type : Set)
{ℓ}
(⟦_⟧Type : Type → Set ℓ)
where
-- ENVIRONMENTS
--
-- This module defines the meaning of contexts, that is,
-- the type of environments that fit a context, together
-- with operations and properties of these operations.
--
-- This module is parametric in t... | Generalize environments to values in higher universes. | Generalize environments to values in higher universes.
Old-commit-hash: 4ff4102742306da9be77151d785aa608f8558977
| Agda | mit | inc-lc/ilc-agda |
0ab0b0012d2db6e26ec2716c2d95f3743111df4d | Parametric/Syntax/MType.agda | Parametric/Syntax/MType.agda | import Parametric.Syntax.Type as Type
module Parametric.Syntax.MType where
module Structure (Base : Type.Structure) where
open Type.Structure Base
mutual
-- Derived from CBPV
data ValType : Set where
U : (c : CompType) → ValType
B : (ι : Base) → ValType
vUnit : ValType
_v×_ : (τ₁... | import Parametric.Syntax.Type as Type
module Parametric.Syntax.MType where
module Structure (Base : Type.Structure) where
open Type.Structure Base
mutual
-- Derived from CBPV
data ValType : Set where
U : (c : CompType) → ValType
B : (ι : Base) → ValType
vUnit : ValType
_v×_ : (τ₁... | Fix arity of _v×_ | MType: Fix arity of _v×_
| Agda | mit | inc-lc/ilc-agda |
dd73b5a36235448b400cd9d02d7983b1155617bc | 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... | Reorder definitions of Term and Terms. | Reorder definitions of Term and Terms.
The order of definitions should follow the order of declaration,
and this code seems easier to understand when one looks at Term
first.
Old-commit-hash: 517547b8eebe1b8803d9f30fa3945f02685b6cc5
| Agda | mit | inc-lc/ilc-agda |
8d03eb08a3d8dc237fc96cbdf430c73571ead581 | 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 new lemmas on change equivalence | Add new lemmas on change equivalence
| Agda | mit | inc-lc/ilc-agda |
ca0490d3e647551767333fe1b8af760d98b01dfa | Syntax/Term/Popl14.agda | Syntax/Term/Popl14.agda | module Syntax.Term.Popl14 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
data Term (Γ : Context) : Type -> Se... | module Syntax.Term.Popl14 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
data Term (Γ : Context) : Type -> Se... | use ⊕ and ⊝ also when defining diff-term and apply-term | agda: use ⊕ and ⊝ also when defining diff-term and apply-term
Goal: make diff-term and apply-term themselves more readable.
Old-commit-hash: fc206b02d6057172e7f49c02eb521abaaafcb1e8
| 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.