Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

QPBT definitions: Upstream

Definition
QPBT_QPBT_Upstream

by Dengnifer · Oct 27, 2026 · Mathlib 0df444a (Lean v4.33.1)

qpbt

This bundle provides the finite-sum, marginal-state, measurement, and Fourier-character helpers imported by the QPBT. The definitions connect bipartite density matrices to local states and express character orthogonality over arbitrary finite coordinate types.

Principal definitions:

  • MIPStarRE.LDT.MakingMeasurementsProjective.diagBlock: the diagonal block of a bipartite operator at a fixed right-register index.
  • MIPStarRE.LDT.MakingMeasurementsProjective.leftMarginalDensity: the normalized left marginal obtained by averaging those diagonal blocks.
  • MIPStarRE.LDT.MakingMeasurementsProjective.leftMarginalState: the local quantum state defined by the left marginal density.
  • MIPStarRE.Quantum.Measurement.ext: equality of complete measurements from equality of all effects.
  • MIPStarRE.LDT.averageOperatorOverDistribution_smul_const: averages scalar multiples of a fixed operator by averaging their scalar coefficients.
  • MIPStarRE.LDT.Distribution.IsProbability.weight_sum_eq_one_of_subset: total probability one on any finite superset of the explicit support.
  • MIPStarRE.LDT.Preliminaries.expect_ffChar_sum_mul: Fourier-character orthogonality in expectation over a finite coordinate space.
  • MIPStarRE.LDT.Preliminaries.sum_ffChar_sum_mul: the corresponding finite-sum orthogonality identity.

Formalization Credit. This Lean declaration is part of the Quantum Pauli basis test formalization by Ruixuan Deng. The source code was generated by AI agents; Ruixuan Deng is the responsible maintainer.

Mathematical Source. The mathematical source is Ji, Natarajan, Vidick, Wright, and Yuen, MIP*=RE, arXiv:2001.04383v3.

Definition code
-- Generated from QPBT/Upstream.lean by skeleton subtraction.
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_AxisParallelLine
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_DiagonalLine
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_Distribution
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_LinePolynomials
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_LowDegreePolynomial
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_OpFamily
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_ParametersBase
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_ParametersFiniteAnswers
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_QuantumState
import Definitions.Def_LIDT_MIPStarRE_LDT_CommutativityPoints_Defs
import Definitions.Def_LIDT_MIPStarRE_LDT_ExpansionHypercubeGraph_Defs_Core
import Definitions.Def_LIDT_MIPStarRE_LDT_GlobalVariance_Defs_Core
import Definitions.Def_LIDT_MIPStarRE_LDT_MakingMeasurementsProjective_Defs
import Definitions.Def_LIDT_MIPStarRE_LDT_Pasting_Defs_Families
import Definitions.Def_LIDT_MIPStarRE_LDT_Pasting_Defs_Interpolation
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_FiniteFields
import Definitions.Def_LIDT_MIPStarRE_LDT_Tactic_AvgCongr
import Definitions.Def_LIDT_MIPStarRE_LDT_Test_StrategyCore
import Definitions.Def_LIDT_MIPStarRE_Quantum_FiniteMatrix_Basic
import Definitions.Def_LIDT_MIPStarRE_Quantum_Measurement
import Theorems.Thm_LIDT_MIPStarRE_LDT_Preliminaries_fourier_fact_vector

namespace LIDT.MIPStarRE.LDT
end LIDT.MIPStarRE.LDT
namespace LIDT.MIPStarRE.LDT.Distribution.IsProbability
end LIDT.MIPStarRE.LDT.Distribution.IsProbability
namespace LIDT.MIPStarRE.LDT.MakingMeasurementsProjective
end LIDT.MIPStarRE.LDT.MakingMeasurementsProjective
namespace LIDT.MIPStarRE.LDT.Preliminaries
end LIDT.MIPStarRE.LDT.Preliminaries
namespace LIDT.MIPStarRE.Quantum.Measurement
end LIDT.MIPStarRE.Quantum.Measurement

/-!
# Public helpers for the upstream LIDT interface

These finite-sum and measurement lemmas support the QPBT without modifying its LIDT dependency.
The marginal-state construction and rank-zero argument adapt the private proofs in
`LionSR/MIPStarRE`, commit `f382c801026f53a9efc260fdee707cb35e0adb15`, module
`MIPStarRE.LDT.MakingMeasurementsProjective.LocalityPreservingRepair`.
The remaining lemmas are QPBT extensions of the upstream measurement and distribution APIs.
Their proofs use the public definitions and Mathlib finite-dimensional linear algebra.
-/

@[expose] public section

open scoped BigOperators MatrixOrder Matrix ComplexOrder

namespace LIDT
namespace MIPStarRE.Quantum.Measurement
variable {d : Type*} [Fintype d] [DecidableEq d]
variable {α β : Type*} [Fintype α] [Fintype β]

/-- A complete measurement is determined by its effects. -/
theorem ext {M N : _root_.LIDT.MIPStarRE.Quantum.Measurement α d} (h : ∀ a, M.effect a = N.effect a) :
    M = N := by
  cases M with
  | mk M hM =>
      cases N with
      | mk N hN =>
          cases M with
          | mk effectM posM leM =>
              cases N with
              | mk effectN posN leN =>
                  simp only at h
                  have heffect : effectM = effectN := funext h
                  subst effectN
                  rfl



end MIPStarRE.Quantum.Measurement
end LIDT

namespace LIDT
namespace MIPStarRE.LDT

/-- Averaging scalar multiples of a fixed operator averages their coefficients
over the distribution's support. -/
theorem averageOperatorOverDistribution_smul_const {α ι : Type*}
    [Fintype ι] [DecidableEq ι] (𝒟 : _root_.LIDT.MIPStarRE.LDT.Distribution α) (c : α → ℂ)
    (A : _root_.LIDT.MIPStarRE.Quantum.Op ι) :
    _root_.LIDT.MIPStarRE.LDT.averageOperatorOverDistribution 𝒟 (fun a => c a • A) =
      (∑ a ∈ 𝒟.support, (𝒟.weight a : ℂ) * c a) • A := by
  simp only [_root_.LIDT.MIPStarRE.LDT.averageOperatorOverDistribution, Finset.sum_smul]
  apply Finset.sum_congr rfl
  intro a ha
  rw [← Complex.real_smul, smul_assoc]



namespace Distribution.IsProbability

/-- A probability distribution has total weight one over any finite superset
of its explicit support. -/
theorem weight_sum_eq_one_of_subset {α : Type*}
    {𝒟 : _root_.LIDT.MIPStarRE.LDT.Distribution α} (h𝒟 : 𝒟.IsProbability) {s : Finset α}
    (hsubset : 𝒟.support ⊆ s) :
    ∑ a ∈ s, 𝒟.weight a = 1 := by
  have hsum :
      ∑ a ∈ 𝒟.support, 𝒟.weight a = ∑ a ∈ s, 𝒟.weight a :=
    Finset.sum_subset hsubset (fun a _ ha => 𝒟.outsideSupport a ha)
  exact hsum ▸ h𝒟.weight_sum_eq_one

end Distribution.IsProbability
end MIPStarRE.LDT
end LIDT

namespace LIDT
namespace MIPStarRE.LDT.Preliminaries

variable {p : ℕ} [Fact p.Prime]
variable {F : Type*} [Field F] [Fintype F] [DecidableEq F] [Algebra (ZMod p) F]
variable {ι : Type*} [Fintype ι] [DecidableEq ι]

/-- Fourier orthogonality for the canonical character over an arbitrary finite
coordinate type. This is the finite-index reindexing of
`prop:fourier-fact-vector`. -/
theorem expect_ffChar_sum_mul (v : ι → F) :
    𝔼 u : (ι → F), _root_.LIDT.MIPStarRE.LDT.Preliminaries.ffChar (p := p) (F := F) (∑ i, u i * v i) =
      if v = 0 then (1 : ℂ) else 0 := by
  let eι : ι ≃ Fin (Fintype.card ι) := Fintype.equivFin ι
  let reindex : (ι → F) ≃ (Fin (Fintype.card ι) → F) :=
    { toFun := fun u j => u (eι.symm j)
      invFun := fun u i => u (eι i)
      left_inv := fun u => by
        funext i
        simp
      right_inv := fun u => by
        funext j
        simp }
  let v' : Fin (Fintype.card ι) → F := reindex v
  calc
    𝔼 u : (ι → F), _root_.LIDT.MIPStarRE.LDT.Preliminaries.ffChar (p := p) (F := F) (∑ i, u i * v i) =
        𝔼 u : (Fin (Fintype.card ι) → F),
          _root_.LIDT.MIPStarRE.LDT.Preliminaries.ffVecChar (p := p) (F := F) v' u := by
      refine Finset.expect_equiv reindex (by simp) ?_
      intro u _
      rw [_root_.LIDT.MIPStarRE.LDT.Preliminaries.ffVecChar_apply]
      congr 2
      exact Fintype.sum_equiv eι
        (fun i => u i * v i)
        (fun j => reindex u j * v' j)
        (fun i => by simp [reindex, v'])
    _ = if v' = 0 then (1 : ℂ) else 0 := _root_.LIDT.MIPStarRE.LDT.Preliminaries.fourier_fact_vector v'
    _ = if v = 0 then (1 : ℂ) else 0 := by
      have reindex_zero : reindex (0 : ι → F) = 0 := by
        ext j
        rfl
      by_cases hv : v = 0
      · subst v
        rw [show v' = 0 by exact reindex_zero]
        simp
      · have hv' : v' ≠ 0 := by
          intro hv'
          apply hv
          apply reindex.injective
          rw [reindex_zero]
          exact hv'
        simp [hv, hv']

/-- Sum form of canonical-character orthogonality over an arbitrary finite
coordinate type. -/
theorem sum_ffChar_sum_mul (v : ι → F) :
    ∑ u : ι → F, _root_.LIDT.MIPStarRE.LDT.Preliminaries.ffChar (p := p) (F := F) (∑ i, u i * v i) =
      if v = 0 then (Fintype.card (ι → F) : ℂ) else 0 := by
  rw [← Fintype.card_smul_expect, _root_.LIDT.MIPStarRE.LDT.Preliminaries.expect_ffChar_sum_mul]
  by_cases hv : v = 0 <;> simp [hv]

end MIPStarRE.LDT.Preliminaries
end LIDT

namespace LIDT
namespace MIPStarRE.LDT.MakingMeasurementsProjective
open LIDT.MIPStarRE.LDT
noncomputable section

/-- The diagonal block of a bipartite operator at a fixed right index. -/
def diagBlock {ιA ιB : Type*}
    [Fintype ιA] [DecidableEq ιA] [Fintype ιB] [DecidableEq ιB]
    (M : _root_.LIDT.MIPStarRE.Quantum.Op (ιA × ιB)) (b : ιB) :
    _root_.LIDT.MIPStarRE.Quantum.Op ιA :=
  M.submatrix (fun i => (i, b)) (fun j => (j, b))

/-- The normalized left marginal of a bipartite density, obtained by
averaging its diagonal right blocks. -/
def leftMarginalDensity {ιA ιB : Type*}
    [Fintype ιA] [DecidableEq ιA] [Fintype ιB] [DecidableEq ιB] [Nonempty ιB]
    (ρ : _root_.LIDT.MIPStarRE.Quantum.Op (ιA × ιB)) : _root_.LIDT.MIPStarRE.Quantum.Op ιA :=
  ((((Fintype.card ιB : _root_.LIDT.MIPStarRE.LDT.Error) : _root_.LIDT.MIPStarRE.LDT.Error)⁻¹ : _root_.LIDT.MIPStarRE.LDT.Error) : ℂ) •
    ∑ b : ιB, _root_.LIDT.MIPStarRE.LDT.MakingMeasurementsProjective.diagBlock ρ b

/-- Positivity passes from a bipartite density to its left marginal. -/
private lemma leftMarginalDensity_nonneg {ιA ιB : Type*}
    [Fintype ιA] [DecidableEq ιA] [Fintype ιB] [DecidableEq ιB] [Nonempty ιB]
    {ρ : _root_.LIDT.MIPStarRE.Quantum.Op (ιA × ιB)} (hρ : 0 ≤ ρ) :
    0 ≤ _root_.LIDT.MIPStarRE.LDT.MakingMeasurementsProjective.leftMarginalDensity ρ := by
  have hρpsd : ρ.PosSemidef := Matrix.nonneg_iff_posSemidef.mp hρ
  have hsum : 0 ≤ ∑ b : ιB, _root_.LIDT.MIPStarRE.LDT.MakingMeasurementsProjective.diagBlock ρ b := by
    refine Finset.sum_nonneg fun b _ => ?_
    refine Matrix.nonneg_iff_posSemidef.mpr ?_
    simpa [_root_.LIDT.MIPStarRE.LDT.MakingMeasurementsProjective.diagBlock] using hρpsd.submatrix (fun i => (i, b))
  have hcoeff : 0 ≤ ((((Fintype.card ιB : _root_.LIDT.MIPStarRE.LDT.Error) : _root_.LIDT.MIPStarRE.LDT.Error)⁻¹ : _root_.LIDT.MIPStarRE.LDT.Error) : ℂ) := by
    positivity
  simpa [_root_.LIDT.MIPStarRE.LDT.MakingMeasurementsProjective.leftMarginalDensity] using smul_nonneg hcoeff hsum

/-- The local state on the left factor defined by the left marginal density
of a bipartite state. This formalization-only definition supports the
locality-preserving projectivization lemma and the explicit-constant form of
the orthonormalization lemma. -/
def leftMarginalState {ιA ιB : Type*}
    [Fintype ιA] [DecidableEq ιA] [Fintype ιB] [DecidableEq ιB] [Nonempty ιB]
    (ψ : _root_.LIDT.MIPStarRE.LDT.QuantumState (ιA × ιB)) : _root_.LIDT.MIPStarRE.LDT.QuantumState ιA where
  density := _root_.LIDT.MIPStarRE.LDT.MakingMeasurementsProjective.leftMarginalDensity ψ.density
  density_psd := by
    exact leftMarginalDensity_nonneg ψ.density_psd















end
end MIPStarRE.LDT.MakingMeasurementsProjective
end LIDT
Source
https://github.com/Dengnifer/MIPStarRE-QPBT/blob/8f4118aeea7be16912adbaee3df6dce1741a2c26/QPBT/Upstream.lean#L28-L247

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me