Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

QPBT definitions: Combining / DirectLowDegree / Transport / Questions

Definition
QPBT_QPBT_Combining_DirectLowDegree_Transport_Questions

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

qpbt

This bundle defines the question translations between the original LDT model and the direct scalar model used in low-degree transport. It chooses affine line parameters, records direction support and canonical leading indices, encodes points, and constructs direct axis, diagonal, point, and represented LDT questions.

Principal definitions:

  • MIPStarRE.QPBT.directLineRepParameter: an affine parameter relative to a canonical line representative.
  • MIPStarRE.QPBT.directionSupport: the nonzero-coordinate support of a direction.
  • MIPStarRE.QPBT.directDiagonalIndexOf: the leading nonzero coordinate, with the zero-direction convention.
  • MIPStarRE.QPBT.ldtPointToDirect: decodes an LDT point into the fixed direct field with reversed coordinate order.
  • MIPStarRE.QPBT.directAxisQuestionOf: the direct axis question represented by an LDT axis line.
  • MIPStarRE.QPBT.directDiagonalQuestionOf: the direct diagonal question represented by an LDT diagonal line.
  • MIPStarRE.QPBT.directPointQuestionOf: the direct point question represented by an LDT point.
  • MIPStarRE.QPBT.ldtDiagonalLineOf: the LDT diagonal line represented by a direct point and direction sample.

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/DirectLowDegree/Transport/Questions.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_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_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_Lines
import Definitions.Def_QPBT_QPBT_Algebra_Subspaces
import Definitions.Def_QPBT_QPBT_Combining_DirectLowDegree_Game
import Definitions.Def_QPBT_QPBT_Combining_DirectLowDegree_Geometry
import Definitions.Def_QPBT_QPBT_Combining_DirectLowDegree_Transport_Correspondence
import Definitions.Def_QPBT_QPBT_Test_LowDegreeGame
import Mathlib

namespace LIDT.MIPStarRE.LDT
end LIDT.MIPStarRE.LDT
namespace LIDT.MIPStarRE.Quantum
end LIDT.MIPStarRE.Quantum
namespace MIPStarRE.QPBT
end MIPStarRE.QPBT

/-!
# Question and answer transport for the directly indexed low-degree game

This module reads low individual degree test questions as canonical direct
questions and rebases direct answers to the LDT line parametrization.

Points and lines are decoded with the coordinate order reversed
(`directPointEquiv`), so that the suffix-zero direction restriction of the
LDT diagonal test becomes the prefix-zero restriction of the direct game.
An LDT diagonal line reveals no coordinate index, whereas a direct diagonal
question carries one.  The transported question uses the *leading index* of
the decoded direction, the least coordinate at which the direction is
nonzero.  Under the direct sampler, this is the index attached to the sampled
direction exactly when the direction is nonzero at the sampled index
(`directDiagonalIndexOf_prefixProjection`), an event of conditional
probability `1 - 1/q`; on the LDT side, the leading index of a decoded
`j`-restricted direction is `Fin.rev j` exactly when its pivot coordinate is
nonzero (`directDiagonalIndexOf_extendRestrictedDirection`).  Diagonal answers
on zero-direction lines are read as the constant polynomial carrying their
value at the base point, following `rem:ld-win-zero-direction`.

## References

- `references/qpbt-paper/08_classical_and_quantum_low_degree_tests.tex:230-272`
- `references/ldt-paper/test_definition.tex:49-65`
- `rem:ld-win-zero-direction`
- `docs/paper-gaps/qpbt_ld-dimension-divisibility.tex`
-/

@[expose] public section

open scoped BigOperators MatrixOrder Matrix ComplexOrder

namespace MIPStarRE.QPBT

open LIDT.MIPStarRE.LDT
open LIDT.MIPStarRE.Quantum

noncomputable section

/-! ## Canonical line rebasing of LDT lines -/

/-- A chosen affine parameter expressing a point relative to its canonical
line representative. -/
noncomputable def directLineRepParameter
    {K : Type*} [Field K] {m : ℕ} (v u : Fin m → K) : K :=
  Classical.choose (_root_.MIPStarRE.QPBT.mem_linePoints_lineRepMap v u)

/-- The chosen canonical rebase parameter reconstructs the original point. -/
theorem directLineRepParameter_spec
    {K : Type*} [Field K] {m : ℕ} (v u : Fin m → K) :
    u = _root_.MIPStarRE.QPBT.lineRepMap v u + _root_.MIPStarRE.QPBT.directLineRepParameter v u • v :=
  Classical.choose_spec (_root_.MIPStarRE.QPBT.mem_linePoints_lineRepMap v u)

/-- Canonical line representatives are unchanged by translation along their
direction. -/
theorem lineRepMap_add_smul
    {K : Type*} [Field K] {m : ℕ}
    (v u : Fin m → K) (t : K) :
    _root_.MIPStarRE.QPBT.lineRepMap v (u + t • v) = _root_.MIPStarRE.QPBT.lineRepMap v u := by
  let W : Submodule K (Fin m → K) := Submodule.span K ({v} : Set (Fin m → K))
  have hv : v ∈ W := Submodule.subset_span (Set.mem_singleton v)
  have hzero : _root_.MIPStarRE.QPBT.lineRepMap v v = 0 := by
    simp [_root_.MIPStarRE.QPBT.lineRepMap, _root_.MIPStarRE.QPBT.canonicalProjOfKernel, W, LinearMap.comp_apply,
      Submodule.projectionOnto_apply_of_mem_right
        (_root_.MIPStarRE.QPBT.isCompl_registerSubmodule_canonicalComplement W).symm hv]
  simp [map_add, map_smul, hzero]

/-- For a nonzero direction, the canonical rebase parameter is unique. -/
theorem directLineRepParameter_eq_of_nonzero
    {K : Type*} [Field K] {m : ℕ}
    {v u : Fin m → K} (hv : v ≠ 0) {t : K}
    (ht : u = _root_.MIPStarRE.QPBT.lineRepMap v u + t • v) :
    _root_.MIPStarRE.QPBT.directLineRepParameter v u = t := by
  have hfun : _root_.MIPStarRE.QPBT.directLineRepParameter v u • v = t • v := by
    apply add_left_cancel (a := _root_.MIPStarRE.QPBT.lineRepMap v u)
    exact (_root_.MIPStarRE.QPBT.directLineRepParameter_spec v u).symm.trans ht
  obtain ⟨i, hi⟩ : ∃ i, v i ≠ 0 := by
    by_contra h
    apply hv
    funext i
    simpa using not_exists.mp h i
  have hcoord := congrFun hfun i
  simp only [Pi.smul_apply, smul_eq_mul] at hcoord
  exact mul_right_cancel₀ hi hcoord

/-- Translating a point on a nonzero line adds the translation to its
canonical rebase parameter. -/
theorem directLineRepParameter_add_smul
    {K : Type*} [Field K] {m : ℕ}
    {v u : Fin m → K} (hv : v ≠ 0) (t : K) :
    _root_.MIPStarRE.QPBT.directLineRepParameter v (u + t • v) =
      _root_.MIPStarRE.QPBT.directLineRepParameter v u + t := by
  apply _root_.MIPStarRE.QPBT.directLineRepParameter_eq_of_nonzero hv
  rw [_root_.MIPStarRE.QPBT.lineRepMap_add_smul]
  calc
    u + t • v =
        (_root_.MIPStarRE.QPBT.lineRepMap v u + _root_.MIPStarRE.QPBT.directLineRepParameter v u • v) + t • v := by
      rw [← _root_.MIPStarRE.QPBT.directLineRepParameter_spec v u]
    _ = _root_.MIPStarRE.QPBT.lineRepMap v u + (_root_.MIPStarRE.QPBT.directLineRepParameter v u + t) • v := by
      module

/-! ## The leading index of a direction -/

/-- The coordinates at which a direct direction vector is nonzero. -/
def directionSupport (D : _root_.MIPStarRE.QPBT.DirectLdParams) (v : Fin D.m → _root_.MIPStarRE.QPBT.DirectScalarQ D) :
    Finset (Fin D.m) :=
  open Classical in
  Finset.univ.filter fun j => v j ≠ 0



/-- The leading index of a direction: the least coordinate at which it is
nonzero, or the last coordinate for the zero direction.  Every coordinate
before the leading index vanishes, so a direction is the prefix projection of
itself at its leading index, and the pair (leading index, direction) is a
canonical direct diagonal sample.  It is the direct index of the sample
whenever the sampled direction is nonzero at the sampled index. -/
noncomputable def directDiagonalIndexOf (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (v : Fin D.m → _root_.MIPStarRE.QPBT.DirectScalarQ D) : Fin D.m :=
  open Classical in
  if h : (_root_.MIPStarRE.QPBT.directionSupport D v).Nonempty then (_root_.MIPStarRE.QPBT.directionSupport D v).min' h
  else Fin.rev D.firstIndex









/-! ## Decoding LDT points and lines -/

/-- Decode an LDT point into the fixed direct scalar field, reversing the
coordinate order. -/
abbrev ldtPointToDirect (D : _root_.MIPStarRE.QPBT.DirectLdParams) :
    _root_.LIDT.MIPStarRE.LDT.Point D.toLDTParameters → Fin D.m → _root_.MIPStarRE.QPBT.DirectScalarQ D :=
  (_root_.MIPStarRE.QPBT.directPointEquiv D).symm

/-- The direct canonical axis question represented by an LDT axis line.
The LDT coordinate index is reversed together with the point
coordinates. -/
noncomputable def directAxisQuestionOf (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (line : _root_.LIDT.MIPStarRE.LDT.AxisParallelLine D.toLDTParameters) : _root_.MIPStarRE.QPBT.DirectLdQuestion D :=
  let u := _root_.MIPStarRE.QPBT.ldtPointToDirect D line.base
  let i : Fin D.m := Fin.rev line.direction
  let v : Fin D.m → _root_.MIPStarRE.QPBT.DirectScalarQ D := _root_.MIPStarRE.QPBT.coordinateDirection i
  (.aline, ⟨_root_.MIPStarRE.QPBT.lineRepMap v u, i, 0⟩)

/-- The direct canonical diagonal question represented by an LDT diagonal
line.  The decoded direction is kept and the direct index is its leading
index, so the question is the canonical direct question of the direct sample
formed by the decoded base, the leading index, and the decoded direction
(`directDiagonalQuestionOf_eq_directLdMap`). -/
noncomputable def directDiagonalQuestionOf (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (line : _root_.LIDT.MIPStarRE.LDT.DiagonalLine D.toLDTParameters) : _root_.MIPStarRE.QPBT.DirectLdQuestion D :=
  let u := _root_.MIPStarRE.QPBT.ldtPointToDirect D line.base
  let v := _root_.MIPStarRE.QPBT.ldtPointToDirect D line.direction
  (.dline, ⟨_root_.MIPStarRE.QPBT.lineRepMap v u, _root_.MIPStarRE.QPBT.directDiagonalIndexOf D v, v⟩)

/-- The direct point question represented by an LDT point. -/
noncomputable def directPointQuestionOf (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (u : _root_.LIDT.MIPStarRE.LDT.Point D.toLDTParameters) : _root_.MIPStarRE.QPBT.DirectLdQuestion D :=
  _root_.MIPStarRE.QPBT.directLdPointQuestionOf D (_root_.MIPStarRE.QPBT.ldtPointToDirect D u)



/-- The LDT diagonal line represented by a direct sample: the encoded
point and the encoded direction. -/
def ldtDiagonalLineOf (D : _root_.MIPStarRE.QPBT.DirectLdParams) (sample : _root_.MIPStarRE.QPBT.DirectLdSpace D) :
    _root_.LIDT.MIPStarRE.LDT.DiagonalLine D.toLDTParameters :=
  { base := _root_.MIPStarRE.QPBT.directPointEquiv D sample.point
    direction := _root_.MIPStarRE.QPBT.directPointEquiv D sample.direction }







/-! ## Rebasing lines -/

/-- Decoding an axis-line rebase is translation by the decoded scalar along
the reversed direct coordinate direction. -/
theorem ldtPointToDirect_axis_rebase (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (line : _root_.LIDT.MIPStarRE.LDT.AxisParallelLine D.toLDTParameters)
    (t : _root_.LIDT.MIPStarRE.LDT.Fq D.toLDTParameters) :
    letI := D.toLDTFieldModel
    _root_.MIPStarRE.QPBT.ldtPointToDirect D (line.rebaseAt t).base =
      _root_.MIPStarRE.QPBT.ldtPointToDirect D line.base +
        (_root_.MIPStarRE.QPBT.directScalarEquiv D).symm t •
          _root_.MIPStarRE.QPBT.coordinateDirection (Fin.rev line.direction) := by
  letI := D.toLDTFieldModel
  funext i
  simp only [_root_.MIPStarRE.QPBT.ldtPointToDirect, _root_.MIPStarRE.QPBT.directPointEquiv_symm_apply,
    _root_.LIDT.MIPStarRE.LDT.AxisParallelLine.rebaseAt, _root_.LIDT.MIPStarRE.LDT.AxisParallelLine.pointAt, Pi.add_apply,
    Pi.smul_apply]
  by_cases hi : i = Fin.rev line.direction
  · subst hi
    simp only [_root_.MIPStarRE.QPBT.coordinateDirection, Fin.rev_rev, if_pos, smul_eq_mul]
    rw [Pi.single_eq_same, mul_one]
    exact (_root_.LIDT.MIPStarRE.LDT.FieldModel.equiv (q := D.q)).symm_apply_apply _
  · have hrev : Fin.rev i ≠ line.direction := by
      intro h
      apply hi
      rw [← h, Fin.rev_rev]
    simp [hi, hrev, _root_.MIPStarRE.QPBT.coordinateDirection]

/-- Decoding a diagonal-line rebase is translation by the decoded scalar
along the decoded direct direction. -/
theorem ldtPointToDirect_diagonal_rebase (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (line : _root_.LIDT.MIPStarRE.LDT.DiagonalLine D.toLDTParameters)
    (t : _root_.LIDT.MIPStarRE.LDT.Fq D.toLDTParameters) :
    letI := D.toLDTFieldModel
    _root_.MIPStarRE.QPBT.ldtPointToDirect D (line.rebaseAt t).base =
      _root_.MIPStarRE.QPBT.ldtPointToDirect D line.base +
        (_root_.MIPStarRE.QPBT.directScalarEquiv D).symm t • _root_.MIPStarRE.QPBT.ldtPointToDirect D line.direction := by
  letI := D.toLDTFieldModel
  funext i
  change _root_.LIDT.MIPStarRE.LDT.decodeScalar
      (_root_.LIDT.MIPStarRE.LDT.addCoord (line.base (Fin.rev i))
        (_root_.LIDT.MIPStarRE.LDT.mulCoord t (line.direction (Fin.rev i)))) =
    _root_.LIDT.MIPStarRE.LDT.decodeScalar (line.base (Fin.rev i)) +
      _root_.LIDT.MIPStarRE.LDT.decodeScalar t * _root_.LIDT.MIPStarRE.LDT.decodeScalar (line.direction (Fin.rev i))
  simp [_root_.LIDT.MIPStarRE.LDT.addCoord, _root_.LIDT.MIPStarRE.LDT.mulCoord]

/-- Canonical direct axis questions do not depend on the chosen base point of
the LDT line. -/
theorem directAxisQuestionOf_rebase (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (line : _root_.LIDT.MIPStarRE.LDT.AxisParallelLine D.toLDTParameters)
    (t : _root_.LIDT.MIPStarRE.LDT.Fq D.toLDTParameters) :
    letI := D.toLDTFieldModel
    _root_.MIPStarRE.QPBT.directAxisQuestionOf D (line.rebaseAt t) = _root_.MIPStarRE.QPBT.directAxisQuestionOf D line := by
  letI := D.toLDTFieldModel
  simp only [_root_.MIPStarRE.QPBT.directAxisQuestionOf, AxisParallelLine.rebaseAt_direction]
  rw [_root_.MIPStarRE.QPBT.ldtPointToDirect_axis_rebase, _root_.MIPStarRE.QPBT.lineRepMap_add_smul]

/-- Canonical direct diagonal questions do not depend on the chosen base point
of the LDT line; the leading index depends only on the direction. -/
theorem directDiagonalQuestionOf_rebase (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (line : _root_.LIDT.MIPStarRE.LDT.DiagonalLine D.toLDTParameters)
    (t : _root_.LIDT.MIPStarRE.LDT.Fq D.toLDTParameters) :
    letI := D.toLDTFieldModel
    _root_.MIPStarRE.QPBT.directDiagonalQuestionOf D (line.rebaseAt t) =
      _root_.MIPStarRE.QPBT.directDiagonalQuestionOf D line := by
  letI := D.toLDTFieldModel
  simp only [_root_.MIPStarRE.QPBT.directDiagonalQuestionOf, _root_.LIDT.MIPStarRE.LDT.DiagonalLine.rebaseAt]
  have hrebase := _root_.MIPStarRE.QPBT.ldtPointToDirect_diagonal_rebase D line t
  change _root_.MIPStarRE.QPBT.ldtPointToDirect D (line.pointAt t) =
      _root_.MIPStarRE.QPBT.ldtPointToDirect D line.base +
        (_root_.MIPStarRE.QPBT.directScalarEquiv D).symm t • _root_.MIPStarRE.QPBT.ldtPointToDirect D line.direction at hrebase
  rw [hrebase, _root_.MIPStarRE.QPBT.lineRepMap_add_smul]

/-- The fixed scalar coding transports field addition to LDT coordinate
addition. -/
theorem directScalarEquiv_add (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (x y : _root_.MIPStarRE.QPBT.DirectScalarQ D) :
    letI := D.toLDTFieldModel
    _root_.MIPStarRE.QPBT.directScalarEquiv D (x + y) =
      _root_.LIDT.MIPStarRE.LDT.addCoord (_root_.MIPStarRE.QPBT.directScalarEquiv D x) (_root_.MIPStarRE.QPBT.directScalarEquiv D y) := by
  letI := D.toLDTFieldModel
  change _root_.LIDT.MIPStarRE.LDT.FieldModel.equiv (x + y) =
    _root_.LIDT.MIPStarRE.LDT.FieldModel.equiv
      (_root_.LIDT.MIPStarRE.LDT.FieldModel.equiv.symm (_root_.LIDT.MIPStarRE.LDT.FieldModel.equiv x) +
        _root_.LIDT.MIPStarRE.LDT.FieldModel.equiv.symm (_root_.LIDT.MIPStarRE.LDT.FieldModel.equiv y))
  rw [_root_.LIDT.MIPStarRE.LDT.FieldModel.equiv.symm_apply_apply, _root_.LIDT.MIPStarRE.LDT.FieldModel.equiv.symm_apply_apply]

private theorem coordinateDirection_ne_zero
    {K : Type*} [Field K] {m : ℕ} (i : Fin m) :
    (_root_.MIPStarRE.QPBT.coordinateDirection i : Fin m → K) ≠ 0 := by
  intro h
  have hi := congrFun h i
  simp [_root_.MIPStarRE.QPBT.coordinateDirection] at hi

/-- Canonical rebase parameter for an LDT axis-parallel line. -/
noncomputable def directAxisRebaseParameter (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (line : _root_.LIDT.MIPStarRE.LDT.AxisParallelLine D.toLDTParameters) : _root_.MIPStarRE.QPBT.DirectScalarQ D :=
  _root_.MIPStarRE.QPBT.directLineRepParameter (_root_.MIPStarRE.QPBT.coordinateDirection (Fin.rev line.direction))
    (_root_.MIPStarRE.QPBT.ldtPointToDirect D line.base)

/-- Canonical rebase parameter for an LDT diagonal line. -/
noncomputable def directDiagonalRebaseParameter (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (line : _root_.LIDT.MIPStarRE.LDT.DiagonalLine D.toLDTParameters) : _root_.MIPStarRE.QPBT.DirectScalarQ D :=
  _root_.MIPStarRE.QPBT.directLineRepParameter (_root_.MIPStarRE.QPBT.ldtPointToDirect D line.direction)
    (_root_.MIPStarRE.QPBT.ldtPointToDirect D line.base)

/-- Axis-line canonical parameters add under LDT line rebasing. -/
theorem directAxisRebaseParameter_rebase (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (line : _root_.LIDT.MIPStarRE.LDT.AxisParallelLine D.toLDTParameters)
    (t : _root_.LIDT.MIPStarRE.LDT.Fq D.toLDTParameters) :
    letI := D.toLDTFieldModel
    _root_.MIPStarRE.QPBT.directAxisRebaseParameter D (line.rebaseAt t) =
      _root_.MIPStarRE.QPBT.directAxisRebaseParameter D line + (_root_.MIPStarRE.QPBT.directScalarEquiv D).symm t := by
  letI := D.toLDTFieldModel
  unfold _root_.MIPStarRE.QPBT.directAxisRebaseParameter
  rw [_root_.MIPStarRE.QPBT.ldtPointToDirect_axis_rebase]
  exact _root_.MIPStarRE.QPBT.directLineRepParameter_add_smul
    (coordinateDirection_ne_zero (Fin.rev line.direction)) _

/-- Nonzero diagonal-line canonical parameters add under LDT line rebasing. -/
theorem directDiagonalRebaseParameter_rebase (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (line : _root_.LIDT.MIPStarRE.LDT.DiagonalLine D.toLDTParameters)
    (t : _root_.LIDT.MIPStarRE.LDT.Fq D.toLDTParameters)
    (hdir : _root_.MIPStarRE.QPBT.ldtPointToDirect D line.direction ≠ 0) :
    letI := D.toLDTFieldModel
    _root_.MIPStarRE.QPBT.directDiagonalRebaseParameter D (line.rebaseAt t) =
      _root_.MIPStarRE.QPBT.directDiagonalRebaseParameter D line + (_root_.MIPStarRE.QPBT.directScalarEquiv D).symm t := by
  letI := D.toLDTFieldModel
  unfold _root_.MIPStarRE.QPBT.directDiagonalRebaseParameter
  rw [_root_.MIPStarRE.QPBT.ldtPointToDirect_diagonal_rebase]
  exact _root_.MIPStarRE.QPBT.directLineRepParameter_add_smul hdir _

/-! ## Reading direct answers as LDT answers -/

/-- The constant diagonal-line answer with the given direct value. -/
noncomputable def constantDiagonalAnswer (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (x : _root_.MIPStarRE.QPBT.DirectScalarQ D) :
    letI := D.toLDTFieldModel
    _root_.LIDT.MIPStarRE.LDT.DiagonalLinePolynomial D.toLDTParameters := by
  letI := D.toLDTFieldModel
  exact { poly := Polynomial.C x
          degreeBounded := by simp }

/-- Constant answers are fixed by every reparametrization. -/
theorem constantDiagonalAnswer_reparamAt (D : _root_.MIPStarRE.QPBT.DirectLdParams)
    (x : _root_.MIPStarRE.QPBT.DirectScalarQ D) (t : _root_.LIDT.MIPStarRE.LDT.Fq D.toLDTParameters) :
    letI := D.toLDTFieldModel
    _root_.LIDT.MIPStarRE.LDT.DiagonalLinePolynomial.reparamAt (_root_.MIPStarRE.QPBT.constantDiagonalAnswer D x) t =
      _root_.MIPStarRE.QPBT.constantDiagonalAnswer D x := by
  letI := D.toLDTFieldModel
  apply _root_.LIDT.MIPStarRE.LDT.DiagonalLinePolynomial.ext
  simp [_root_.MIPStarRE.QPBT.constantDiagonalAnswer, _root_.LIDT.MIPStarRE.LDT.DiagonalLinePolynomial.reparamAt]



/-- Read one simultaneous coordinate from a direct point answer. -/
noncomputable def directPointAnswerReadout (D : _root_.MIPStarRE.QPBT.DirectLdParams) (r : Fin D.k) :
    letI := D.toLDTFieldModel
    _root_.MIPStarRE.QPBT.DirectLdAnswer D → _root_.LIDT.MIPStarRE.LDT.Fq D.toLDTParameters := by
  letI := D.toLDTFieldModel
  intro answer
  exact match answer with
    | .pointVals a => _root_.MIPStarRE.QPBT.directScalarEquiv D (a r)
    | .alinePolys _ => _root_.MIPStarRE.QPBT.directScalarEquiv D 0
    | .dlinePolys _ => _root_.MIPStarRE.QPBT.directScalarEquiv D 0

/-- Read one simultaneous coordinate from a direct axis-line answer and
rebase its polynomial from the canonical direct line to the LDT line. -/
noncomputable def directAxisAnswerReadout (D : _root_.MIPStarRE.QPBT.DirectLdParams) (r : Fin D.k)
    (line : _root_.LIDT.MIPStarRE.LDT.AxisParallelLine D.toLDTParameters) :
    letI := D.toLDTFieldModel
    _root_.MIPStarRE.QPBT.DirectLdAnswer D → _root_.LIDT.MIPStarRE.LDT.AxisLinePolynomial D.toLDTParameters := by
  letI := D.toLDTFieldModel
  intro answer
  exact match answer with
    | .alinePolys a => _root_.LIDT.MIPStarRE.LDT.AxisLinePolynomial.reparamAt
        (_root_.MIPStarRE.QPBT.directAxisAnswerEquiv D (a r))
        (_root_.MIPStarRE.QPBT.directScalarEquiv D (_root_.MIPStarRE.QPBT.directAxisRebaseParameter D line))
    | .pointVals _ => default
    | .dlinePolys _ => default

/-- Read one simultaneous coordinate from a direct diagonal-line answer.  For
a nonzero direction the polynomial is rebased from the canonical direct line
to the LDT line.  A zero direction is the singleton line through its base,
where the direct predicate accepts an answer exactly when its polynomial
function is constant with the point's value (`rem:ld-win-zero-direction`);
the answer is read as the constant polynomial carrying its value at the base
point, which is fixed by every reparametrization.  Wrong-form answers are
sent to the default polynomial. -/
noncomputable def directDiagonalAnswerReadout (D : _root_.MIPStarRE.QPBT.DirectLdParams) (r : Fin D.k)
    (line : _root_.LIDT.MIPStarRE.LDT.DiagonalLine D.toLDTParameters) :
    letI := D.toLDTFieldModel
    _root_.MIPStarRE.QPBT.DirectLdAnswer D → _root_.LIDT.MIPStarRE.LDT.DiagonalLinePolynomial D.toLDTParameters := by
  letI := D.toLDTFieldModel
  classical
  intro answer
  exact match answer with
    | .dlinePolys a =>
        if _root_.MIPStarRE.QPBT.ldtPointToDirect D line.direction = 0 then
          _root_.MIPStarRE.QPBT.constantDiagonalAnswer D (_root_.MIPStarRE.QPBT.evalCoefficient (a r) 0)
        else
          _root_.LIDT.MIPStarRE.LDT.DiagonalLinePolynomial.reparamAt (_root_.MIPStarRE.QPBT.directDiagonalAnswerEquiv D (a r))
            (_root_.MIPStarRE.QPBT.directScalarEquiv D (_root_.MIPStarRE.QPBT.directDiagonalRebaseParameter D line))
    | .pointVals _ => default
    | .alinePolys _ => default

/-- Axis answer readout is covariant under LDT line rebasing. -/
theorem directAxisAnswerReadout_rebase (D : _root_.MIPStarRE.QPBT.DirectLdParams) (r : Fin D.k)
    (line : _root_.LIDT.MIPStarRE.LDT.AxisParallelLine D.toLDTParameters)
    (t : _root_.LIDT.MIPStarRE.LDT.Fq D.toLDTParameters) (answer : _root_.MIPStarRE.QPBT.DirectLdAnswer D) :
    letI := D.toLDTFieldModel
    _root_.MIPStarRE.QPBT.directAxisAnswerReadout D r (line.rebaseAt t) answer =
      _root_.LIDT.MIPStarRE.LDT.AxisLinePolynomial.reparamAt (_root_.MIPStarRE.QPBT.directAxisAnswerReadout D r line answer) t := by
  letI := D.toLDTFieldModel
  cases answer with
  | pointVals a => simp [_root_.MIPStarRE.QPBT.directAxisAnswerReadout]
  | dlinePolys a => simp [_root_.MIPStarRE.QPBT.directAxisAnswerReadout]
  | alinePolys a =>
      simp only [_root_.MIPStarRE.QPBT.directAxisAnswerReadout]
      rw [_root_.MIPStarRE.QPBT.directAxisRebaseParameter_rebase, _root_.MIPStarRE.QPBT.directScalarEquiv_add]
      rw [(_root_.MIPStarRE.QPBT.directScalarEquiv D).apply_symm_apply]
      exact (_root_.LIDT.MIPStarRE.LDT.AxisLinePolynomial.reparamAt_reparamAt
        (_root_.MIPStarRE.QPBT.directAxisAnswerEquiv D (a r)) _ _).symm

/-- Diagonal answer readout is covariant under LDT line rebasing, including
the constant zero-direction convention. -/
theorem directDiagonalAnswerReadout_rebase (D : _root_.MIPStarRE.QPBT.DirectLdParams) (r : Fin D.k)
    (line : _root_.LIDT.MIPStarRE.LDT.DiagonalLine D.toLDTParameters)
    (t : _root_.LIDT.MIPStarRE.LDT.Fq D.toLDTParameters) (answer : _root_.MIPStarRE.QPBT.DirectLdAnswer D) :
    letI := D.toLDTFieldModel
    _root_.MIPStarRE.QPBT.directDiagonalAnswerReadout D r (line.rebaseAt t) answer =
      _root_.LIDT.MIPStarRE.LDT.DiagonalLinePolynomial.reparamAt
        (_root_.MIPStarRE.QPBT.directDiagonalAnswerReadout D r line answer) t := by
  letI := D.toLDTFieldModel
  cases answer with
  | pointVals a => simp [_root_.MIPStarRE.QPBT.directDiagonalAnswerReadout]
  | alinePolys a => simp [_root_.MIPStarRE.QPBT.directDiagonalAnswerReadout]
  | dlinePolys a =>
      by_cases hdir : _root_.MIPStarRE.QPBT.ldtPointToDirect D line.direction = 0
      · have hrebase : _root_.MIPStarRE.QPBT.ldtPointToDirect D (line.rebaseAt t).direction = 0 := by
          simpa [_root_.LIDT.MIPStarRE.LDT.DiagonalLine.rebaseAt] using hdir
        simp [_root_.MIPStarRE.QPBT.directDiagonalAnswerReadout, hdir, hrebase,
          _root_.MIPStarRE.QPBT.constantDiagonalAnswer_reparamAt]
      · have hrebase : _root_.MIPStarRE.QPBT.ldtPointToDirect D (line.rebaseAt t).direction ≠ 0 := by
          simpa [_root_.LIDT.MIPStarRE.LDT.DiagonalLine.rebaseAt] using hdir
        simp only [_root_.MIPStarRE.QPBT.directDiagonalAnswerReadout, hdir, hrebase, ↓reduceIte]
        rw [_root_.MIPStarRE.QPBT.directDiagonalRebaseParameter_rebase D line t hdir,
          _root_.MIPStarRE.QPBT.directScalarEquiv_add, (_root_.MIPStarRE.QPBT.directScalarEquiv D).apply_symm_apply]
        exact (_root_.LIDT.MIPStarRE.LDT.DiagonalLinePolynomial.reparamAt_reparamAt
          (_root_.MIPStarRE.QPBT.directDiagonalAnswerEquiv D (a r)) _ _).symm

end

end MIPStarRE.QPBT
Source
https://github.com/Dengnifer/MIPStarRE-QPBT/blob/8f4118aeea7be16912adbaee3df6dce1741a2c26/QPBT/Combining/DirectLowDegree/Transport/Questions.lean#L47-L556

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