Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

QPBT definitions: Combining / Defs

Definition
QPBT_QPBT_Combining_Defs

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

qpbt

This bundle defines the coordinate layout and polynomial map used to combine two bounded individual-degree polynomials into one extended polynomial. The extended coordinates contain separate blocks for the two inputs and two scalar mixing variables.

Principal definitions:

  • MIPStarRE.QPBT.Poly: the bounded individual-degree polynomial outcome used by the global pair measurement.
  • MIPStarRE.QPBT.PolyPair: a pair of such polynomial representatives.
  • MIPStarRE.QPBT.finCombineEquiv: the equivalence separating the extended coordinates into the first block, second block, and two scalar coordinates.
  • MIPStarRE.QPBT.embX: embeds the first polynomial block into the extended coordinate set.
  • MIPStarRE.QPBT.embZ: embeds the second polynomial block into the extended coordinate set.
  • MIPStarRE.QPBT.alphaVar: the extended coordinate carrying the first scalar coefficient.
  • MIPStarRE.QPBT.betaVar: the extended coordinate carrying the second scalar coefficient.
  • MIPStarRE.QPBT.combinePoly: the polynomial αf(x)+βg(z)\alpha f(x)+\beta g(z)αf(x)+βg(z) in the extended coordinates.

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/Combining/Defs.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_Polynomials
import Definitions.Def_LIDT_MIPStarRE_LDT_Tactic_AvgCongr
import Definitions.Def_LIDT_MIPStarRE_LDT_Test_StrategyCore
import Definitions.Def_QPBT_QPBT_Algebra_Coefficients
import Definitions.Def_QPBT_QPBT_Algebra_FieldBasis
import Definitions.Def_QPBT_QPBT_Algebra_Pauli
import Definitions.Def_QPBT_QPBT_Games_CondLinear
import Definitions.Def_QPBT_QPBT_Games_DistributionAux
import Definitions.Def_QPBT_QPBT_Observables_LineDefs
import Definitions.Def_QPBT_QPBT_Test_LowDegreeGame
import Definitions.Def_QPBT_QPBT_Test_PauliBasisTest
import Mathlib

namespace LIDT.MIPStarRE.LDT
end LIDT.MIPStarRE.LDT
namespace LIDT.MIPStarRE.LDT.Preliminaries
end LIDT.MIPStarRE.LDT.Preliminaries
namespace MIPStarRE.QPBT
end MIPStarRE.QPBT

/-!
# Polynomial combination and restricted line distributions

This file contains the concrete definitions at the foundation of the
Chapter 15 combining argument.  A pair of bounded individual-degree
polynomials is embedded into the two coordinate blocks of an extended
polynomial.  On lines, explicit affine reparameterizations are composed with
coefficient-list polynomials.  The original-dimensional restricted line laws
are formed before decoding, while their field seed is still present.

## References

The combining map is blueprint
`def:combine-map`, with paper origin
`references/qpbt-paper/14_analysis_of_the_pauli_basis_test.tex:970-989`.
The restricted laws are blueprint `def:ith-restricted-line`,
with paper origin in the same source at lines 1038--1048.
-/

@[expose] public section

open scoped BigOperators

namespace MIPStarRE.QPBT

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

noncomputable section

/-- The bounded individual-degree polynomial outcome used by the global
pair measurement.  This is the actual `polyFunc` subtype from
`def:polyfunc`, not a coefficient-box replacement. -/
noncomputable abbrev Poly (P : _root_.MIPStarRE.QPBT.AdmissibleParams) :=
  ↥(_root_.LIDT.MIPStarRE.LDT.Preliminaries.polyFunc P.m (_root_.MIPStarRE.QPBT.PauliScalar P) P.d)

/-- Pairs of bounded polynomial representatives returned by the global
measurement in `lem:qld-4-7`. -/
noncomputable abbrev PolyPair (P : _root_.MIPStarRE.QPBT.AdmissibleParams) := _root_.MIPStarRE.QPBT.Poly P × _root_.MIPStarRE.QPBT.Poly P

/-- This equivalence decomposes the extended coordinate set into the `X` block,
    the `Z` block, and the two scalar coordinates.  It supports blueprint
`def:combine-map`, paper
`references/qpbt-paper/14_analysis_of_the_pauli_basis_test.tex:970-989`. -/
def finCombineEquiv (m : ℕ) :
    Fin (2 * m + 2) ≃ ((Fin m ⊕ Fin m) ⊕ Fin 2) :=
  (finCongr (by omega)).trans
    (finSumFinEquiv.symm.trans
      (Equiv.sumCongr finSumFinEquiv.symm (Equiv.refl (Fin 2))))

/-- Embed an `X`-block coordinate into the extended coordinate set. -/
def embX (m : ℕ) : Fin m → Fin (2 * m + 2) :=
  fun i => (_root_.MIPStarRE.QPBT.finCombineEquiv m).symm (.inl (.inl i))

/-- Embed a `Z`-block coordinate into the extended coordinate set. -/
def embZ (m : ℕ) : Fin m → Fin (2 * m + 2) :=
  fun i => (_root_.MIPStarRE.QPBT.finCombineEquiv m).symm (.inl (.inr i))

/-- The extended coordinate occupied by the scalar `alpha`. -/
def alphaVar (m : ℕ) : Fin (2 * m + 2) :=
  (_root_.MIPStarRE.QPBT.finCombineEquiv m).symm (.inr 0)

/-- The extended coordinate occupied by the scalar `beta`. -/
def betaVar (m : ℕ) : Fin (2 * m + 2) :=
  (_root_.MIPStarRE.QPBT.finCombineEquiv m).symm (.inr 1)

/-- Project an extended point onto its `X` coordinate block. -/
def projX {K : Type*} {m : ℕ} (u : Fin (2 * m + 2) → K) : Fin m → K :=
  fun i => u (_root_.MIPStarRE.QPBT.embX m i)

/-- Project an extended point onto its `Z` coordinate block. -/
def projZ {K : Type*} {m : ℕ} (u : Fin (2 * m + 2) → K) : Fin m → K :=
  fun i => u (_root_.MIPStarRE.QPBT.embZ m i)

/-- Combine two multivariate polynomials by the formula
`alpha * f(x) + beta * g(z)` from `def:combine-map`.

Blueprint `def:combine-map`; paper
`references/qpbt-paper/14_analysis_of_the_pauli_basis_test.tex:970-983`. -/
noncomputable def combinePoly {K : Type*} [CommSemiring K] {m : ℕ}
    (f g : MvPolynomial (Fin m) K) : MvPolynomial (Fin (2 * m + 2)) K :=
  MvPolynomial.X (_root_.MIPStarRE.QPBT.alphaVar m) * MvPolynomial.rename (_root_.MIPStarRE.QPBT.embX m) f +
    MvPolynomial.X (_root_.MIPStarRE.QPBT.betaVar m) * MvPolynomial.rename (_root_.MIPStarRE.QPBT.embZ m) g



/-- A fresh variable times an injectively renamed bounded polynomial retains
the same individual-degree bound.  This is a formalization-only auxiliary for
`def:combine-map`, paper
`references/qpbt-paper/14_analysis_of_the_pauli_basis_test.tex:970-983`. -/
private theorem x_mul_rename_mem_polyFunc {K : Type*} [CommSemiring K]
    {m n d : ℕ} (hd : 1 ≤ d) {e : Fin m → Fin n} (he : Function.Injective e)
    {a : Fin n} (ha : ∀ i, e i ≠ a) {p : MvPolynomial (Fin m) K}
    (hp : p ∈ _root_.LIDT.MIPStarRE.LDT.Preliminaries.polyFunc m K d) :
    MvPolynomial.X a * MvPolynomial.rename e p ∈ _root_.LIDT.MIPStarRE.LDT.Preliminaries.polyFunc n K d := by
  classical
  have hrenOutside {j : Fin n} (hj : j ∉ Set.range e) :
      (MvPolynomial.rename e p).degreeOf j = 0 := by
    apply Nat.le_zero.mp
    rw [MvPolynomial.degreeOf_le_iff]
    intro s hs
    rw [MvPolynomial.support_rename_of_injective he] at hs
    obtain ⟨t, _, rfl⟩ := Finset.mem_image.mp hs
    simp [Finsupp.mapDomain_notin_range _ _ hj]
  have hrenAll (j : Fin n) : (MvPolynomial.rename e p).degreeOf j ≤ d := by
    by_cases hj : j ∈ Set.range e
    · obtain ⟨i, rfl⟩ := hj
      rw [MvPolynomial.degreeOf_rename_of_injective he]
      exact _root_.LIDT.MIPStarRE.LDT.Preliminaries.degreeOf_le_of_mem_polyFunc hp i
    · rw [hrenOutside hj]
      exact Nat.zero_le d
  have haRange : a ∉ Set.range e := by
    rintro ⟨i, hi⟩
    exact ha i hi
  refine (MvPolynomial.mem_restrictDegree _ _ _).mpr ?_
  intro s hs j
  refine MvPolynomial.degreeOf_le_iff.mp ?_ s hs
  by_cases hj : j = a
  · subst j
    rw [mul_comm]
    exact (MvPolynomial.degreeOf_mul_X_self a _).trans (by
      rw [hrenOutside haRange]
      omega)
  · rw [mul_comm, MvPolynomial.degreeOf_mul_X_of_ne _ hj]
    exact hrenAll j

/-- The combining polynomial has individual degree at most `d` when
`hd : 1 ≤ d`.  The coordinate blocks are disjoint: `f` depends only on the
`x` variables and `g` only on the `z` variables, so multiplication by `alpha`
or `beta` preserves the degree bound on those old coordinates and gives degree
one only in the corresponding fresh coordinate.  Thus `hd` supplies exactly
the needed bound on the two fresh coordinates; no `d + 1` bound is introduced.
The statement is the well-definedness assertion in
blueprint
`def:combine-map`, with source context
`references/qpbt-paper/14_analysis_of_the_pauli_basis_test.tex:970-983` and the
boundary-hypothesis discussion in `docs/paper-gaps/qpbt_ld-dimension-divisibility.tex`.
-/
theorem combinePoly_mem_polyFunc {K : Type*} [CommSemiring K] {m d : ℕ}
    (hd : 1 ≤ d) {f g : MvPolynomial (Fin m) K}
    (hf : f ∈ _root_.LIDT.MIPStarRE.LDT.Preliminaries.polyFunc m K d) (hg : g ∈ _root_.LIDT.MIPStarRE.LDT.Preliminaries.polyFunc m K d) :
    _root_.MIPStarRE.QPBT.combinePoly f g ∈ _root_.LIDT.MIPStarRE.LDT.Preliminaries.polyFunc (2 * m + 2) K d := by
  have hsymm : Function.Injective (_root_.MIPStarRE.QPBT.finCombineEquiv m).symm :=
    (_root_.MIPStarRE.QPBT.finCombineEquiv m).symm.injective
  have hX : Function.Injective (_root_.MIPStarRE.QPBT.embX m) := by
    intro i j hij
    simpa using hsymm hij
  have hZ : Function.Injective (_root_.MIPStarRE.QPBT.embZ m) := by
    intro i j hij
    simpa using hsymm hij
  have haX : ∀ i, _root_.MIPStarRE.QPBT.embX m i ≠ _root_.MIPStarRE.QPBT.alphaVar m := by
    intro i hi
    simpa using hsymm hi
  have haZ : ∀ i, _root_.MIPStarRE.QPBT.embZ m i ≠ _root_.MIPStarRE.QPBT.betaVar m := by
    intro i hi
    simpa using hsymm hi
  exact Submodule.add_mem _ (x_mul_rename_mem_polyFunc hd hX haX hf)
    (x_mul_rename_mem_polyFunc hd hZ haZ hg)

/-- Evaluate one member of a global polynomial pair at a point, selecting the
component by Pauli basis.  This is formalization-only support for
`lem:qld-4-7`, paper
`references/qpbt-paper/14_analysis_of_the_pauli_basis_test.tex:1267-1274`. -/
def evalAt {P : _root_.MIPStarRE.QPBT.AdmissibleParams} (W : _root_.MIPStarRE.QPBT.PauliKind)
    (u : Fin P.m → _root_.MIPStarRE.QPBT.PauliScalar P) (pair : _root_.MIPStarRE.QPBT.PolyPair P) : _root_.MIPStarRE.QPBT.PauliScalar P :=
  match W with
  | .X => MvPolynomial.eval u pair.1.1
  | .Z => MvPolynomial.eval u pair.2.1

/-- The univariate polynomial before coefficient extraction in
`combineLinePoly`.  The four first scalars describe the affine parameters on
the two projected lines; the last four are the affine `alpha` and `beta`
coordinates of the extended line. -/
noncomputable def combineLinePolynomial {K : Type*} [CommSemiring K] {c : ℕ}
    (aX bX aZ bZ uα vα uβ vβ : K)
    (f g : Fin (c + 1) → K) : Polynomial K :=
  (Polynomial.C uα + Polynomial.C vα * Polynomial.X) *
      (_root_.MIPStarRE.QPBT.linePolynomialOfCoefficients f).comp
        (Polynomial.C aX + Polynomial.C bX * Polynomial.X) +
    (Polynomial.C uβ + Polynomial.C vβ * Polynomial.X) *
      (_root_.MIPStarRE.QPBT.linePolynomialOfCoefficients g).comp
        (Polynomial.C aZ + Polynomial.C bZ * Polynomial.X)



/-- Combine two degree-`c` line polynomials using explicit affine
reparameterizations.  Coefficients through degree `c + 1` are extracted from
the genuine composed polynomial, so the definition has no incompatibility
fallback.

This is Equation `eq:combine-lines` in blueprint
`def:combine-map`, paper
`references/qpbt-paper/14_analysis_of_the_pauli_basis_test.tex:984-989`. -/
noncomputable def combineLinePoly {K : Type*} [CommSemiring K] {c : ℕ}
    (aX bX aZ bZ uα vα uβ vβ : K)
    (f g : Fin (c + 1) → K) : Fin (c + 1 + 1) → K :=
  fun i => (_root_.MIPStarRE.QPBT.combineLinePolynomial aX bX aZ bZ uα vα uβ vβ f g).coeff i.val

/-- Compatibility of an extended line with two projected lines and their
explicit affine parameters. These data witness the projection-inclusion
condition preceding Equation `eq:combine-lines`. The theorem
`exists_isCombineLineCompatible_of_projection_mem` in `Combining/LinePolynomial.lean`
constructs them from that condition, including zero directions. Compatibility
alone does not make every coefficient answer a function on a singleton line;
see issue Dengnifer/MIPStarRE-QPBT-bak#695. -/
def IsCombineLineCompatible {K : Type*} [Field K] {m : ℕ}
    (u v : Fin (2 * m + 2) → K)
    (uX vX uZ vZ : Fin m → K)
    (aX bX aZ bZ uα vα uβ vβ : K) : Prop :=
  u (_root_.MIPStarRE.QPBT.alphaVar m) = uα ∧ v (_root_.MIPStarRE.QPBT.alphaVar m) = vα ∧
    u (_root_.MIPStarRE.QPBT.betaVar m) = uβ ∧ v (_root_.MIPStarRE.QPBT.betaVar m) = vβ ∧
    ∀ t : K,
      _root_.MIPStarRE.QPBT.projX (u + t • v) = uX + (aX + bX * t) • vX ∧
        _root_.MIPStarRE.QPBT.projZ (u + t • v) = uZ + (aZ + bZ * t) • vZ



/-- The seed event defining the `i`-th original-dimensional restricted line
law.  It is applied before the `LineDesc` decoder, since a geometric line does
not determine the retained seed. -/
def restrictedLineSeedEvent (L : _root_.MIPStarRE.QPBT.LdParams) (i : Fin L.m)
    (sample : _root_.MIPStarRE.QPBT.LdSpace L × _root_.MIPStarRE.QPBT.LdSpace L) : Prop :=
  _root_.MIPStarRE.QPBT.chiIndex L sample.1.seed = i

/-- Decidability of the pre-decoding seed event. -/
instance restrictedLineSeedEvent_decidablePred (L : _root_.MIPStarRE.QPBT.LdParams) (i : Fin L.m) :
    DecidablePred (_root_.MIPStarRE.QPBT.restrictedLineSeedEvent L i) := by
  intro sample
  unfold _root_.MIPStarRE.QPBT.restrictedLineSeedEvent
  infer_instance

/-- Formalization-only auxiliary for `def:ith-restricted-line`: whenever a line
CL map keeps the shared scalar coordinate, the pre-decoding law it generates
against the point map gives positive mass to every coordinate-index event.  The
witness is the constant seed reconstructed from the index by
`seedOfIndexResidue`. -/
private theorem clDistribution_seedEvent_positive (L : _root_.MIPStarRE.QPBT.LdParams) (i : Fin L.m)
    (CL : _root_.MIPStarRE.QPBT.LdSpace L → _root_.MIPStarRE.QPBT.LdSpace L)
    (hseed : ∀ z : _root_.MIPStarRE.QPBT.LdSpace L, (CL z).seed = z.seed) :
    0 < ∑ sample ∈
        (_root_.MIPStarRE.QPBT.clDistribution CL (_root_.MIPStarRE.QPBT.ldPointCL L)).support.filter
          (_root_.MIPStarRE.QPBT.restrictedLineSeedEvent L i),
      (_root_.MIPStarRE.QPBT.clDistribution CL (_root_.MIPStarRE.QPBT.ldPointCL L)).weight sample := by
  set s0 : _root_.MIPStarRE.QPBT.ScalarQ L := _root_.MIPStarRE.QPBT.seedOfIndexResidue L i ⟨0, L.seedFiberCard_pos⟩ with hs0
  set z0 : _root_.MIPStarRE.QPBT.LdSpace L := fun _ => s0 with hz0
  refine Finset.sum_pos'
    (fun a _ => (_root_.MIPStarRE.QPBT.clDistribution CL (_root_.MIPStarRE.QPBT.ldPointCL L)).nonnegative a)
    ⟨(CL z0, _root_.MIPStarRE.QPBT.ldPointCL L z0), Finset.mem_filter.mpr ⟨?_, ?_⟩, ?_⟩
  · refine Finset.mem_image.mpr ⟨z0, ?_, rfl⟩
    simp
  · change _root_.MIPStarRE.QPBT.chiIndex L (CL z0).seed = i
    rw [hseed]
    exact _root_.MIPStarRE.QPBT.chiIndex_seedOfIndexResidue L i _
  · refine Finset.sum_pos'
      (fun a _ => (_root_.LIDT.MIPStarRE.LDT.uniformDistribution (_root_.MIPStarRE.QPBT.LdSpace L)).nonnegative a)
      ⟨z0, Finset.mem_filter.mpr ⟨?_, rfl⟩, ?_⟩
    · simp
    · simp only [_root_.LIDT.MIPStarRE.LDT.uniformDistribution, _root_.LIDT.MIPStarRE.LDT.Distribution.uniformOnFinset_weight,
        Finset.mem_univ, if_true]
      positivity

/-- The axis-line seed event has positive mass.  This named obligation makes
normalization in `restrictedALinePreDist` explicit.  It belongs to
blueprint
`def:ith-restricted-line`, paper
`references/qpbt-paper/14_analysis_of_the_pauli_basis_test.tex:1038-1048`. -/
theorem restrictedALineSeedEvent_positive (L : _root_.MIPStarRE.QPBT.LdParams) (i : Fin L.m) :
    0 < ∑ sample ∈
        (_root_.MIPStarRE.QPBT.clDistribution (_root_.MIPStarRE.QPBT.ldALineCL L) (_root_.MIPStarRE.QPBT.ldPointCL L)).support.filter
          (_root_.MIPStarRE.QPBT.restrictedLineSeedEvent L i),
      (_root_.MIPStarRE.QPBT.clDistribution (_root_.MIPStarRE.QPBT.ldALineCL L) (_root_.MIPStarRE.QPBT.ldPointCL L)).weight sample :=
  clDistribution_seedEvent_positive L i (_root_.MIPStarRE.QPBT.ldALineCL L) fun _ => rfl

/-- The diagonal-line seed event has positive mass.  This is the corresponding
normalization obligation from blueprint `def:ith-restricted-line`; paper lines
1038--1048. -/
theorem restrictedDLineSeedEvent_positive (L : _root_.MIPStarRE.QPBT.LdParams) (i : Fin L.m) :
    0 < ∑ sample ∈
        (_root_.MIPStarRE.QPBT.clDistribution (_root_.MIPStarRE.QPBT.ldDLineCL L) (_root_.MIPStarRE.QPBT.ldPointCL L)).support.filter
          (_root_.MIPStarRE.QPBT.restrictedLineSeedEvent L i),
      (_root_.MIPStarRE.QPBT.clDistribution (_root_.MIPStarRE.QPBT.ldDLineCL L) (_root_.MIPStarRE.QPBT.ldPointCL L)).weight sample :=
  clDistribution_seedEvent_positive L i (_root_.MIPStarRE.QPBT.ldDLineCL L) fun _ => rfl

/-- The normalized pre-decoding axis law conditioned on coordinate `i`. -/
noncomputable def restrictedALinePreDist (L : _root_.MIPStarRE.QPBT.LdParams) (i : Fin L.m) :
    _root_.LIDT.MIPStarRE.LDT.Distribution (_root_.MIPStarRE.QPBT.LdSpace L × _root_.MIPStarRE.QPBT.LdSpace L) :=
  _root_.MIPStarRE.QPBT.Distribution.restrict
    (_root_.MIPStarRE.QPBT.clDistribution (_root_.MIPStarRE.QPBT.ldALineCL L) (_root_.MIPStarRE.QPBT.ldPointCL L))
    (_root_.MIPStarRE.QPBT.restrictedLineSeedEvent L i)
    (_root_.MIPStarRE.QPBT.restrictedALineSeedEvent_positive L i)

/-- The normalized pre-decoding diagonal law conditioned on coordinate `i`. -/
noncomputable def restrictedDLinePreDist (L : _root_.MIPStarRE.QPBT.LdParams) (i : Fin L.m) :
    _root_.LIDT.MIPStarRE.LDT.Distribution (_root_.MIPStarRE.QPBT.LdSpace L × _root_.MIPStarRE.QPBT.LdSpace L) :=
  _root_.MIPStarRE.QPBT.Distribution.restrict
    (_root_.MIPStarRE.QPBT.clDistribution (_root_.MIPStarRE.QPBT.ldDLineCL L) (_root_.MIPStarRE.QPBT.ldPointCL L))
    (_root_.MIPStarRE.QPBT.restrictedLineSeedEvent L i)
    (_root_.MIPStarRE.QPBT.restrictedDLineSeedEvent_positive L i)

/-- The `i`-th restricted refined axis-line distribution of blueprint
`def:ith-restricted-line`.  Restriction precedes decoding so the seed fiber is
represented faithfully.

**Formalization-only auxiliary:** the blueprint node is stated over the
refined, seed-bearing axis law, so this is an auxiliary restriction of that
refined law and not a formalization of a source distribution.  The paper
prose at
`references/qpbt-paper/14_analysis_of_the_pauli_basis_test.tex:1038-1048`
describes the source restriction; identifying this law's push-forward with it
remains an open obligation recorded in
`docs/paper-gaps/qpbt_ld-dimension-divisibility.tex`, section
`sec:auxiliary-subline-scalars`. -/
noncomputable def restrictedALineDist (L : _root_.MIPStarRE.QPBT.LdParams) (i : Fin L.m) :
    _root_.LIDT.MIPStarRE.LDT.Distribution (_root_.MIPStarRE.QPBT.LineDesc L × (Fin L.m → _root_.MIPStarRE.QPBT.ScalarQ L)) :=
  (_root_.MIPStarRE.QPBT.restrictedALinePreDist L i).map fun sample =>
    (_root_.MIPStarRE.QPBT.aLineDescOf L sample.1, sample.2.point)

/-- The `i`-th restricted refined diagonal-line distribution of blueprint
`def:ith-restricted-line`.  The decoded direction already has all coordinates
preceding `i` set to zero.

**Formalization-only auxiliary:** as for `restrictedALineDist`, the blueprint
node is stated over the refined, seed-bearing diagonal law.  The paper prose
at `references/qpbt-paper/14_analysis_of_the_pauli_basis_test.tex:1038-1048`
describes the source restriction; identifying this law's push-forward with it
remains an open obligation recorded in
`docs/paper-gaps/qpbt_ld-dimension-divisibility.tex`, section
`sec:auxiliary-subline-scalars`. -/
noncomputable def restrictedDLineDist (L : _root_.MIPStarRE.QPBT.LdParams) (i : Fin L.m) :
    _root_.LIDT.MIPStarRE.LDT.Distribution (_root_.MIPStarRE.QPBT.LineDesc L × (Fin L.m → _root_.MIPStarRE.QPBT.ScalarQ L)) :=
  (_root_.MIPStarRE.QPBT.restrictedDLinePreDist L i).map fun sample =>
    (_root_.MIPStarRE.QPBT.dLineDescOf L sample.1, sample.2.point)





end

end MIPStarRE.QPBT
Source
https://github.com/Dengnifer/MIPStarRE-QPBT/blob/8f4118aeea7be16912adbaee3df6dce1741a2c26/QPBT/Combining/Defs.lean#L36-L413

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