Skip to content

feat(quantum): add variable-width parallel queries and execution bridges - #1188

Open
alexanderlhicks wants to merge 4 commits into
mainfrom
feat/parallel-qrom-01-model
Open

alexanderlhicks wants to merge 4 commits into
mainfrom
feat/parallel-qrom-01-model

Conversation

@alexanderlhicks

@alexanderlhicks alexanderlhicks commented Nov 19, 2026 •

Copy link
Copy Markdown
Collaborator

Summary

Add adaptive parallel oracle rounds with variable widths and separate rounds, total-point and maximum-width budgets. Ordered batching runs arbitrary runtime steps in slot order; batch_oracleQuery identifies additive-oracle batching with simultaneous queries. The QROM samples one function for all slots and rounds.

QuantumRuntime.run_sequentialize preserves complete runs, and the point-budget certificate bounds flattened queries. qromBatchEvalDistMap_le_of_sequential_bound packages transport for sequential bounds over arbitrary local instruments, retaining observations of the same sampled function and final leaf. Additional gate-set or local-cost assumptions require their own transport. A batch round uses one base port. Several additive oracles can be encoded as one port on a sum input domain.

Classical algorithms with private uniform coins retain their lazy random-oracle law. Parallel compressed execution has the same output law as the parallel QROM, with one shared database. Search bounds follow in #1190.

Base: main.

Suggested review order: #1188 → #1190 → #1192 first; then #1191 → #1193; then #1194 → #1195 → #1196.

Validation

Validated head: a2061ed0a57b15269d6aaea5c5f35042be3fea8a. All nine hosted check types and every recorded run passed.

Review response and reproducible checks · Review dispositions

The reproduction commands for this slice are:

lake build VCVio VCVioTest.Quantum.Parallel VCVioTest.Quantum.Sequentialize VCVioTest.Quantum.ParallelBridges VCVioTest.Quantum.ClassicalRandomized
lake build
lake exe axiomsweep --check
lake lint

The hosted matrix also runs the default executable/CSV suite, initializer checks, import and
isolation guards, documentation checks and downstream builds. The default axiom sweep covers
production roots; a fresh whole-test-library axiom sweep is not implied. Historical contract
comparison can be reproduced from the published baseline and committed capture tools as
specified in the integration review-response page.

@github-actions

github-actions Bot commented Nov 19, 2026 •

Copy link
Copy Markdown

🤖 PR Summary

feat(quantum): add variable-width parallel queries and execution bridges

This PR introduces a comprehensive framework for variable-width parallel quantum oracle queries in VCVio, along with execution bridges that relate parallel, sequential, and classical randomized models. The core mathematical contributions are spread across several new files, with supporting definitions, theorems, and regression tests.

Mathematical Formalization

  • Parallel Oracle Model (VCVio/Quantum/Oracle/Parallel.lean): Defines the parallel (width-k) quantum random oracle model (QROM). Introduces the permutation parallelOracleEquiv (applying oracleEquiv H in every slot), the unitary matrix parallelOracleUnitary, and the SubInstrument parallelOracleQuery. Proves algebraic properties (parallelOracleEquiv_add, conjTranspose_parallelOracleUnitary, parallelOracleUnitary_mulVec_single) and the crucial batch_oracleQuery theorem showing that batching sequential single-slot oracle queries reproduces the parallel query's frame. Constructs parallelOracleRuntime as a batch of additiveOracleRuntime. Defines evaluation distributions qromBatchEvalDist, qromBatchEvalDist₂, etc., and proves they are uniform averages over all functions, confirming the QROM law.

  • Compressed Parallel Oracle (VCVio/Quantum/Oracle/Compressed/Parallel.lean): Establishes equivalence between the compressed and purified parallel runtimes. Proves they are intertwined by an isometry (intertwines_purifiedRuntime_compressedRuntime_step, intertwines_purifiedRuntime_compressedRuntime_batch_step), and that their joint post-states, reduced post-states, leaf traces, and outcome laws are identical (matrix_jointPost_compressedRuntime_batch, reducedPost_compressedRuntime_batch, outcomeLawWith_compressedRuntime_batch_eq_purifiedRuntime). Concludes that the compressed parallel runtime satisfies the parallel QROM outcome law (outcomeLaw_compressedRuntime_batch).

  • Classical Bridges (VCVio/Quantum/Oracle/ClassicalParallel.lean, VCVio/Quantum/Oracle/ClassicalRandomized.lean): ClassicalParallel.lean defines classicalBatchQuery and classicalBatchImpl for parallel classical-to-quantum compilation via toQuantumBatch. Core correctness theorems (run_toQuantumBatch, qromEvalDistMap_sequentialize_toQuantumBatch_eq_randomOracle) show the quantum embedding matches classical fixed-table and random-oracle distributions. Provides resource-bound transfer theorems (IsOnlineQueryBound.isTotalQueryBound_toQuantumBatch). ClassicalRandomized.lean defines classicalRandomizedImpl and toQuantumRandomized for embedding classical randomized algorithms with private coins into the sequential QROM. Proves qromEvalDist₂_toQuantumRandomized_eq_randomOracle, equating the sequential QROM distribution to the classical lazy random-oracle law.

Comp / Runtime Infrastructure

  • Runtime Batch Construction (VCVio/Quantum/Comp/Parallel.lean): Defines QuantumRuntime.batch, which orders a runtime's one-result endomorphism ports into batched slots sharing private memory. Provides theorems (batch_D, batch_init, intertwines_batch_step, evalDist_batch_eq_of_simulation) establishing that batching preserves the private register, initial state, losslessness, and simulation equivalences.

  • Syntactic Cost Metrics (VCVio/Quantum/Comp/RoundBound.lean): Introduces IsPointBound (total width consumed) and IsWidthBound (per-batch width cap). Defines Cmd.pointCharge and bridges these bounds: IsPointBound.isWidthBound and IsTotalQueryBound.isPointBound. Adds simp lemmas for QComp and QuantumComp₂ namespaces.

  • Sequentialization (VCVio/Quantum/Comp/Sequentialize.lean): Defines the core translation from the unstructured batch specification uBatchSpec P In to the single-slot instrument specification uSpec P In. Defines sequentializeSlots and sequentializeHandler. Proves a comprehensive suite of theorems: syntactic preservation (sequentialize_pure, sequentialize_primBind), cost preservation (IsPointBound.sequentialize, IsTotalQueryBound.sequentialize), losslessness preservation (Lossless.sequentialize), and the critical semantic equivalence theorem run_sequentialize establishing that running the sequentialized program yields exactly the same result as running the original batch program.

  • Foundations (VCVio/Quantum/Foundations/Parallel.lean): Introduces concepts for ordered operations on finite quantum register families: piSlotEquiv (basis permutation on one coordinate), Subsystem.pi/Subsystem.piWithMemory (coordinate selection), and SubInstrument.sequenceUnit (ordered instrument list application). Proves lossless_sequenceUnit, sequenceUnit_append, and intertwines_sequenceUnit. The batch operation applies a step instrument to each slot in order, with properties batch_zero, lossless_batch, and batch_relabel_frame.

Proof Completion (sorries removed)

  • No sorry or admit placeholders are added in any file. All theorems are fully proven.

Documentation

  • docs/design/quantum-layer.md: Significantly expanded to document the new parallel runtime infrastructure, the classical bridges, the compressed parallel bridge, and updated open obligations.
  • docs/quantum/guide/4-programs-and-runtimes.md: Adds sections on "Rounds, widths and points" and "Sequentializing batches", describing the new cost metrics and the run_sequentialize theorem.
  • docs/quantum/guide/5-qrom.md: Expanded to cover classical private coins, parallel oracle rounds, sequentialization equivalence, and parallel compressed execution.
  • docs/quantum/guide/README.md: Updates scope, coverage, and topic lists to reflect new features.
  • docs/quantum/reference/classical-quantum.md: Expands the classical-quantum reference table with three new correspondences for toQuantumRandomized and toQuantumBatch.
  • docs/quantum/reference/literature.md: Adds a row for parallelOracleUnitary, batch_oracleQuery, and qromBatchEvalDist.
  • VCVio/Quantum/Oracle/Classical.lean: Adds a "Private randomness" documentation section and the run_classicalQuery theorem.

Infrastructure / CI

  • New public imports (VCVio.lean): Adds imports for Parallel, RoundBound, Sequentialize, ClassicalParallel, ClassicalRandomized, and Foundations.Parallel modules.
  • New test imports (VCVioTest.lean): Adds imports for ClassicalRandomized, Parallel, ParallelBridges, and Sequentialize test modules.
  • Regression tests (VCVioTest/Quantum/...): ClassicalRandomized.lean (adaptive program with private coin, query bounds, lazy random oracle law), Parallel.lean (parallel oracle query properties, batch semantics, batch simulation), ParallelBridges.lean (classical and compressed semantics bridges, query/point bounds, adaptive widths), Sequentialize.lean (sequentialization budget preservation, zero-width calls, adaptive rounds, QROM interfaces).
  • Total query bound lemmas (VCVio/Quantum/Comp/TotalQueryBound.lean): Adds @[simp] theorems isTotalQueryBound_act_bind_iff and isTotalQueryBound_query_bind_iff for simplified cost reasoning.
  • Sequentialization bridge (VCVio/Quantum/Oracle/Sequentialize.lean): Proves qromEvalDist_sequentialize (sequentialization preserves averaged output law), qromEvalDistMap_sequentialize, QuantumComp.IsPointBound.qrom_sequentialize, and qromBatchEvalDistMap_le_of_sequential_bound (sequential QROM probability bound at Q queries transfers to a parallel program with Q total queried points).
  • README.md wording: Minor wording improvement in docs/quantum/README.md.

Refactoring

  • No refactoring changes beyond the normal addition of new files and imports.

Statistics

Metric Count
📝 Files Changed 24
✅ Lines Added 3603
❌ Lines Removed 39

Lean Declarations

✏️ Added: 275 declaration(s)

VCVio/Quantum/Comp/Parallel.lean (9)

  • def uBatchSpec (P : Type u) (In : P → QReg) : QuantumOracleSpec.{u, 0}
  • noncomputable def batch {P : Type u} {In : P → QReg}
  • private theorem intertwines_lift_piWithMemory {ι : Type} [Fintype ι] [DecidableEq ι]
  • private theorem intertwines_relabel_queryEquivIn_symm {A I E D D' : QReg}
  • theorem batch_D {P : Type u} {In : P → QReg} (R : QuantumRuntime (uSpec P In)) :
  • theorem batch_init {P : Type u} {In : P → QReg} (R : QuantumRuntime (uSpec P In)) :
  • theorem evalDist_batch_eq_of_simulation {P : Type u} {In : P → QReg}
  • theorem intertwines_batch_step {P : Type u} {In : P → QReg}
  • theorem lossless_batch_step {P : Type u} {In : P → QReg}

VCVio/Quantum/Comp/RoundBound.lean (21)

  • def Cmd.pointCharge : {A : QReg} → Cmd L (uBatchSpec P In) A → ℕ
  • def IsPointBound (x : QuantumComp L (uBatchSpec P In) X A) (n : ℕ) : Prop
  • def IsWidthBound (x : QuantumComp L (uBatchSpec P In) X A) (k : ℕ) : Prop
  • theorem IsPointBound.bind {x : QuantumComp L (uBatchSpec P In) X A}
  • theorem IsPointBound.isWidthBound {x : QuantumComp L (uBatchSpec P In) X A} {n : ℕ}
  • theorem IsPointBound.mono {x : QuantumComp L (uBatchSpec P In) X A} {n m : ℕ}
  • theorem IsTotalQueryBound.isPointBound {x : QuantumComp L (uBatchSpec P In) X A}
  • theorem IsWidthBound.bind {x : QuantumComp L (uBatchSpec P In) X A}
  • theorem IsWidthBound.mono {x : QuantumComp L (uBatchSpec P In) X A} {k k' : ℕ}
  • theorem isPointBound_act_bind_iff (p : SubInstrument A B β)
  • theorem isPointBound_prim (o : L.Op A) (n : ℕ) :
  • theorem isPointBound_primBind_iff (o : L.Op A)
  • theorem isPointBound_pure (a : X A) (n : ℕ) :
  • theorem isPointBound_queryBind_iff (ik : P × ℕ) (E : QReg)
  • theorem isPointBound_query_bind_iff (ik : P × ℕ) (E : QReg)
  • theorem isPointBound_query_iff (ik : P × ℕ) (E : QReg)
  • theorem isWidthBound_prim (o : L.Op A) (k : ℕ) :
  • theorem isWidthBound_primBind_iff (o : L.Op A)
  • theorem isWidthBound_pure (a : X A) (k : ℕ) :
  • theorem isWidthBound_queryBind_iff (ik : P × ℕ) (E : QReg)
  • theorem isWidthBound_query_iff (ik : P × ℕ) (E : QReg)

VCVio/Quantum/Comp/Sequentialize.lean (30)

  • def batchSlotEquiv (p : P) (k : ℕ) (F : QReg) (i : Fin k) :
  • noncomputable def relabelThen {A B : QReg} {W : QReg → Type w} (e : A ≃ B)
  • noncomputable def sequentialize {L : LocalSig.{uL, vL}} {W : QReg → Type w} {A : QReg}
  • noncomputable def sequentializeHandler {L : LocalSig.{uL, vL}} (I : L.Interp) :
  • noncomputable def sequentializeSlots {W : QReg → Type w} (p : P) (k : ℕ) (F : QReg)
  • theorem IsPointBound.sequentialize {L : LocalSig.{uL, vL}} (I : L.Interp)
  • theorem IsTotalQueryBound.sequentialize {L : LocalSig.{uL, vL}} (I : L.Interp)
  • theorem Lossless.sequentialize {L : LocalSig.{uL, vL}} {I : L.Interp}
  • theorem evalDistMap_sequentialize {L : LocalSig.{uL, vL}} (I : L.Interp) {A : QReg}
  • theorem evalDist_sequentialize {L : LocalSig.{uL, vL}} (I : L.Interp) {A : QReg}
  • theorem isTotalQueryBound_sequentializeHandler {L : LocalSig.{uL, vL}} (I : L.Interp)
  • theorem isTotalQueryBound_sequentializeSlots (p : P) (k : ℕ) (F : QReg)
  • theorem jointPost_sequentialize {L : LocalSig.{uL, vL}} (I : L.Interp) {A : QReg}
  • theorem lift_batchSlotEquiv (p : P) (k : ℕ) (F : QReg) (i : Fin k) :
  • theorem lossless_relabelThen {B : QReg} (e : A ≃ B)
  • theorem lossless_sequentializeSlots (p : P) (k : ℕ) (F : QReg) (is : List (Fin k))
  • theorem queryStep_bind_relabel_symm {A : QReg} (p : P) (E : QReg) (ℓ : A ≃ In p × E) :
  • theorem queryStep_eq_reindex {A : QReg} (p : P) (F : QReg) (ℓ : A ≃ In p × F) :
  • theorem relabelThen_bind {B : QReg} (e : A ≃ B)
  • theorem relabel_bind_batch_queryStep {A : QReg} (p : P) (k : ℕ) (F : QReg)
  • theorem run_relabelThen {A B : QReg} (e : A ≃ B)
  • theorem run_sequentialize {L : LocalSig.{uL, vL}} (I : L.Interp) {A : QReg}
  • theorem run_sequentializeSlots (p : P) (k : ℕ) (F : QReg) (is : List (Fin k))
  • theorem run_sequentializeSlots_finRange (p : P) (k : ℕ) (F : QReg)
  • theorem sequentializeSlots_bind (p : P) (k : ℕ) (F : QReg) (is : List (Fin k))
  • theorem sequentialize_bind {L : LocalSig.{uL, vL}} (I : L.Interp)
  • theorem sequentialize_primBind {L : LocalSig.{uL, vL}} (I : L.Interp) (o : L.Op A)
  • theorem sequentialize_pure {L : LocalSig.{uL, vL}} (I : L.Interp) (x : W A) :
  • theorem sequentialize_queryBind {L : LocalSig.{uL, vL}} (I : L.Interp) (p : P) (k : ℕ) (F : QReg)
  • theorem sequentialize_queryBind_zero {L : LocalSig.{uL, vL}} (I : L.Interp) (p : P) (F : QReg)

VCVio/Quantum/Comp/TotalQueryBound.lean (2)

  • theorem isTotalQueryBound_act_bind_iff (p : SubInstrument A B β)
  • theorem isTotalQueryBound_query_bind_iff (p : spec.Port) (E : QReg)

VCVio/Quantum/Foundations/Parallel.lean (25)

  • def pi {ι : Type} [Fintype ι] [DecidableEq ι] (i : ι) (A : QReg) :
  • def piSlotEquiv {ι A : Type} [DecidableEq ι] (i : ι) (e : A ≃ A) :
  • def piWithMemory {ι : Type} [Fintype ι] [DecidableEq ι] (i : ι) (A D : QReg) :
  • def sequenceEquiv (e : ι → A ≃ A) : List ι → A ≃ A
  • noncomputable def batch (A D : QReg) (p : SubInstrument (A × D) (A × D) Unit) (k : ℕ) :
  • noncomputable def sequenceUnit (p : ι → SubInstrument A A Unit) :
  • theorem batch_relabel_frame (A D : QReg) (e : A ≃ A) (k : ℕ) :
  • theorem batch_zero (A D : QReg) (p : SubInstrument (A × D) (A × D) Unit) :
  • theorem intertwines_sequenceUnit {B : Type*} [Fintype B]
  • theorem lift_relabel {A M : QReg} (S : Subsystem A M) (e : A ≃ A) :
  • theorem lift_relabel_piWithMemory {ι : Type} [Fintype ι] [DecidableEq ι]
  • theorem lossless_batch (A D : QReg) {p : SubInstrument (A × D) (A × D) Unit}
  • theorem lossless_sequenceUnit (p : ι → SubInstrument A A Unit) (is : List ι)
  • theorem piSlotEquiv_apply {ι A : Type} [DecidableEq ι] (i : ι) (e : A ≃ A)
  • theorem piWithMemory_equiv_apply {ι : Type} [Fintype ι] [DecidableEq ι] (i : ι)
  • theorem pi_equiv_apply {ι : Type} [Fintype ι] [DecidableEq ι] (i : ι) (A : QReg)
  • theorem sequenceEquiv_piSlot_apply {ι A : Type} [DecidableEq ι]
  • theorem sequenceEquiv_piSlot_finRange (A : QReg) (e : A ≃ A) (k : ℕ) :
  • theorem sequenceEquiv_prodCongr (e : ι → A ≃ A) (is : List ι) (D : Type*) :
  • theorem sequenceUnit_append (p : ι → SubInstrument A A Unit) (is js : List ι) :
  • theorem sequenceUnit_cons (p : ι → SubInstrument A A Unit) (i : ι) (is : List ι) :
  • theorem sequenceUnit_frame (p : ι → SubInstrument A A Unit) (is : List ι) (F : QReg) :
  • theorem sequenceUnit_nil (p : ι → SubInstrument A A Unit) :
  • theorem sequenceUnit_reindex (p : ι → SubInstrument A A Unit) (is : List ι) (e : A ≃ B) :
  • theorem sequenceUnit_relabel [Fintype A] [DecidableEq A] (e : ι → A ≃ A) (is : List ι) :

VCVio/Quantum/Oracle/Classical.lean (1)

  • theorem run_classicalQuery (H : X → Y) (t : X) :

VCVio/Quantum/Oracle/ClassicalParallel.lean (21)

  • noncomputable def classicalBatchImpl :
  • noncomputable def classicalBatchQuery (ts : List X) :
  • noncomputable def toQuantumBatch (oa : OracleComp (unifSpec + (X →ₒ Y).batch) α) :
  • theorem IsOnlineQueryBound.isPointBound_toQuantumBatch
  • theorem IsOnlineQueryBound.isTotalQueryBound_toQuantumBatch
  • theorem IsPointQueryBound.isPointBound_toQuantumBatch
  • theorem evalDist_parallelOracleRuntime_toQuantumBatch [MeasurableSpace α] (H : X → Y)
  • theorem isPointBound_classicalBatchQuery_bind_iff (ts : List X) (k : (Fin ts.length → Y) →
  • theorem isTotalQueryBound_classicalBatchQuery_bind_iff (ts : List X) (k : (Fin ts.length → Y) →
  • theorem lossless_classicalBatchQuery (ts : List X) :
  • theorem lossless_toQuantumBatch (oa : OracleComp (unifSpec + (X →ₒ Y).batch) α) :
  • theorem parallelOracleRuntime_step_branch_single (H : X → Y) (k : ℕ) (m : Fin k → X × Y)
  • theorem qromEvalDistMap_sequentialize_toQuantumBatch_eq_randomOracle
  • theorem qromEvalDistMap_sequentialize_toQuantumBatch_eq_unbatch
  • theorem run_classicalBatchQuery (H : X → Y) (ts : List X) :
  • theorem run_classicalBatchQuery_branch (H : X → Y) (ts : List X) (d : (parallelOracleRuntime H).D)
  • theorem run_toQuantumBatch (H : X → Y)
  • theorem sampledEvalDist₂_toQuantumBatch [MeasurableSpace α]
  • theorem sampledEvalDist₂_toQuantumBatch_eq_randomOracle [SampleableType Y] [MeasurableSpace α]
  • theorem toQuantumBatch_pure (a : α) :
  • theorem toQuantumBatch_query_bind (t : ℕ ⊕ List X)

VCVio/Quantum/Oracle/ClassicalRandomized.lean (10)

  • noncomputable def classicalRandomizedImpl :
  • noncomputable def toQuantumRandomized (oa : OracleComp (unifSpec + (X →ₒ Y)) α) :
  • theorem IsQueryBoundP.isQueryBound_toQuantumRandomized
  • theorem evalDist_additiveOracleRuntime_toQuantumRandomized [MeasurableSpace α] (H : X → Y)
  • theorem lossless_toQuantumRandomized (oa : OracleComp (unifSpec + (X →ₒ Y)) α) :
  • theorem qromEvalDist₂_toQuantumRandomized [MeasurableSpace α]
  • theorem qromEvalDist₂_toQuantumRandomized_eq_randomOracle [SampleableType Y]
  • theorem run_toQuantumRandomized (H : X → Y)
  • theorem toQuantumRandomized_pure (a : α) :
  • theorem toQuantumRandomized_query_bind (t : ℕ ⊕ X)

VCVio/Quantum/Oracle/Compressed/Parallel.lean (10)

  • theorem intertwines_purifiedRuntime_compressedRuntime_batch_step (ik : Unit × ℕ) :
  • theorem intertwines_purifiedRuntime_compressedRuntime_step (i : Unit) :
  • theorem matrix_jointPost_compressedRuntime_batch (I : L.Interp)
  • theorem outcomeLawWith_compressedRuntime_batch {γ : Type*} [MeasurableSpace γ]
  • theorem outcomeLawWith_compressedRuntime_batch_eq_purifiedRuntime {γ : Type*}
  • theorem outcomeLawWith_purifiedRuntime_batch {γ : Type*} [MeasurableSpace γ]
  • theorem outcomeLaw_compressedRuntime_batch [MeasurableSpace (Σ a, W a)] (I : L.Interp)
  • theorem reducedPost_compressedRuntime_batch (I : L.Interp)
  • theorem trace_jointPost_compressedRuntime_batch (I : L.Interp)
  • theorem trace_jointPost_purifiedRuntime_batch (I : L.Interp)

VCVio/Quantum/Oracle/Parallel.lean (35)

  • def parallelOracleEquiv (H : X → Y) (k : ℕ) :
  • def parallelOracleUnitary (H : X → Y) (k : ℕ) :
  • def qromBatchSpec : QuantumOracleSpec.{0, 0}
  • noncomputable def parallelOracleQuery (H : X → Y) (k : ℕ) :
  • noncomputable def parallelOracleRuntime (H : X → Y) :
  • noncomputable def qromBatchEvalDist [MeasurableSpace (Σ u, W u)] (I : L.Interp)
  • noncomputable def qromBatchEvalDistMap {β : Type w₁} [MeasurableSpace β] (I : L.Interp)
  • noncomputable def qromBatchEvalDistMap₂ {B : QReg} {α : Type w} {β : Type w₁}
  • noncomputable def qromBatchEvalDist₂ {B : QReg} {α : Type w} [MeasurableSpace α]
  • theorem batch_oracleQuery (H : X → Y) (k : ℕ) (D : QReg) :
  • theorem branch_parallelOracleQuery (H : X → Y) (k : ℕ) (u : Unit) :
  • theorem conjTranspose_parallelOracleUnitary (H : X → Y) (k : ℕ) :
  • theorem conj_parallelOracleUnitary_apply [Fintype X] [Fintype Y] (H : X → Y) (k : ℕ)
  • theorem lossless_parallelOracleQuery (H : X → Y) (k : ℕ) :
  • theorem lossless_parallelOracleRuntime_step (H : X → Y) (k : ℕ) :
  • theorem lossless_run_parallelOracleRuntime (I : L.Interp)
  • theorem parallelOracleEquiv_add (H H' : X → Y) (k : ℕ) :
  • theorem parallelOracleEquiv_apply (H : X → Y) (k : ℕ)
  • theorem parallelOracleEquiv_neg (H : X → Y) (k : ℕ) :
  • theorem parallelOracleEquiv_symm_apply (H : X → Y) (k : ℕ)
  • theorem parallelOracleEquiv_zero (k : ℕ) :

…and 125 more not listed.


sorry Tracking

  • No sorrys were added, removed, or affected.

📋 **Additional Analysis**

No findings.

The diff introduces parallel oracle rounds, sequentialization, point/width/round budgets, classical bridges (both single-query and batch), compressed-oracle parallel execution, and corresponding tests and documentation. These additions are substantial and directly relevant to the VCVio quantum layer. However, they do not touch any of the specific process, style, or infrastructure items listed in the deployment-supplied instructions (header policy, docstring layout, linter settings, Python tooling, merge queue procedure, toolchain bumps, section variables, ASCII banners, etc.). All new files use the correct copyright header format, have proper module docstrings, follow the prologue layout and public section style, and respect the naming conventions visible in the diff. There is no violation of the policies described in the contributed instructions. The diff is therefore fully compliant.


📄 **Per-File Summaries**
  • VCVio.lean: This change adds public imports for the Parallel, RoundBound, Sequentialize, ClassicalParallel, ClassicalRandomized, and Foundations.Parallel modules, making their definitions and theorems accessible to downstream files in the project.
  • VCVio/Quantum/Comp/Parallel.lean: This file introduces the QuantumRuntime.batch construction, which orders a runtime's one-result endomorphism ports into batched slots sharing private memory. It defines uBatchSpec as uSpec (P × ℕ) fun ik ↦ QReg.of (Fin ik.2 → In ik.1), and batch is implemented using SubInstrument.batch. Two auxiliary lemmas (intertwines_relabel_queryEquivIn_symm and intertwines_lift_piWithMemory) are proven privately to support the main transfer theorem, and the file provides theorems batch_D, batch_init, lossless_batch_step, intertwines_batch_step, and evalDist_batch_eq_of_simulation to establish that batching preserves the private register, initial state, losslessness, simulations through private memory, and trace-preserving simulation equivalences.
  • VCVio/Quantum/Comp/RoundBound.lean: This new file RoundBound.lean introduces two syntactic cost metrics for quantum computations under ordered batches: IsPointBound (total width consumed across all batches on a branch) and IsWidthBound (per-batch width cap). It defines Cmd.pointCharge to assign each batch command its width and local operations zero charge, then derives IsPointBound via IFreeM.IsChargeBound and IsWidthBound via IFreeM.IsRollBound. The file provides simp lemmas for pure, primBind, queryBind, prim, and query for each predicate, monotonicity and sequencing lemmas, and the bridging theorems IsPointBound.isWidthBound (total budget bounds individual rounds) and IsTotalQueryBound.isPointBound (width cap plus round count gives a point bound). It also adds isPointBound_act_bind_iff and isPointBound_query_bind_iff to the QComp and QuantumComp₂ namespaces respectively.
  • VCVio/Quantum/Comp/Sequentialize.lean: This new file Sequentialize.lean defines the core translation from the unstructured batch specification uBatchSpec P In to the single-slot instrument specification uSpec P In. It introduces batchSlotEquiv to expose one slot of a batch while carrying the others, relabelThen to apply a public-register relabelling before a continuation, sequentializeSlots to issue ordered calls for a list of slots while restoring the full public register after each, and sequentializeHandler/sequentialize to replace every batch command (primitive or query) in a QuantumComp program with equivalent single-slot commands. The file then proves a suite of theorems: the translation commutes with pure, primBind, and bind (sequentialize_pure, sequentialize_primBind, sequentialize_bind); a batch query becomes the ordered list of slot calls (sequentialize_queryBind, with a zero‑width simplification sequentialize_queryBind_zero); the ordered calls increase the total query bound by the number of slots (isTotalQueryBound_sequentializeSlots and isTotalQueryBound_sequentializeHandler); and point bounds and combined round/width bounds are preserved (IsPointBound.sequentialize, IsTotalQueryBound.sequentialize). It also demonstrates that syntactic losslessness is preserved (lossless_relabelThen, lossless_sequentializeSlots, Lossless.sequentialize). Finally, for any stateful runtime R, the file proves that running the sequentialized program yields exactly the same result as running the original batch program (run_sequentialize, jointPost_sequentialize, evalDist_sequentialize, evalDistMap_sequentialize), establishing the fully verified semantic equivalence of the sequentialization transformation.
  • VCVio/Quantum/Comp/TotalQueryBound.lean: Added two @[simp] theorems providing alternative characterizations of IsTotalQueryBound. isTotalQueryBound_act_bind_iff (in Quantum.QComp) states that (act p).bind k has bound n iff every continuation k b individually has bound n. isTotalQueryBound_query_bind_iff (in Quantum.QuantumComp₂) states that (query p E e).bind k has bound n iff n > 0 and for each result r, k r has bound n-1. These simplify reasoning about query costs by reducing compound programs to their components.
  • VCVio/Quantum/Foundations/Parallel.lean: This new file, Parallel.lean, introduces concepts for ordered operations on finite families of quantum registers. It defines piSlotEquiv (a basis permutation acting on one coordinate) and Subsystem.pi/Subsystem.piWithMemory for selecting a single coordinate, with or without private memory, along with explicit equiv actions. It then defines SubInstrument.sequenceUnit to apply a list of one-result instruments in order, proving losslessness preservation (lossless_sequenceUnit), concatenation (sequenceUnit_append), and intertwining through a fixed map (intertwines_sequenceUnit). Companion definitions include sequenceEquiv for composing basis permutations, with theorems sequenceUnit_relabel, sequenceEquiv_prodCongr, sequenceEquiv_piSlot_apply, and sequenceEquiv_piSlot_finRange relating sequencing of relabellings to pointwise permutations. The batch operation applies a step instrument to each slot in increasing order, with properties batch_zero, lossless_batch, and batch_relabel_frame linking batching of framed relabellings to a global frame. Finally, sequenceUnit_frame and sequenceUnit_reindex show that framing and reindexing commute with sequencing. No sorry or admit appear.
  • VCVio/Quantum/Oracle/Classical.lean: The documentation now includes a "## Private randomness" section explaining that the new modules ClassicalRandomized and ClassicalParallel embed algorithms with local uniform coins and ordinary function queries while preserving the classical lazy random-oracle law and charging no oracle queries for private coins; the "## Not covered" section has been updated to remove the previously listed item about private randomness. The theorem run_classicalQuery is added, establishing that a basis query against a fixed function H : X → Y on a point t : X returns the table answer H t as a pure instrument, filling a gap in the classical embedding.
  • VCVio/Quantum/Oracle/ClassicalParallel.lean: This PR introduces ClassicalParallel.lean, a new file formalizing classical-round parallel quantum oracle queries. It defines classicalBatchQuery, a quantum program that, given a list of inputs, makes one parallel oracle call of that width and measures all response slots, and classicalBatchImpl, a QueryImpl that interprets either a local coin sample or such a batch query. The file provides lossless_classicalBatchQuery establishing losslessness, parallelOracleRuntime_step_branch_single and run_classicalBatchQuery_branch describing the runtime behavior on a fixed function, and run_classicalBatchQuery showing that the fixed-function run reduces to a deterministic tuple. It defines toQuantumBatch, which embeds a classical randomized algorithm (with unifSpec + (X →ₒ Y).batch queries) into the quantum batch oracle model, and supplies toQuantumBatch_pure, toQuantumBatch_query_bind, and lossless_toQuantumBatch. The core correctness theorems run_toQuantumBatch, evalDist_parallelOracleRuntime_toQuantumBatch, sampledEvalDist₂_toQuantumBatch, sampledEvalDist₂_toQuantumBatch_eq_randomOracle, qromEvalDistMap_sequentialize_toQuantumBatch_eq_randomOracle, and qromEvalDistMap_sequentialize_toQuantumBatch_eq_unbatch show that the quantum embedding matches the classical fixed-table and random-oracle output distributions. Finally, resource-bound theorems isTotalQueryBound_classicalBatchQuery_bind_iff, isPointBound_classicalBatchQuery_bind_iff, IsOnlineQueryBound.isTotalQueryBound_toQuantumBatch, IsPointQueryBound.isPointBound_toQuantumBatch, and IsOnlineQueryBound.isPointBound_toQuantumBatch relate the classical query and point bounds to the quantum embedding.
  • VCVio/Quantum/Oracle/ClassicalRandomized.lean: This new file introduces the standard embedding of classical randomized algorithms into the sequential QROM. It defines classicalRandomizedImpl, a QueryImpl that maps uniform private samples (unifSpec) to local coin flips (QComp.coinImpl) and function queries (X →ₒ Y) to ordinary quantum basis calls (classicalQuery). The central definition toQuantumRandomized uses this implementation to embed any OracleComp over the combined oracle. Key theorems validate the embedding: toQuantumRandomized_pure and toQuantumRandomized_query_bind give equational lemmas for pure returns and query-bind; lossless_toQuantumRandomized proves the resulting quantum program is lossless; IsQueryBoundP.isQueryBound_toQuantumRandomized transfers a query bound that counts only function queries (ignoring coin flips). The run_toQuantumRandomized theorem shows that running the quantum embedding against a fixed function H equals the fixed-table classical execution simulateQ with local coins. evalDist_additiveOracleRuntime_toQuantumRandomized gives the corresponding output measure identity. Finally, under [SampleableType (X → Y)], qromEvalDist₂_toQuantumRandomized expresses the sequential QROM distribution as sampling a random function and then simulating, and qromEvalDist₂_toQuantumRandomized_eq_randomOracle equates it to the classical lazy random-oracle law (via OracleComp.evalDist_simulateQ_romImpl_run'_eq_completeTable). No sorry or admit are present.
  • VCVio/Quantum/Oracle/Compressed/Parallel.lean: This new file establishes the equivalence between the compressed and purified parallel runtimes for ordered batches of the compressed oracle, proving that they are intertwined by an isometry (via theorems intertwines_purifiedRuntime_compressedRuntime_step and intertwines_purifiedRuntime_compressedRuntime_batch_step) and that their joint post-states, reduced post-states, leaf traces, and outcome laws are identical (matrix_jointPost_compressedRuntime_batch, reducedPost_compressedRuntime_batch, trace_jointPost_compressedRuntime_batch, outcomeLawWith_compressedRuntime_batch_eq_purifiedRuntime). Additionally, it relates the purified parallel runtime to the parallel QROM law via uniform averaging over fixed-function parallel oracles (trace_jointPost_purifiedRuntime_batch, outcomeLawWith_purifiedRuntime_batch) and concludes that the compressed parallel runtime satisfies the parallel QROM outcome law (outcomeLawWith_compressedRuntime_batch, outcomeLaw_compressedRuntime_batch).
  • VCVio/Quantum/Oracle/Parallel.lean: This new file introduces the parallel (width-k) quantum random oracle model. It defines the permutation parallelOracleEquiv (applying oracleEquiv H in every slot), the unitary matrix parallelOracleUnitary as its basisMatrix, and the SubInstrument parallelOracleQuery. Several algebraic properties are proved: parallelOracleEquiv_add and parallelOracleEquiv_neg show the permutation respects function addition and negation; conjTranspose_parallelOracleUnitary identifies the adjoint as the negated-function oracle; parallelOracleUnitary_mulVec_single and conj_parallelOracleUnitary_apply describe its action on basis vectors and density matrices; parallelOracleUnitary_eq_oracleUnitary_submatrix relates the parallel unitary to a submatrix of the ordinary additive oracle; and batch_oracleQuery verifies that batching sequential single-slot oracle queries reproduces the parallel query's frame. The parallelOracleRuntime is then constructed as the batch of additiveOracleRuntime, and its step is shown equal to the frame of the parallel query. Finally, the file defines the evaluation distributions qromBatchEvalDist, qromBatchEvalDistMap, qromBatchEvalDist₂, and qromBatchEvalDistMap₂ over the hidden function H : X → Y, and provides theorems (qromBatchEvalDist_eq_sum, qromBatchEvalDist₂_eq_sum, qromBatchEvalDist_apply_univ) expressing them as uniform averages over all functions, confirming the QROM law.
  • VCVio/Quantum/Oracle/Sequentialize.lean: Added the new file VCVio/Quantum/Oracle/Sequentialize.lean, which proves four theorems about sequentializing parallel quantum random-oracle model (QROM) programs: qromEvalDist_sequentialize (sequentialization preserves the averaged output law), qromEvalDistMap_sequentialize (preservation of any observation depending on the jointly sampled function and classical leaf), QuantumComp.IsPointBound.qrom_sequentialize (a parallel point budget bounds the single QROM port after sequentialization), and qromBatchEvalDistMap_le_of_sequential_bound (a sequential QROM probability bound at Q queries transfers to a parallel program with Q total queried points). The file also includes module-level documentation explaining the context and imports VCVio.Quantum.Comp.Sequentialize and VCVio.Quantum.Oracle.Parallel. No sorry or admit are present.
  • VCVioTest.lean: The file VCVioTest.lean has been updated by adding four new public import statements for modules within the Quantum subdirectory: ClassicalRandomized, Parallel, ParallelBridges, and Sequentialize. These additions make these modules available for use across the project, extending the quantum component's API with support for classical randomized computations, parallel execution structures, bridges between parallel systems, and sequentialization of quantum processes. No existing imports were removed or modified, and no proofs, definitions, or sorry/admit declarations were changed or introduced.
  • VCVioTest/Quantum/ClassicalRandomized.lean: This file introduces a module for sequential randomized classical embedding regressions, defining the adaptive program adaptive that uses a private coin to select an address and then makes repeated oracle calls to a nonbinary response group ZMod 3. It provides the answers function to compute deterministic outcomes for a given function H and private coin b, along with theorems and examples verifying simulation (simulateQ_adaptive), concrete table values (table), quantum evaluation correctness, and shared-cache lazy random oracle laws via qromEvalDist₂_toQuantumRandomized_eq_randomOracle. The theorem adaptive_classical_budget proves an exact syntactic query bound of 3 for adaptive, and several examples demonstrate transfer to quantum programs and impossibility of lower budgets. Finally, the coinsOnly definition illustrates a computation using only private randomness with zero quantum queries, and an example confirms its quantum private-coin law matches the classical uniform distribution.
  • VCVioTest/Quantum/Parallel.lean: This new file adds a comprehensive suite of regression tests for the Parallel.lean module in VCVioTest/Quantum/. The examples verify core properties of parallel oracle queries: two copies of the same input receive the same answer (parallelOracleEquiv), the width can exceed the domain cardinality, repeated width-two queries on a cyclic group of order three do not cancel, the inverse subtracts the same answer in every slot (parallelOracleEquiv.symm), the matrix law for parallelOracleUnitary works on entangled superpositions, ordered batching equals the simultaneous query (batch_oracleQuery), a zero-width call leaves private memory unchanged (parallelOracleRuntime_step_zero), and the QROM batch spec port pairs a base port with ℕ. It also defines two noncomputable helper functions: queryTwo (a two-slot query) and chooseWidth (a branch-dependent width query), each proven to consume exactly one oracle round. A base simulation result is extended to the actual parallel runtime's steps (QuantumRuntime.intertwines_batch_step), and a generic batch simulation theorem (QuantumRuntime.evalDist_batch_eq_of_simulation) is applied to compare a parallel QROM program with another batched runtime, including adaptive register sizes and widths. Finally, two examples demonstrate how batching and reversing steps affect the correlation with private memory.
  • VCVioTest/Quantum/ParallelBridges.lean: This new file VCVioTest/Quantum/ParallelBridges.lean introduces a collection of definitions, examples, and theorems that serve as regression tests and bridge cases for parallel classical and compressed quantum oracle semantics. It defines subnormalized states halfState and mixedBool, a Boolean-spectator batch spectatorBatch, an adaptive-width program adaptive, a nonbinary table table (Bool → ZMod 3), and several oracle programs (correlatedRounds, randomizedWidths, freeCoin, emptyRound) that exercise repeated-input tuples, adaptive batch widths, and the distinction between compression isometries and non-trace-preserving function-register projections. Key theorems verify: exact compressed parallel laws for mixed states (outcomeLawWith_compressedRuntime_batch), trace preservation of the full compression map (MatrixMap.isTP_conj), query-bound and point-bound estimates for adaptive branches (IsTotalQueryBound 2, IsPointBound 5), ordered classical batch query answers (run_classicalBatchQuery_branch), and that the quantum embedding of randomized-width programs matches classical simulation (qromEvalDistMap_sequentialize_toQuantumBatch_eq_unbatch). All proofs are complete; there are no sorry or admit declarations.
  • VCVioTest/Quantum/Sequentialize.lean: This file adds a comprehensive test module for the sequentialization of quantum batch computations in VCVio. It introduces zeroWidth, a zero-width quantum call that relabels a Bool register, along with examples verifying its point, total-query, and runtime branch behavior. The adaptive definition models a two-adaptive-round computation with path-dependent register sizes (2 or 3), and it includes companion theorems (adaptive_point_iff, adaptive_width_iff, adaptive_round_iff) characterizing its exact point, width, and round budgets, plus specific regression tests using a shortChoice DSubInstrument that exercises zero-weight branches. The file also introduces gates (a one-gate signature with flipSpectator) and namedBatch, swapRuntime, statefulBatch, qromCall, and qromObserve to test named local operations, shared private memory, QROM interfaces, and large-outcome/port universes. Several example blocks (including one using QComp₂) verify budget-preserving properties of sequentialization, and the final two example blocks establish lemmas about act_bind and query_bind budget equivalences in higher universes.
  • docs/design/quantum-layer.md: This documentation update significantly expands the design document for the quantum layer in VCVio. The high-level description of the import structure now notes that VCVio's pinned QuantumFoundations dependency has a different Quantum.QComp in QuantumFoundations.Instrument which collides with VCVio's Quantum.Comp.Basic; the stack avoids that module. The section previously titled "Open obligations" is renamed "Coverage and remaining obligations". The coverage statement for OracleComp.toQuantum is updated to describe two new embeddings: OracleComp.toQuantumBatch (for list-round parallel queries) and OracleComp.toQuantumRandomized (for single-port queries with local coins), with explicit named theorems (qromEvalDist₂_toQuantumRandomized_eq_randomOracle) and the observation that the query-bound transfer for the randomized embedding counts only function queries. A new subsection "11. Parallel oracle rounds" is added, documenting the parallel runtime infrastructure across five files: Foundations/Parallel.lean (coordinate subsystems), Comp/Parallel.lean (runtime batches with shared private register, requiring equal In/Out and Result = Unit), Oracle/Parallel.lean (parallel QROM law via parallelOracleRuntime H), Comp/RoundBound.lean (separate round, width, and point bounds), Comp/Sequentialize.lean (named command sequentializeHandler and translation x.sequentialize and associated bound transfers), Oracle/Sequentialize.lean (theorems qromEvalDist_sequentialize and qromEvalDistMap_sequentialize), Oracle/ClassicalParallel.lean (classical bridge with theorems run_toQuantumBatch, sampledEvalDist₂_toQuantumBatch_eq_randomOracle, and bound transfers), and Oracle/Compressed/Parallel.lean (compressed parallel bridge with theorems matrix_jointPost_compressedRuntime_batch, outcomeLaw_compressedRuntime_batch, outcomeLawWith_compressedRuntime_batch). Existing open obligations are updated: the general final-measurement lemma and compressed-oracle output bounds for collision and zero-preimage remain open (Remaining quantum random-oracle results: classical embedding, shared games, oracle checks and compressed-oracle bounds #966). The item on Zhandry's compressed oracle is shortened to match the new structure.
  • docs/quantum/README.md: The introductory sentence for the guide section was reworded from 'One file per part of the library, each starting from a worked example with the Lean declarations beside it' to 'The guide explains each part of the library with Lean declarations and worked examples' to improve clarity about the guide's structure. The list of guide files remained unchanged.
  • docs/quantum/guide/4-programs-and-runtimes.md: The document adds a new section "Rounds, widths and points" that defines three syntactic bounds for batch programs (IsTotalQueryBound, IsWidthBound, IsPointBound) and explains how they compose, including that IsTotalQueryBound.isPointBound combines a round bound r and width cap k into a point bound k * r. It adds a section "Sequentializing batches" that describes x.sequentialize I, which translates a batch program into a single-point sequential program using sequentializeHandler I, and states the key equality QuantumRuntime.run_sequentialize: R.run .instruments (x.sequentialize I) = R.batch.run I x as equality of full dependent instruments including the runtime's private register. It also adds two new rows to the existing theorem table: one for the batch-to-sequential equality (QuantumRuntime.run_sequentialize) and one noting the test file VCVioTest/Quantum/Sequentialize.lean that checks adaptive budgets, zero-weight branches, zero-width relabellings, and ordered calls sharing private memory. The document's introduction now lists "parallel query budgets" as a covered topic. The runtime description is revised: the private register is now referred to as QuantumRuntime.D (rather than R.D) and R.run I x is described as "a dependent subinstrument" (removing the earlier quantification "on (program register) × (private register)").
  • docs/quantum/guide/5-qrom.md: This documentation file for the quantum random-oracle model (QROM) has been significantly expanded. It now covers classical private coins and their compilation via oa.toQuantumRandomized (from Oracle/ClassicalRandomized.lean), the parallel oracle rounds (qromBatchSpec X Y) with the parallelOracleEquiv and parallelOracleUnitary definitions, the sequentialization equivalence (qromEvalDist_sequentialize), and classical rounds with private coins via OracleComp.toQuantumBatch. New sections detail parallel compressed execution (Oracle/Compressed/Parallel.lean) and its output law outcomeLaw_compressedRuntime_batch. The checks table is updated with new agreement entries, and the test coverage notes mention new test files VCVioTest/Quantum/Parallel.lean and VCVioTest/Quantum/ParallelBridges.lean.
  • docs/quantum/guide/README.md: The diff updates docs/quantum/guide/README.md to reflect progress and scope adjustments. It revises the description of the guide's pedagogical structure, adds a note about the new file VCVio/Quantum/Foundations/Parallel.lean (which stages generic parallel and subinstrument batching facts), and updates the topic lists for guides 4 and 5 to include parallel query budgets, sequentialization, private uniform coins, and compressed execution bridges. The “Scope” section is rewritten: the covered list now mentions failure as missing mass, private uniform coins, variable-width parallel rounds, and parallel compressed-runtime output-law equivalence; the not-covered list adds depth-sensitive search bounds, quantum delay security, auxiliary-input preprocessing, serialized public puzzles, unrestricted-length hash queries, and early-success quantum truncation as separate items.
  • docs/quantum/reference/classical-quantum.md: This documentation update expands the classical-quantum reference table in docs/quantum/reference/classical-quantum.md to include three new correspondences: OracleComp (unifSpec + (X →ₒ Y)) α maps to OracleComp.toQuantumRandomized (ordinary basis queries, free local private coins, same lazy random-oracle law); OracleComp (unifSpec + (X →ₒ Y).batch) α maps to OracleComp.toQuantumBatch (one quantum call per list round, local private coins, same lazy random-oracle law); and classical IsOnlineQueryBound oa (r, q) maps to round bound r and point bound q for oa.toQuantumBatch, with classical list-order unbatching mapped to quantum sequentialization of oa.toQuantumBatch (same observed law). The table also refines IsTotalQueryBound to QuantumComp.IsTotalQueryBound, and adds a note that depth-sensitive marked-search and preimage bounds require separate analysis.
  • docs/quantum/reference/literature.md: Adds a table row documenting the newly introduced declarations parallelOracleUnitary, batch_oracleQuery, and qromBatchEvalDist. These are attributed to Chung, Fehr, Huang, and Liao (arXiv:2010.11658v4, §4.4, pp. 12–13) and are described as handling simultaneous additive queries with variable classical widths and one shared random function. This updates the literature reference table to cover the parallel variant of the oracle machinery.

Last updated: 2026-11-20 22:10 UTC.

@github-actions

github-actions Bot commented Nov 19, 2026 •

Copy link
Copy Markdown

Build Timing Report

  • Source: 663710f
  • Message: Merge a2061ed into 7c167e8
  • Ref: feat/parallel-qrom-01-model
  • Build cache: restored the build of 7c167e8; Lake rebuilt only modules whose source or imports differ from it.
  • Commands: library build lake build ToMathlib VCVio LatticeCrypto Extern HashSig Examples; smoke test lake env lean VCVioTest/Smoke.lean.
Measurement Wall (s) CPU work (s) Status
Library build 74.45 190.51 ok
Smoke test 6.56 2.28 ok

CPU work is user + sys. Wall time depends on which modules this run had to rebuild, so compare it across runs only together with the module section below.

Rebuilt Modules

Rebuilt 65 modules (13 without an earlier time). The 52 with an earlier time took 311s here against 278s when last built (+33s (+12.0%)).

Estimated clean-build compile time, summed over all 1709 modules: 4366s before, 4442s after (+76s (+1.7%)).

Per-module times are wall-clock under whatever parallel load the run had, so treat small differences as noise; a large change on one module is the signal.

Showing 20 slowest of 65 rebuilt modules.

Current (s) Earlier (s) Delta (s) Path
23 19 +4 VCVioTest/Quantum/Emulated.lean
22 18 +4 VCVioTest/Quantum/Oracle.lean
17 10 +7 VCVioTest/ProbabilityTactics.lean
17 15 +2 VCVioTest/Quantum/VCOffline.lean
16 15 +1 VCVioTest/Quantum/CheckedRead.lean
10 10 +0 VCVio/Quantum/Oracle/ClassicalRepeatability.lean
8.1 6.6 +1.5 VCVioTest/LongChainPrograms.lean
7.5 3.5 +4.0 VCVio/Quantum/Oracle/Classical.lean
7.5 12 -4 VCVio/Quantum/VC/Proof/OnlineSecurity.lean
7.3 9.9 -2.6 VCVio/Quantum/VC/MultiExtractable.lean
7.2 6.9 +0.3 VCVio/Quantum/VC/Proof/CheckerDistance.lean
7.2 7.4 -0.2 VCVio/Quantum/VC/Proof/Repeatability.lean
6.9 5.9 +1.0 VCVio/Quantum/VC/Proof/Offline.lean
6.9 4.7 +2.2 VCVioTest/Quantum/VectorCommitmentQuantum.lean
6.8 7.8 -1.0 VCVio/Quantum/VC/Proof/GoodEvent.lean
6.2 - - VCVio/Quantum/Foundations/Parallel.lean
6.2 7.5 -1.3 VCVio/Quantum/VC/Proof/Commutativity.lean
6.0 2.9 +3.1 VCVio/Quantum/Comp/TotalQueryBound.lean
5.7 4.0 +1.7 VCVio/Quantum/VC/Emulated.lean
5.7 7.0 -1.3 VCVio/Quantum/VC/Proof/Online.lean

Expose reusable, universe-polymorphic budget lemmas in the core modules, add parallel observation laws and package sequential-bound transport for joint oracle/output events. Document one-port rounds and local-cost scope.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant