LIDT definitions: LDT / Pasting / ComparisonLemmas / CommuteGHalfSandwich / Setup / Definitions
DefinitionLIDT_MIPStarRE_LDT_Pasting_ComparisonLemmas_CommuteGHalfSandwich_Setup_Definitionslidt
This bundle defines the question reindexings and operator families for the commute-G-half-sandwich comparison. Its constructions expose the head, tail, moved, and commuted endpoints and provide the equivalences needed to add one move to the chain.
Principal definitions:
pointTupleConsEquiv: the equivalence that splits a nonempty tuple of slice questions into its first point and remaining tail.gHatReverseHalfProductOutcomeOperator: the reverse-ordered half-product of completed-slice outcome operators.headTailOrderedFamily: the ordered head-tail family with the head factor first on the left register.headTailRotatedFamily: the rotated family with the tail half-product preceding the head factor.commuteGHalfSandwich_moveFamily: the move-family endpoint with distinguished factors on opposite tensor registers.commuteGHalfSandwich_commuteFamily: the endpoint obtained by commuting the two distinguished left-register factors.thirdSliceFrontEquiv: the equivalence that moves a third distinguished slice coordinate to the front.splitQuestionEquiv: the reassociation equivalence from a head-tail question and one added slice to a move-chain question.
Formalization credit: Sirui Lu, Ruixuan Deng, Yanqiao Zhu, and Zhengfeng Ji (arXiv:2609.19814). Mathematical source: Zhengfeng Ji, Anand Natarajan, Thomas Vidick, John Wright, and Henry Yuen (arXiv:2009.12982).
Definition code
-- Generated from MIPStarRE/LDT/Pasting/ComparisonLemmas/CommuteGHalfSandwich/Setup/Definitions.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_DistributionUniformSums
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_LinePolynomialEmbedding
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_LinePolynomials
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_LowDegreePolynomial
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_MeasurementLift
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_OpFamily
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_OperatorExpectations
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_PMFAverages
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_PMFUniformAverages
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_Basic_SubMeasurementFamilies
import Definitions.Def_LIDT_MIPStarRE_LDT_Basic_TensorPlacement
import Definitions.Def_LIDT_MIPStarRE_LDT_CommutativityPoints_Approximation
import Definitions.Def_LIDT_MIPStarRE_LDT_CommutativityPoints_Defs
import Definitions.Def_LIDT_MIPStarRE_LDT_CommutativityPoints_SharedHelpers_SharedLine
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_Defs_Core
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_Defs_Normalization
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_Defs_Stability
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_EvaluatedSliceBounds_PhaseOneThree
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_GCommStability_Scalar_First
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_GCommStability_Scalar_RawSecond
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_Main_Auxiliary_HEvalTransport
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_Main_Auxiliary_ScalarMarginalization
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_Scaffold_Core
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_Scaffold_Products
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_ScalarApproximation_Core
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_ScalarApproximation_PaperChainPhaseFive
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_ScalarApproximation_ProcessedG_MainChain
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_ScalarApproximation_ProcessedG_PhaseTwo
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_Transport_FullSlice_Averages
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_Transport_FullSlice_Machinery_Marginalization_Core
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_Transport_FullSlice_Machinery_Marginalization_Y
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_Transport_FullSlice_Machinery_Normalization
import Definitions.Def_LIDT_MIPStarRE_LDT_Commutativity_Transport_Pullback
import Definitions.Def_LIDT_MIPStarRE_LDT_ExpansionHypercubeGraph_Defs_Core
import Definitions.Def_LIDT_MIPStarRE_LDT_GlobalVariance_Defs_Core
import Definitions.Def_LIDT_MIPStarRE_LDT_MainInductionStep_Defs
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_Pasting_Defs_Tuples
import Definitions.Def_LIDT_MIPStarRE_LDT_Pasting_Sandwich_GHatSandwich
import Definitions.Def_LIDT_MIPStarRE_LDT_Pasting_Sandwich_PastedFamilies
import Definitions.Def_LIDT_MIPStarRE_LDT_Pasting_Sandwich_Switcheroo
import Definitions.Def_LIDT_MIPStarRE_LDT_Pasting_Statements
import Definitions.Def_LIDT_MIPStarRE_LDT_Pasting_SwitcherooContraction_ScalarTerms
import Definitions.Def_LIDT_MIPStarRE_LDT_Pasting_SwitcherooContraction_Split
import Definitions.Def_LIDT_MIPStarRE_LDT_Pasting_SwitcherooSetup_Centers
import Definitions.Def_LIDT_MIPStarRE_LDT_Pasting_SwitcherooSetup_Terms
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_BipartiteSelfConsistency_Completion
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_BipartiteSelfConsistency_Core
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_BipartiteSelfConsistency_Local
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_CauchySchwarz
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_ComparisonCore
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_CompletionTransfer
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_Defs
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_DistanceBounds
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_PolynomialAgreement
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_Polynomials
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_SelfConsistency_Extensions
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_SwitchSandwichMain_Completeness
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_SwitchSandwichPrep_ApproxDelta
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_SwitchSandwichPrep_Core
import Definitions.Def_LIDT_MIPStarRE_LDT_Preliminaries_SwitchSandwichPrep_InnerProduct
import Definitions.Def_LIDT_MIPStarRE_LDT_Tactic_QuantumNonneg
import Definitions.Def_LIDT_MIPStarRE_LDT_Test_Defs
import Definitions.Def_LIDT_MIPStarRE_LDT_Test_StrategyCore
import Definitions.Def_LIDT_MIPStarRE_LDT_Test_StrategyFailures
import Definitions.Def_LIDT_MIPStarRE_LDT_Test_StrategyPolynomialFamilies
import Definitions.Def_LIDT_MIPStarRE_LDT_Test_StrategyRole_Algebra
import Definitions.Def_LIDT_MIPStarRE_LDT_Test_StrategyRole_Core
import Definitions.Def_LIDT_MIPStarRE_Quantum_FiniteMatrix_Basic
import Definitions.Def_LIDT_MIPStarRE_Quantum_FiniteMatrix_BlockDiagonal
import Definitions.Def_LIDT_MIPStarRE_Quantum_FiniteMatrix_NormalizedTrace
import Definitions.Def_LIDT_MIPStarRE_Quantum_FiniteMatrix_Order
import Definitions.Def_LIDT_MIPStarRE_Quantum_FiniteMatrix_TracePairing
import Definitions.Def_LIDT_MIPStarRE_Quantum_Measurement
import Mathlib
import Mathlib.Algebra.MvPolynomial.CommRing
import Mathlib.Algebra.MvPolynomial.SchwartzZippel
import Mathlib.Algebra.Polynomial.Roots
import Mathlib.Analysis.MeanInequalitiesPow
import Mathlib.Probability.ProbabilityMassFunction.Integrals
import Mathlib.Probability.ProbabilityMassFunction.Monad
import Mathlib.RingTheory.MvPolynomial.Basic
namespace LIDT
namespace MIPStarRE.LDT
end MIPStarRE.LDT
namespace MIPStarRE.LDT.Commutativity
end MIPStarRE.LDT.Commutativity
namespace MIPStarRE.LDT.Commutativity.GCommStability.Scalar
end MIPStarRE.LDT.Commutativity.GCommStability.Scalar
namespace MIPStarRE.LDT.CommutativityPoints
end MIPStarRE.LDT.CommutativityPoints
namespace MIPStarRE.LDT.Pasting
end MIPStarRE.LDT.Pasting
namespace MIPStarRE.LDT.Preliminaries
end MIPStarRE.LDT.Preliminaries
/-!
# Section 12 pasting: commute G half-sandwich setup — definitions
Tuple equivalences, operator definitions, and family constructions for the half-sandwich
commutation chain. This module contains all `def`/`noncomputable def` declarations and small
helper lemmas used by the sum-bound and step-commutation submodules.
## References
- `references/ldt-paper/ld-pasting.tex`
- `blueprint/src/chapter/ch09_pasting.tex`
-/
@[expose] public section
namespace MIPStarRE.LDT.Pasting
open MIPStarRE.LDT
open MIPStarRE.LDT.ExpansionHypercubeGraph
open MIPStarRE.LDT.CommutativityPoints
open scoped BigOperators MatrixOrder _root_.Matrix ComplexOrder
variable {ι : Type*} [Fintype ι] [DecidableEq ι]
/-! ### Sandwich-chain comparison lemmas
These lemmas capture the infrastructure needed for the `lem:commute-g-half-sandwich`
through `cor:h-a-consistency` chain in `ld-pasting.tex` §9.3.
The n-step SDDOpRel composition lemma (`sddOpRel_chain`) lives in
`MIPStarRE.LDT.Preliminaries.CompletionTransfer` alongside `sddOpRel_triangle`,
since it is a general-purpose result used by multiple chapters. -/
/-- Split a nonempty tuple of slice questions into its first coordinate and
the remaining tail. -/
def pointTupleConsEquiv (params : Parameters) (k : ℕ) :
PointTuple params (k + 1) ≃ SliceQuestion params × PointTuple params k where
toFun xs := (xs 0, pointTupleTail xs)
invFun p := Fin.cons p.1 p.2
left_inv xs := by
funext i
cases i using Fin.cases with
| zero => rfl
| succ j => rfl
right_inv p := by
cases p
rfl
/-- Reverse-ordered half-product of completed-slice outcome operators. -/
noncomputable def gHatReverseHalfProductOutcomeOperator
(params : Parameters) [FieldModel params.q]
(family : IdxPolyFamily params ι) :
(k : ℕ) → PointTuple params k → GHatTupleOutcome params k → MIPStarRE.Quantum.Op ι
| 0, _xs, _gs =>
1
| k + 1, xs, gs =>
gHatReverseHalfProductOutcomeOperator params family k
(pointTupleTail xs) (gHatTupleOutcomeTail gs) *
((gHatIdxMeas params family (xs 0)).toSubMeas).outcome (gs 0)
/-- Ordered head-tail family with the head completed-slice operator followed
by the remaining half-product on the left tensor register. -/
noncomputable def headTailOrderedFamily
(params : Parameters) [FieldModel params.q]
(family : IdxPolyFamily params ι) (r : ℕ) :
IdxOpFamily
(SliceQuestion params × PointTuple params r)
(GHatOutcome params × GHatTupleOutcome params r)
(ι × ι) :=
fun q =>
{ outcome := fun ogs =>
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).outcome ogs.1) *
leftTensor (ι₂ := ι)
(gHatHalfProductOutcomeOperator params family r q.2 ogs.2)
total :=
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).total) *
leftTensor (ι₂ := ι) (gHatHalfProductTotalOperator params family r q.2) }
/-- Rotated head-tail family with the tail half-product placed before the head
completed-slice operator. -/
noncomputable def headTailRotatedFamily
(params : Parameters) [FieldModel params.q]
(family : IdxPolyFamily params ι) (r : ℕ) :
IdxOpFamily
(SliceQuestion params × PointTuple params r)
(GHatOutcome params × GHatTupleOutcome params r)
(ι × ι) :=
fun q =>
{ outcome := fun ogs =>
leftTensor (ι₂ := ι)
(gHatHalfProductOutcomeOperator params family r q.2 ogs.2) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).outcome ogs.1)
total :=
leftTensor (ι₂ := ι) (gHatHalfProductTotalOperator params family r q.2) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).total) }
/-- Move-family endpoint with two distinguished left-register factors and the
reverse half-product on the right register. -/
noncomputable def commuteGHalfSandwich_moveFamily
(params : Parameters) [FieldModel params.q]
(family : IdxPolyFamily params ι) (r : ℕ) :
IdxOpFamily
(SliceQuestion params × SliceQuestion params × PointTuple params r)
(GHatOutcome params × GHatOutcome params × GHatTupleOutcome params r)
(ι × ι) :=
fun q =>
{ outcome := fun ogs =>
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).outcome ogs.1) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.2.1).outcome ogs.2.1) *
rightTensor (ι₁ := ι)
(gHatReverseHalfProductOutcomeOperator params family r q.2.2 ogs.2.2)
total :=
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).total) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.2.1).total) *
rightTensor (ι₁ := ι)
(gHatHalfProductTotalOperator params family r q.2.2) }
/-- Commuted endpoint obtained by interchanging the two distinguished
left-register completed-slice factors. -/
noncomputable def commuteGHalfSandwich_commuteFamily
(params : Parameters) [FieldModel params.q]
(family : IdxPolyFamily params ι) (r : ℕ) :
IdxOpFamily
(SliceQuestion params × SliceQuestion params × PointTuple params r)
(GHatOutcome params × GHatOutcome params × GHatTupleOutcome params r)
(ι × ι) :=
fun q =>
{ outcome := fun ogs =>
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.2.1).outcome ogs.2.1) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).outcome ogs.1) *
rightTensor (ι₁ := ι)
(gHatReverseHalfProductOutcomeOperator params family r q.2.2 ogs.2.2)
total :=
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.2.1).total) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).total) *
rightTensor (ι₁ := ι)
(gHatHalfProductTotalOperator params family r q.2.2) }
/-! ### Base cases and consistency lifts -/
/-! ### Slice-front equivalences -/
/-- Move the third distinguished slice coordinate to the front while preserving
the other two distinguished coordinates and the tail. -/
def thirdSliceFrontEquiv (params : Parameters) (r : ℕ) :
(SliceQuestion params × SliceQuestion params × SliceQuestion params ×
PointTuple params r) ≃
(SliceQuestion params × (SliceQuestion params × SliceQuestion params ×
PointTuple params r)) where
toFun q := (q.2.2.1, (q.1, q.2.1, q.2.2.2))
invFun q := (q.2.1, q.2.2.1, q.1, q.2.2.2)
left_inv q := by
rcases q with ⟨x₁, x₂, x₃, xs⟩
rfl
right_inv q := by
rcases q with ⟨x₃, x₁, x₂, xs⟩
rfl
/-! ### Question/outcome equivalences -/
/-- Reassociate a head-tail slice question together with one additional slice
question as a move-chain question. -/
def splitQuestionEquiv (params : Parameters) (r : ℕ) :
((SliceQuestion params × PointTuple params r) × SliceQuestion params) ≃
(SliceQuestion params × SliceQuestion params × PointTuple params r) where
toFun q := (q.1.1, q.2, q.1.2)
invFun q := ((q.1, q.2.2), q.2.1)
left_inv q := by cases q; rfl
right_inv q := by cases q; rfl
/-- Outcome analogue of `splitQuestionEquiv`, with the additional completed-slice
outcome placed in the second distinguished position. -/
def prefixTripleOutcomeEquiv (params : Parameters) [FieldModel params.q] (r : ℕ) :
((GHatOutcome params × GHatTupleOutcome params r) × GHatOutcome params) ≃
(GHatOutcome params × GHatOutcome params × GHatTupleOutcome params r) where
toFun og := (og.1.1, og.2, og.1.2)
invFun og := ((og.1, og.2.2), og.2.1)
left_inv og := by cases og; rfl
right_inv og := by cases og; rfl
/-- Reassociate a pair of distinguished completed-slice outcomes and an outcome
tail as a move-chain outcome. -/
def pairTailOutcomeEquiv (params : Parameters) [FieldModel params.q] (r : ℕ) :
((GHatOutcome params × GHatOutcome params) × GHatTupleOutcome params r) ≃
(GHatOutcome params × GHatOutcome params × GHatTupleOutcome params r) where
toFun og := (og.1.1, og.1.2, og.2)
invFun og := ((og.1, og.2.1), og.2.2)
left_inv og := by cases og; rfl
right_inv og := by cases og; rfl
/-! ### Split-successor and move-tail equivalences -/
/-- Expose the first coordinate of a successor point tuple as the second
distinguished slice question. -/
def splitSuccQuestionEquiv (params : Parameters) (r : ℕ) :
(SliceQuestion params × PointTuple params (r + 1)) ≃
(SliceQuestion params × SliceQuestion params × PointTuple params r) where
toFun q := (q.1, q.2 0, pointTupleTail q.2)
invFun q := (q.1, Fin.cons q.2.1 q.2.2)
left_inv q := by
rcases q with ⟨x, xs⟩
change (x, Fin.cons (xs 0) (pointTupleTail xs)) = (x, xs)
congr
funext i
cases i using Fin.cases with
| zero => rfl
| succ j => rfl
right_inv q := by
cases q
rfl
/-- Outcome analogue of `splitSuccQuestionEquiv`. -/
def splitSuccOutcomeEquiv (params : Parameters) [FieldModel params.q] (r : ℕ) :
(GHatOutcome params × GHatTupleOutcome params (r + 1)) ≃
(GHatOutcome params × GHatOutcome params × GHatTupleOutcome params r) where
toFun og := (og.1, og.2 0, gHatTupleOutcomeTail og.2)
invFun og := (og.1, Fin.cons og.2.1 og.2.2)
left_inv og := by
rcases og with ⟨g, gs⟩
change (g, Fin.cons (gs 0) (gHatTupleOutcomeTail gs)) = (g, gs)
congr
funext i
cases i using Fin.cases with
| zero => rfl
| succ j => rfl
right_inv og := by
cases og
rfl
/-- Expose the first coordinate of the tail in a successor move question. -/
def moveTailQuestionEquiv (params : Parameters) (r : ℕ) :
(SliceQuestion params × SliceQuestion params × PointTuple params (r + 1)) ≃
(SliceQuestion params × SliceQuestion params × SliceQuestion params ×
PointTuple params r) where
toFun q := (q.1, q.2.1, q.2.2 0, pointTupleTail q.2.2)
invFun q := (q.1, q.2.1, Fin.cons q.2.2.1 q.2.2.2)
left_inv q := by
rcases q with ⟨x₁, x₂, xs⟩
change (x₁, x₂, Fin.cons (xs 0) (pointTupleTail xs)) = (x₁, x₂, xs)
congr
funext i
cases i using Fin.cases with
| zero => rfl
| succ j => rfl
right_inv q := by
cases q
rfl
/-- Outcome analogue of `moveTailQuestionEquiv`. -/
def moveTailOutcomeEquiv (params : Parameters) [FieldModel params.q] (r : ℕ) :
(GHatOutcome params × GHatOutcome params × GHatTupleOutcome params (r + 1)) ≃
(GHatOutcome params × GHatOutcome params × GHatOutcome params ×
GHatTupleOutcome params r) where
toFun og := (og.1, og.2.1, og.2.2 0, gHatTupleOutcomeTail og.2.2)
invFun og := (og.1, og.2.1, Fin.cons og.2.2.1 og.2.2.2)
left_inv og := by
rcases og with ⟨g₁, g₂, gs⟩
change (g₁, g₂, Fin.cons (gs 0) (gHatTupleOutcomeTail gs)) = (g₁, g₂, gs)
congr
funext i
cases i using Fin.cases with
| zero => rfl
| succ j => rfl
right_inv og := by
cases og
rfl
/-- Move a new leading slice coordinate from the product suffix to the front of
the exposed move-tail question. -/
def firstSliceBackQuestionEquiv (params : Parameters) (r : ℕ) :
((SliceQuestion params × SliceQuestion params × PointTuple params r) ×
SliceQuestion params) ≃
(SliceQuestion params × SliceQuestion params × SliceQuestion params ×
PointTuple params r) where
toFun q := (q.2, q.1.1, q.1.2.1, q.1.2.2)
invFun q := ((q.2.1, q.2.2.1, q.2.2.2), q.1)
left_inv q := by
rcases q with ⟨⟨x₂, x₃, xs⟩, x₁⟩
rfl
right_inv q := by
rcases q with ⟨x₁, x₂, x₃, xs⟩
rfl
/-- Outcome analogue of `firstSliceBackQuestionEquiv`. -/
def firstSliceBackOutcomeEquiv (params : Parameters) [FieldModel params.q] (r : ℕ) :
((GHatOutcome params × GHatOutcome params × GHatTupleOutcome params r) ×
GHatOutcome params) ≃
(GHatOutcome params × GHatOutcome params × GHatOutcome params ×
GHatTupleOutcome params r) where
toFun og := (og.2, og.1.1, og.1.2.1, og.1.2.2)
invFun og := ((og.2.1, og.2.2.1, og.2.2.2), og.1)
left_inv og := by
rcases og with ⟨⟨g₂, g₃, gs⟩, g₁⟩
rfl
right_inv og := by
rcases og with ⟨g₁, g₂, g₃, gs⟩
rfl
/-! ### Move-step and source families -/
/-- Target family for a single move step: the exposed tail coordinate and the
reverse tail half-product have been moved to the right tensor register. -/
noncomputable def commuteGHalfSandwich_moveStepTargetFamily
(params : Parameters) [FieldModel params.q]
(family : IdxPolyFamily params ι) (r : ℕ) :
IdxOpFamily
(SliceQuestion params × SliceQuestion params × SliceQuestion params × PointTuple params r)
(GHatOutcome params × GHatOutcome params × GHatOutcome params × GHatTupleOutcome params r)
(ι × ι) :=
fun q =>
{ outcome := fun ogs =>
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).outcome ogs.1) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.2.1).outcome ogs.2.1) *
rightTensor (ι₁ := ι)
(gHatReverseHalfProductOutcomeOperator params family r q.2.2.2 ogs.2.2.2) *
rightTensor (ι₁ := ι) ((gHatIdxMeas params family q.2.2.1).outcome ogs.2.2.1)
total :=
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).total) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.2.1).total) *
rightTensor (ι₁ := ι) ((gHatIdxMeas params family q.2.2.1).total) *
rightTensor (ι₁ := ι)
(gHatHalfProductTotalOperator params family r q.2.2.2) }
/-- Intermediate family for a move step, after the third distinguished
completed-slice operator but before that operator is moved to the right. -/
noncomputable def commuteGHalfSandwich_moveStepMidFamily
(params : Parameters) [FieldModel params.q]
(family : IdxPolyFamily params ι) (r : ℕ) :
IdxOpFamily
(SliceQuestion params × SliceQuestion params × SliceQuestion params × PointTuple params r)
(GHatOutcome params × GHatOutcome params × GHatOutcome params × GHatTupleOutcome params r)
(ι × ι) :=
fun q =>
{ outcome := fun ogs =>
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).outcome ogs.1) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.2.1).outcome ogs.2.1) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.2.2.1).outcome ogs.2.2.1) *
rightTensor (ι₁ := ι)
(gHatReverseHalfProductOutcomeOperator params family r q.2.2.2 ogs.2.2.2)
total :=
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).total) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.2.1).total) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.2.2.1).total) *
rightTensor (ι₁ := ι)
(gHatHalfProductTotalOperator params family r q.2.2.2) }
/-- Source endpoint of the move chain before the first tail coordinate has been
exposed. -/
noncomputable def commuteGHalfSandwich_moveSourceFamily
(params : Parameters) [FieldModel params.q]
(family : IdxPolyFamily params ι) (r : ℕ) :
IdxOpFamily
(SliceQuestion params × SliceQuestion params × PointTuple params r)
(GHatOutcome params × GHatOutcome params × GHatTupleOutcome params r)
(ι × ι) :=
fun q =>
{ outcome := fun ogs =>
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).outcome ogs.1) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.2.1).outcome ogs.2.1) *
leftTensor (ι₂ := ι)
(gHatHalfProductOutcomeOperator params family r q.2.2 ogs.2.2)
total :=
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.1).total) *
leftTensor (ι₂ := ι) ((gHatIdxMeas params family q.2.1).total) *
leftTensor (ι₂ := ι)
(gHatHalfProductTotalOperator params family r q.2.2) }
/-! ### Move-source splitting lemmas -/
/-! ### One-element tuple equivalences -/
/-- Identify a one-element point tuple with its unique slice question. -/
def pointTupleOneEquiv (params : Parameters) :
PointTuple params 1 ≃ SliceQuestion params where
toFun xs := xs 0
invFun x := fun _ => x
left_inv xs := by
funext i
fin_cases i
rfl
right_inv x := by rfl
/-- Identify a one-element completed-slice outcome tuple with its unique
outcome. -/
def gHatTupleOutcomeOneEquiv (params : Parameters) [FieldModel params.q] :
GHatTupleOutcome params 1 ≃ GHatOutcome params where
toFun gs := gs 0
invFun g := fun _ => g
left_inv gs := by
funext i
fin_cases i
rfl
right_inv g := by rfl
/-- Specialization of `splitQuestionEquiv` for a one-element tuple. -/
def splitQuestionEquivOne (params : Parameters) :
(SliceQuestion params × PointTuple params 1) ≃ SlicePairQuestion params where
toFun q := (q.1, (pointTupleOneEquiv params) q.2)
invFun q := (q.1, (pointTupleOneEquiv params).symm q.2)
left_inv q := by
rcases q with ⟨x, xs⟩
exact congrArg (fun ys => (x, ys)) ((pointTupleOneEquiv params).left_inv xs)
right_inv q := by
rcases q with ⟨x, y⟩
exact congrArg (fun ys => (x, ys)) ((pointTupleOneEquiv params).right_inv y)
/-- Outcome specialization matching `splitQuestionEquivOne`. -/
def splitOutcomeEquivOne (params : Parameters) [FieldModel params.q] :
(GHatOutcome params × GHatTupleOutcome params 1) ≃ (GHatOutcome params ×
GHatOutcome params) where
toFun og := (og.1, (gHatTupleOutcomeOneEquiv params) og.2)
invFun og := (og.1, (gHatTupleOutcomeOneEquiv params).symm og.2)
left_inv og := by
rcases og with ⟨g, gs⟩
exact congrArg (fun hs => (g, hs)) ((gHatTupleOutcomeOneEquiv params).left_inv gs)
right_inv og := by
rcases og with ⟨g₁, g₂⟩
exact congrArg (fun hs => (g₁, hs)) ((gHatTupleOutcomeOneEquiv params).right_inv g₂)
/-! ### Outcome slice-front equivalences -/
/-- Outcome analogue of `thirdSliceFrontEquiv`. -/
def thirdSliceFrontOutcomeEquiv (params : Parameters) [FieldModel params.q] (r : ℕ) :
(GHatOutcome params ×
((GHatOutcome params × GHatOutcome params) × GHatTupleOutcome params r)) ≃
(GHatOutcome params × GHatOutcome params × GHatOutcome params ×
GHatTupleOutcome params r) where
toFun og := (og.2.1.1, og.2.1.2, og.1, og.2.2)
invFun og := (og.2.2.1, ((og.1, og.2.1), og.2.2.2))
left_inv og := by
rcases og with ⟨g₃, ⟨⟨g₁, g₂⟩, gs⟩⟩
rfl
right_inv og := by
rcases og with ⟨g₁, g₂, g₃, gs⟩
rfl
end MIPStarRE.LDT.Pasting
end
end LIDT
Source