Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

QPBT definitions: Games / StrategyClasses

Definition
QPBT_QPBT_Games_StrategyClasses

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

qpbt

This bundle defines projective, symmetric, commuting, and consistent game strategies. It provides conversions between symmetric and ordinary games or strategies and packages the common-space commutation and measurement consistency predicates.

Principal definitions:

  • MIPStarRE.QPBT.SymmetricGame: a game with matching question and answer types and symmetric verification.
  • MIPStarRE.QPBT.SymmetricStrategy: a strategy using common local data for both players.
  • MIPStarRE.QPBT.IsCommutingOn: common-space commutation of measurement families.

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/Games/StrategyClasses.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_DistributionAvg
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_Basic_SubMeasurementCore
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_MakingMeasurementsProjective_NaimarkOneMeas
import Definitions.Def_LIDT_MIPStarRE_LDT_MakingMeasurementsProjective_Statements
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_Completion
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_Defs
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_FiniteMatrix_NormalizedTrace
import Definitions.Def_LIDT_MIPStarRE_Quantum_FiniteMatrix_Order
import Definitions.Def_LIDT_MIPStarRE_Quantum_Measurement
import Definitions.Def_QPBT_QPBT_Games_Defs
import Definitions.Def_QPBT_QPBT_State
import Theorems.Thm_LIDT_MIPStarRE_LDT_MakingMeasurementsProjective_OneMeasNaimarkData_compression_none_none
import Theorems.Thm_LIDT_MIPStarRE_LDT_MakingMeasurementsProjective_oneMeasNaimark

namespace LIDT.MIPStarRE.LDT
end LIDT.MIPStarRE.LDT
namespace LIDT.MIPStarRE.LDT.MakingMeasurementsProjective
end LIDT.MIPStarRE.LDT.MakingMeasurementsProjective
namespace LIDT.MIPStarRE.LDT.Preliminaries
end LIDT.MIPStarRE.LDT.Preliminaries
namespace LIDT.MIPStarRE.Quantum
end LIDT.MIPStarRE.Quantum
namespace MIPStarRE.QPBT
end MIPStarRE.QPBT
namespace MIPStarRE.QPBT.SymmetrizationObstruction
end MIPStarRE.QPBT.SymmetrizationObstruction

/-! # Strategy classes and symmetric games

This module defines projective, commuting, consistent, PCC, and SPCC strategy
predicates from blueprint `def:projective-strategy-general`,
`def:symmetric-game`, `def:comm-strategy`, `def:consistent-measurement`,
`def:consistent-strategy`, and `def:spcc`, with source definitions in
`references/qpbt-paper/06_nonlocal_games_and_mipstar.tex:68-180`.
-/
@[expose] public section
namespace MIPStarRE.QPBT

universe u

open scoped BigOperators Matrix MatrixOrder ComplexOrder

open LIDT.MIPStarRE.LDT LIDT.MIPStarRE.Quantum

/-- Projectivity from blueprint
`def:projective-strategy-general`, paper `06_nonlocal_games_and_mipstar.tex:68-72`. -/
def Strategy.IsProjective {G : _root_.MIPStarRE.QPBT.Game} (S : _root_.MIPStarRE.QPBT.Strategy G) : Prop :=
  (∀ x, _root_.MIPStarRE.QPBT.Measurement.IsProjective (S.A x)) ∧
    ∀ y, _root_.MIPStarRE.QPBT.Measurement.IsProjective (S.B y)

/-- Symmetric games from blueprint
`def:symmetric-game`, paper `06_nonlocal_games_and_mipstar.tex:74-92`.
The question and answer alphabets are each represented by a single shared type,
matching the source notation. -/
structure SymmetricGame where
  Question : Type
  Answer : Type
  [questionFintype : Fintype Question]
  [answerFintype : Fintype Answer]
  [questionDecidableEq : DecidableEq Question]
  [answerDecidableEq : DecidableEq Answer]
  μ : _root_.LIDT.MIPStarRE.LDT.Distribution (Question × Question)
  μ_prob : μ.IsProbability
  μ_symm : ∀ x y, μ.weight (x, y) = μ.weight (y, x)
  decide : Question → Question → Answer → Answer → Bool
  decide_symm : ∀ x y a b, decide x y a b = decide y x b a

attribute [instance] _root_.MIPStarRE.QPBT.SymmetricGame.questionFintype _root_.MIPStarRE.QPBT.SymmetricGame.answerFintype
  _root_.MIPStarRE.QPBT.SymmetricGame.questionDecidableEq _root_.MIPStarRE.QPBT.SymmetricGame.answerDecidableEq

/-- Regard a symmetric game as a game with equal question and answer types;
blueprint
`def:symmetric-game`, paper `06_nonlocal_games_and_mipstar.tex:74-92`. -/
def SymmetricGame.toGame (G : _root_.MIPStarRE.QPBT.SymmetricGame) : _root_.MIPStarRE.QPBT.Game where
  QuestionA := G.Question
  QuestionB := G.Question
  AnswerA := G.Answer
  AnswerB := G.Answer
  μ := G.μ
  μ_prob := G.μ_prob
  decide := G.decide

/-- Symmetric strategies from blueprint
`def:symmetric-game`, paper `06_nonlocal_games_and_mipstar.tex:74-92`.
The two local spaces and measurement families are identified, as in the source
definition. -/
structure SymmetricStrategy (G : _root_.MIPStarRE.QPBT.SymmetricGame) where
  ι : Type
  [ιFintype : Fintype ι]
  [ιDecidableEq : DecidableEq ι]
  ψ : EuclideanSpace ℂ (ι × ι)
  ψ_norm : ‖ψ‖ = 1
  ψ_swap : _root_.MIPStarRE.QPBT.reindexState (Equiv.prodComm ι ι) ψ = ψ
  M : G.Question → _root_.LIDT.MIPStarRE.Quantum.Measurement G.Answer ι

attribute [instance] _root_.MIPStarRE.QPBT.SymmetricStrategy.ιFintype _root_.MIPStarRE.QPBT.SymmetricStrategy.ιDecidableEq

/-- Regard a symmetric strategy as a strategy using the same local space and
measurement family for both players; blueprint
`def:symmetric-game`, paper `06_nonlocal_games_and_mipstar.tex:74-92`. -/
def SymmetricStrategy.toStrategy {G : _root_.MIPStarRE.QPBT.SymmetricGame} (S : _root_.MIPStarRE.QPBT.SymmetricStrategy G) :
    _root_.MIPStarRE.QPBT.Strategy G.toGame where
  ιA := S.ι
  ιB := S.ι
  ψ := S.ψ
  ψ_norm := S.ψ_norm
  A := S.M
  B := S.M

/-- Common-space commutation from blueprint
`def:comm-strategy`, paper `06_nonlocal_games_and_mipstar.tex:132-142`. -/
def IsCommutingOn {X Y α β ι : Type*}
    [Fintype X] [DecidableEq X] [Fintype Y] [DecidableEq Y]
    [Fintype α] [DecidableEq α] [Fintype β]
    [DecidableEq β] [Fintype ι] [DecidableEq ι]
    (μ : _root_.LIDT.MIPStarRE.LDT.Distribution (X × Y))
    (A : X → _root_.LIDT.MIPStarRE.Quantum.Measurement α ι)
    (B : Y → _root_.LIDT.MIPStarRE.Quantum.Measurement β ι) : Prop :=
  ∀ x y, 0 < μ.weight (x, y) → ∀ a b, Commute ((A x).effect a) ((B y).effect b)





/-- Measurement consistency from blueprint
`def:consistent-measurement`, paper `06_nonlocal_games_and_mipstar.tex:144-160`. -/
def Measurement.IsConsistentOn {α ι : Type*}
    [Fintype α] [DecidableEq α] [Fintype ι] [DecidableEq ι]
    (M : _root_.LIDT.MIPStarRE.Quantum.Measurement α ι)
    (ψ : EuclideanSpace ℂ (ι × ι)) : Prop :=
  ∀ a, (_root_.MIPStarRE.QPBT.heteroKron (M.effect a) 1).mulVec ψ =
    (_root_.MIPStarRE.QPBT.heteroKron 1 (M.effect a)).mulVec ψ



/-- Symmetric strategy consistency from blueprint
`def:consistent-strategy`, paper `06_nonlocal_games_and_mipstar.tex:162-174`. -/
def SymmetricStrategy.IsConsistent {G : _root_.MIPStarRE.QPBT.SymmetricGame}
    (S : _root_.MIPStarRE.QPBT.SymmetricStrategy G) : Prop :=
  ∀ x, _root_.MIPStarRE.QPBT.Measurement.IsConsistentOn (S.M x) S.ψ



/-- The SPCC predicate blueprint `def:spcc`,
paper `06_nonlocal_games_and_mipstar.tex:176-180`. -/
def SymmetricStrategy.IsSPCC {G : _root_.MIPStarRE.QPBT.SymmetricGame}
  (S : _root_.MIPStarRE.QPBT.SymmetricStrategy G) : Prop :=
  (∀ x, _root_.MIPStarRE.QPBT.Measurement.IsProjective (S.M x)) ∧ S.IsConsistent ∧
    _root_.MIPStarRE.QPBT.IsCommutingOn G.μ S.M S.M

noncomputable section

open LIDT.MIPStarRE.LDT.MakingMeasurementsProjective
open LIDT.MIPStarRE.LDT.Preliminaries

/-- The real quadratic form of an operator evaluated on a finite vector. This
is the Born expression averaged by blueprint
`def:tensor-product-value`, paper origin
`references/qpbt-paper/06_nonlocal_games_and_mipstar.tex:40-48`. -/
def vectorQForm {I : Type*} [Fintype I] [DecidableEq I]
    (ψ : EuclideanSpace ℂ I) (A : _root_.LIDT.MIPStarRE.Quantum.Op I) : ℝ :=
  (inner ℂ ψ (Matrix.toEuclideanLin A ψ)).re

/-- Embed a bipartite state into one distinguished coordinate of each local
ancilla space, extending it by zero elsewhere. This is the zero padding used by
the dilations of blueprint
`def:projective-strategy-general`, and of blueprint
`lem:projective-strategy-setup`, paper
`references/qpbt-paper/14_analysis_of_the_pauli_basis_test.tex:155-172`. -/
def padState
    {I J κA κB : Type*} [Fintype I] [DecidableEq I]
    [Fintype J] [DecidableEq J] [Fintype κA] [DecidableEq κA]
    [Fintype κB] [DecidableEq κB]
    (aA : κA) (bB : κB) (ψ : EuclideanSpace ℂ (I × J)) :
    EuclideanSpace ℂ ((I × κA) × (J × κB)) :=
  (EuclideanSpace.equiv ((I × κA) × (J × κB)) ℂ).symm
    (fun p => if p.1.2 = aA then
      if p.2.2 = bB then ψ.ofLp (p.1.1, p.2.1) else 0 else 0)

/-- Padding a state at the two distinguished ancilla coordinates preserves its
norm. -/
theorem padState_norm
    {I J κA κB : Type*} [Fintype I] [DecidableEq I]
    [Fintype J] [DecidableEq J] [Fintype κA] [DecidableEq κA]
    [Fintype κB] [DecidableEq κB]
    (aA : κA) (bB : κB) (ψ : EuclideanSpace ℂ (I × J)) :
    ‖_root_.MIPStarRE.QPBT.padState aA bB ψ‖ = ‖ψ‖ := by
  apply (sq_eq_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
  rw [EuclideanSpace.norm_sq_eq, EuclideanSpace.norm_sq_eq]
  simp only [_root_.MIPStarRE.QPBT.padState, Fintype.sum_prod_type]
  apply Finset.sum_congr rfl
  intro i _
  rw [Finset.sum_eq_single aA]
  · apply Finset.sum_congr rfl
    intro j _
    rw [Finset.sum_eq_single bB]
    · simp
    · intro b _ hb
      simp [hb]
    · intro h
      exact (h (Finset.mem_univ _)).elim
  · intro a _ ha
    simp [ha]
  · intro h
    exact (h (Finset.mem_univ _)).elim

/-- The quadratic form of a padded state depends only on the compression of
each local operator at the distinguished ancilla coordinate. -/
theorem stateQForm_padState
    {I J κA κB : Type*} [Fintype I] [DecidableEq I]
    [Fintype J] [DecidableEq J] [Fintype κA] [DecidableEq κA]
    [Fintype κB] [DecidableEq κB]
    (aA : κA) (bB : κB) (ψ : EuclideanSpace ℂ (I × J))
    (A : _root_.LIDT.MIPStarRE.Quantum.Op I) (B : _root_.LIDT.MIPStarRE.Quantum.Op J) (A' : _root_.LIDT.MIPStarRE.Quantum.Op (I × κA)) (B' : _root_.LIDT.MIPStarRE.Quantum.Op (J × κB))
    (hA : ∀ i j, A' (i, aA) (j, aA) = A i j)
    (hB : ∀ i j, B' (i, bB) (j, bB) = B i j) :
    _root_.MIPStarRE.QPBT.vectorQForm (_root_.MIPStarRE.QPBT.padState aA bB ψ) (_root_.MIPStarRE.QPBT.heteroKron A' B') =
      _root_.MIPStarRE.QPBT.vectorQForm ψ (_root_.MIPStarRE.QPBT.heteroKron A B) := by
  unfold _root_.MIPStarRE.QPBT.vectorQForm
  apply congrArg Complex.re
  rw [EuclideanSpace.inner_eq_star_dotProduct,
    EuclideanSpace.inner_eq_star_dotProduct]
  change (∑ p : (I × κA) × (J × κB),
      (∑ q : (I × κA) × (J × κB),
        _root_.MIPStarRE.QPBT.heteroKron A' B' p q * (_root_.MIPStarRE.QPBT.padState aA bB ψ).ofLp q) *
        star (_root_.MIPStarRE.QPBT.padState aA bB ψ).ofLp p) =
    (∑ p : I × J,
      (∑ q : I × J, _root_.MIPStarRE.QPBT.heteroKron A B p q * ψ.ofLp q) * star ψ.ofLp p)
  suffices hExpanded :
      (∑ i : I, ∑ a : κA, ∑ j : J, ∑ b : κB,
        (∑ k : I, ∑ l : J,
          A' (i, a) (k, aA) * B' (j, b) (l, bB) * ψ.ofLp (k, l)) *
            star (if a = aA then if b = bB then ψ.ofLp (i, j) else 0 else 0)) =
        ∑ i : I, ∑ j : J,
          (∑ k : I, ∑ l : J, A i k * B j l * ψ.ofLp (k, l)) *
            star (ψ.ofLp (i, j)) by
    simpa [_root_.MIPStarRE.QPBT.padState, _root_.MIPStarRE.QPBT.heteroKron, Matrix.kronecker,
      Fintype.sum_prod_type] using hExpanded
  apply Finset.sum_congr rfl
  intro i _
  rw [Finset.sum_eq_single aA]
  · apply Finset.sum_congr rfl
    intro j _
    rw [Finset.sum_eq_single bB]
    · simp_rw [hA, hB]
      simp
    · intro b _ hb
      simp [hb]
    · intro h
      exact (h (Finset.mem_univ _)).elim
  · intro a _ ha
    simp [ha]
  · intro h
    exact (h (Finset.mem_univ _)).elim

/-- Choose the one-measurement Naimark dilation data for a POVM. -/
def oneMeasData
    {α I : Type} [Fintype α] [DecidableEq α]
    [Fintype I] [DecidableEq I]
    (M : _root_.LIDT.MIPStarRE.Quantum.Measurement α I) : _root_.LIDT.MIPStarRE.LDT.MakingMeasurementsProjective.OneMeasNaimarkData α I :=
  Classical.choose (_root_.LIDT.MIPStarRE.LDT.MakingMeasurementsProjective.oneMeasNaimark M.toSubmeasurement)

/-- The source submeasurement of the chosen Naimark data is the original POVM. -/
theorem oneMeasData_source_effect
    {α I : Type} [Fintype α] [DecidableEq α]
    [Fintype I] [DecidableEq I]
    (M : _root_.LIDT.MIPStarRE.Quantum.Measurement α I) :
    (_root_.MIPStarRE.QPBT.oneMeasData M).source.effect = M.effect := by
  exact congrArg _root_.LIDT.MIPStarRE.Quantum.Submeasurement.effect
    (Classical.choose_spec (_root_.LIDT.MIPStarRE.LDT.MakingMeasurementsProjective.oneMeasNaimark M.toSubmeasurement))

/-- Complete the Naimark projectors at one outcome to obtain a projective POVM. -/
def dilatedMeasurement
    {α I : Type} [Fintype α] [DecidableEq α]
    [Fintype I] [DecidableEq I]
    (a₀ : α) (M : _root_.LIDT.MIPStarRE.Quantum.Measurement α I) :
    _root_.LIDT.MIPStarRE.Quantum.Measurement α (I × Option α) :=
  let P := _root_.LIDT.MIPStarRE.LDT.Preliminaries.completeAtOutcomeProj (_root_.MIPStarRE.QPBT.oneMeasData M).toProjSubMeas a₀
  _root_.LIDT.MIPStarRE.Quantum.Measurement.ofSumEqOne P.outcome P.outcome_pos <| by
    rw [P.sum_eq_total, P.total_eq_one]

/-- Every effect of the completed Naimark measurement is a projection. -/
theorem dilatedMeasurement_isProjective
    {α I : Type} [Fintype α] [DecidableEq α]
    [Fintype I] [DecidableEq I]
    (a₀ : α) (M : _root_.LIDT.MIPStarRE.Quantum.Measurement α I) :
    _root_.MIPStarRE.QPBT.Measurement.IsProjective (_root_.MIPStarRE.QPBT.dilatedMeasurement a₀ M) := by
  intro a
  let P := _root_.LIDT.MIPStarRE.LDT.Preliminaries.completeAtOutcomeProj (_root_.MIPStarRE.QPBT.oneMeasData M).toProjSubMeas a₀
  change _root_.LIDT.MIPStarRE.Quantum.IsProj (P.outcome a)
  exact
    { isIdempotentElem := P.proj a
      isSelfAdjoint :=
        (Matrix.nonneg_iff_posSemidef.mp (P.outcome_pos a)).isHermitian.eq }

/-- Compressing a completed Naimark effect to the distinguished ancilla
coordinate recovers the original POVM effect. -/
theorem dilatedMeasurement_compression
    {α I : Type} [Fintype α] [DecidableEq α]
    [Fintype I] [DecidableEq I]
    (a₀ a : α) (M : _root_.LIDT.MIPStarRE.Quantum.Measurement α I) (i j : I) :
    (_root_.MIPStarRE.QPBT.dilatedMeasurement a₀ M).effect a (i, none) (j, none) = M.effect a i j := by
  let D := _root_.MIPStarRE.QPBT.oneMeasData M
  let P := D.toProjSubMeas
  have hcompress (b : α) : P.outcome b (i, none) (j, none) = M.effect b i j := by
    change D.liftedEffect (some b) (i, none) (j, none) = M.effect b i j
    rw [D.compression_none_none]
    exact congrArg (fun X : _root_.LIDT.MIPStarRE.Quantum.Op I => X i j)
      (congrFun (_root_.MIPStarRE.QPBT.oneMeasData_source_effect M) b)
  have htotal : P.total (i, none) (j, none) = (1 : _root_.LIDT.MIPStarRE.Quantum.Op I) i j := by
    rw [← P.sum_eq_total]
    simp_rw [Matrix.sum_apply, hcompress]
    simpa [Matrix.sum_apply] using congrArg (fun X : _root_.LIDT.MIPStarRE.Quantum.Op I => X i j) M.sum_eq_one
  simp only [_root_.MIPStarRE.QPBT.dilatedMeasurement, _root_.LIDT.MIPStarRE.Quantum.Measurement.ofSumEqOne]
  change ((_root_.LIDT.MIPStarRE.LDT.Preliminaries.completeAtOutcomeProj P a₀).toMeasurement).outcome a
      (i, none) (j, none) = M.effect a i j
  rw [_root_.LIDT.MIPStarRE.LDT.Preliminaries.completeAtOutcomeProj_toMeasurement]
  simp only [_root_.LIDT.MIPStarRE.LDT.Preliminaries.completeAtOutcome]
  by_cases ha : a = a₀
  · subst a
    rw [dif_pos rfl]
    rw [Matrix.add_apply, hcompress, Matrix.sub_apply, Matrix.one_apply, htotal]
    by_cases hij : i = j <;> simp [hij, Matrix.one_apply]
  · rw [dif_neg ha]
    exact hcompress a





/-- Replace both local measurement families of a strategy by families on the
enlarged local registers and pad the state at the distinguished ancilla
coordinates. This is the dilation step shared by
blueprint `def:projective-strategy-general`, and
blueprint
`lem:projective-strategy-setup`. -/
@[reducible] def paddedStrategy {G : _root_.MIPStarRE.QPBT.Game} (S : _root_.MIPStarRE.QPBT.Strategy G) {κA κB : Type}
    [Fintype κA] [DecidableEq κA] [Fintype κB] [DecidableEq κB]
    (aA : κA) (bB : κB)
    (A' : G.QuestionA → _root_.LIDT.MIPStarRE.Quantum.Measurement G.AnswerA (S.ιA × κA))
    (B' : G.QuestionB → _root_.LIDT.MIPStarRE.Quantum.Measurement G.AnswerB (S.ιB × κB)) :
    _root_.MIPStarRE.QPBT.Strategy G where
  ιA := S.ιA × κA
  ιB := S.ιB × κB
  ψ := _root_.MIPStarRE.QPBT.padState aA bB S.ψ
  ψ_norm := (_root_.MIPStarRE.QPBT.padState_norm aA bB S.ψ).trans S.ψ_norm
  A := A'
  B := B'

/-- The padded strategy is projective as soon as both enlarged families are. -/
theorem paddedStrategy_isProjective {G : _root_.MIPStarRE.QPBT.Game} (S : _root_.MIPStarRE.QPBT.Strategy G) {κA κB : Type}
    [Fintype κA] [DecidableEq κA] [Fintype κB] [DecidableEq κB]
    (aA : κA) (bB : κB)
    (A' : G.QuestionA → _root_.LIDT.MIPStarRE.Quantum.Measurement G.AnswerA (S.ιA × κA))
    (B' : G.QuestionB → _root_.LIDT.MIPStarRE.Quantum.Measurement G.AnswerB (S.ιB × κB))
    (hA : ∀ x, _root_.MIPStarRE.QPBT.Measurement.IsProjective (A' x))
    (hB : ∀ y, _root_.MIPStarRE.QPBT.Measurement.IsProjective (B' y)) :
    (_root_.MIPStarRE.QPBT.paddedStrategy S aA bB A' B').IsProjective :=
  ⟨fun x => hA x, fun y => hB y⟩

/-- Local dilation and padding preserve every game correlation, hence the
strategy value, as soon as each enlarged family compresses to the original one
at the distinguished ancilla coordinate. -/
theorem paddedStrategy_value {G : _root_.MIPStarRE.QPBT.Game} (S : _root_.MIPStarRE.QPBT.Strategy G) {κA κB : Type}
    [Fintype κA] [DecidableEq κA] [Fintype κB] [DecidableEq κB]
    (aA : κA) (bB : κB)
    (A' : G.QuestionA → _root_.LIDT.MIPStarRE.Quantum.Measurement G.AnswerA (S.ιA × κA))
    (B' : G.QuestionB → _root_.LIDT.MIPStarRE.Quantum.Measurement G.AnswerB (S.ιB × κB))
    (hA : ∀ x a i j, (A' x).effect a (i, aA) (j, aA) = (S.A x).effect a i j)
    (hB : ∀ y b i j, (B' y).effect b (i, bB) (j, bB) = (S.B y).effect b i j) :
    (_root_.MIPStarRE.QPBT.paddedStrategy S aA bB A' B').value = S.value := by
  unfold _root_.MIPStarRE.QPBT.Strategy.value
  apply _root_.LIDT.MIPStarRE.LDT.avgOver_congr
  intro xy
  apply Finset.sum_congr rfl
  intro a _
  apply Finset.sum_congr rfl
  intro b _
  by_cases hw : G.decide xy.1 xy.2 a b
  · simp only [hw, if_true]
    exact _root_.MIPStarRE.QPBT.stateQForm_padState aA bB S.ψ ((S.A xy.1).effect a)
      ((S.B xy.2).effect b) ((A' xy.1).effect a) ((B' xy.2).effect b)
      (hA xy.1 a) (hB xy.2 b)
  · simp [hw]










/-- Transport a POVM along an equivalence of its finite coordinate type. -/
noncomputable def reindexMeasurement
    {α I J : Type*} [Fintype α]
    [Fintype I] [DecidableEq I] [Fintype J] [DecidableEq J]
    (e : I ≃ J) (M : _root_.LIDT.MIPStarRE.Quantum.Measurement α J) :
    _root_.LIDT.MIPStarRE.Quantum.Measurement α I :=
  _root_.LIDT.MIPStarRE.Quantum.Measurement.ofSumEqOne
    (fun a => _root_.MIPStarRE.QPBT.reindexOp e (M.effect a))
    (fun a => _root_.LIDT.MIPStarRE.Quantum.reindex_nonneg e.symm (M.pos a))
    (by
      change ∑ a : α, (Matrix.reindexAlgEquiv ℂ ℂ e.symm) (M.effect a) = 1
      rw [← map_sum, M.sum_eq_one, map_one])






































end

end MIPStarRE.QPBT
Source
https://github.com/Dengnifer/MIPStarRE-QPBT/blob/8f4118aeea7be16912adbaee3df6dce1741a2c26/QPBT/Games/StrategyClasses.lean#L26-L490

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