Add lean source and binary files (part 87)

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum.lean

@@ -0,0 +1,940 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.ClockPathBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.ClockWeightedBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAcceptance
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAdjacentCnot
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAdjacentProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAlgebraicHeight
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAlgebraicHistory
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAlgebraicScalar
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAlgebraicScalarProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAnchorDensity
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAncilla
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAncillaCompression
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAncillaCount
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAxisSample
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAxisSampleAccuracy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAxisSampleProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBitTransfer
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBlockBasis
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBlockBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBlockCoefficientBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBlockEdges
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBlockExchange
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBlockFull
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBlockHamiltonian
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBlockRational
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedArmProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedArms
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedCells
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedCongestion
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedCounts
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedDetour
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedDogleg
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedEndpointWalk
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedExtent
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedFanout
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedGridEdge
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedIntersections
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedLanes
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedListProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedNodes
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedPortChain
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedPortLinks
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedPortRealization
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedRay
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedSharedEdge
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedSourceCells
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumBufferedSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCellCatalogProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCellCorridor
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCellCrossings
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCellMatching
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCellPassages
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCellPathProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCellPathTemplates
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCellRouteCatalog
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCellRouteSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCellTranslate
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCellVisitPaths
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumChosenSlots
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCircuitCode
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCircuitPadding
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCircuitPauli
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCircuitPromise
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCircuitTwoLocal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumClockAnchor
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumClockCells
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumClockPath
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumClockSector
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumClockStep
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumClockTransition
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCoefficientEnvelopeProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCoefficientHeight
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCoefficientPrograms
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCoerciveInverse
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumComputedAccuracy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumComputedCrossingBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumComputedCrossingRelabel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumComputedRouteSelector
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumComputedRoutingTable
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCoordinateSpectrum
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCornerPatch
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCorridorEndpoints
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCorridorInterior
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCorridorSeparation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCountedHistory
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCountertermProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCountertermSample
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingCalibration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingCoefficientBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingCompiled
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingDirections
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingEffective
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingGraph
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingListActual
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingListBlock
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingListFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingListLayer
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingListMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingListSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingMove
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingOutputRoutes
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingPacketBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingPacketEnergy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingPairSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingParallel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingPatch
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingPatchChart
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingPlacement
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingPlanarRoutes
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingPorts
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingPositionProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingPositionRelabel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingRetention
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingScaleProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingSelectCorrectness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingSelectFromSites
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingSelectProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingSelection
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingSelectionRelabel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingSelectionUnique
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingSiteProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingSiteRelabel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingSites
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingSize
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingSpectrum
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingSupportRelabel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingsGraph
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDefinedRealization
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDegreeReduction
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDescriptorSiteProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDescriptorSites
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDiagonalTableProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDiagonalTensor
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDistinctCrossings
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDistributedClock
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDistributedFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDistributedGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDistributedInput
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDistributedMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDistributedPositive
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDistributedRebit
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDistributedSpectrum
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumDistributedWitness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEightBasis
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEndpoint
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEndpointListProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEndpointPorts
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEndpointRelabel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEntryParity
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEvenListPieces
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEvenRouteData
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEvenRouteLabels
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEvenRoutePlacement
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEvenRouteRealization
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEvenTapeGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEvenTapeOrder
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEvenTapeOutputBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEvenTapeProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEvenTapeWeights
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumEvolution
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumExchangeCrossings
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumExchangeLanes
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumExchangeRounding
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumExchangeRoutes
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumExchangeSample
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumExchangeSampleProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFanoutPaths
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFanoutPorts
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFieldSample
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFinalPrecision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFinalRoutingProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFineRoute
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFiniteHistory
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFiniteMembership
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFiniteRouteSearch
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFirstUse
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFirstUseProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFirstUseSites
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFixedMatrixProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFixedPauli
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFixedPauliProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkBackground
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkCalibration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkCells
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkDegreeBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkDegrees
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkEffective
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkGraph
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkGridInitial
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkGridProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkInitial
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkInitialCells
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkInitialLocality
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkInitialMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkInitialSize
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkIteration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListAccuracy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListActive
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListBackground
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListBoundProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListCalibration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListCellIteration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListCellLocality
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListCellMass
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListCellProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListCells
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListData
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListDegree
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListDegreeIteration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListEnvelope
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListFinalDegree
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListFullCells
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListFullDegree
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListGraph
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListIndex
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitial
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialAccuracy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialCalibration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialCellMass
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialCells
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialDegree
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialPairs
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialPhysical
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialRealization
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialSpatial
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialStateProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialSum
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListInitialWeights
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListIterateWeights
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListIteration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListNext
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListNextBackground
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListNextDegree
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListNextPorts
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListNextValid
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListNextWeights
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListOrdinal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListOuter
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListOutputBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListPartition
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListPoints
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListRealization
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListRound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListSites
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListSize
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListSpatialPackage
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListSum
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkListWeights
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkLocality
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkParallel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkPatch
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkPlaced
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkPortSums
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkPorts
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkRounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkRoutingData
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkRoutingPaths
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkSpectrum
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkStarGround
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkStarIndex
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkState
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkStateAccuracy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkStateDegree
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkStateMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkStateNextMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumForkWeightBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourAxis
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourBasis
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourCorrelation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourCorrelationCertificate
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourCounterterm
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourCouplingBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourCouplingScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourCross
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourDoubleGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourEffective
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourEncoding
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourFields
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourGapCertificate
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourGround
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourIsometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourLogical
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourNorm
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourPositive
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourProjector
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourSpatial
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourSpin
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourSpinCertificate
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourSpinTable
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourSpinTransition
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourStencils
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorCoefficientBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorComparison
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorCompression
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorCross
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorEffective
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorEffectiveError
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorError
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorFamilyAccuracy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorFamilyBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorFields
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorForms
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorFullFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorGap
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorGround
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorHilbert
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorInverse
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorNorm
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorOnsite
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorOperatorBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorOrthogonal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorSpin
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourTensorWeighted
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFourWeighted
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGadgetAlgebra
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGadgetCounterterms
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGateArrival
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGateCode
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGateEntryProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGateLocality
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGateProduct
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGateScalarReduction
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGateUnitary
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGates
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGeometryPowers
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGraphCoefficientBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGraphDegree
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridAcceptance
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridCircuit
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridColor
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridFrame
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridLocality
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridMidpoint
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridNeighbors
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridNeighborsFour
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridPorts
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridSlots
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridWalk
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGroundComparison
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHalfCorridor
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistory
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryBitProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryCellProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryCells
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryComparison
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryDegree
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryDelta
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryDeltaProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryDescriptorProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryDescriptors
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryDiagonal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryDiagonalProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryEnergy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryEnumeration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryFork
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryHeight
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryIncidence
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryLattice
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryLiteralCorrectness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryLiteralPromise
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryMatrixForm
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryOutputBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryParameterBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryPrecisionProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryPreparedProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryRawCells
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryRoutedEnergy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryRoutingProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistorySamplerProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistorySampling
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistorySiteProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistorySizeBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistorySourcePowers
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistorySourceProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistorySourcePromise
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistorySpatial
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistorySpatialProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistorySpectrum
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryTableCorrectness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryTableProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryThreeLocal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryThreeLocalEnergy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryWitness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryXZ
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryXZBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryXZPromise
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumInflatedListProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumInflatedPath
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumInflatedSeparation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumInnerPorts
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumInputProjection
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumInternalHalfSeparation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumInternalRouteSeparation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLaneSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLaneUnaryProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLatticeCoefficient
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLatticeEncoding
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLatticeEnvelope
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLatticePromise
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLatticeSerialization
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLatticeSource
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLatticeSourceBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListGraph
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListLattice
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListLatticeProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListMerge
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListMergeMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListMergeProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListMergeProperties
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListPathAccuracy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListPathInput
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListPathMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListPathProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListPathStep
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListRouteLattice
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListRouteMatching
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListRouteNextPoint
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListRouteNextPosition
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListRouteNextWork
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListRouteOutputBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListRouteOutputProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListRoutePathOrder
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListRoutePieces
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListRoutePreservation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListRouteProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListRouteRepresentation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListRouteSelection
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListSchedule
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListScheduleBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListScheduleGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListScheduleGraph
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListScheduleLabels
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListScheduleOrder
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListScheduleProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListScheduleRealization
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListScheduleRelabel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListScheduleScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListScheduleWeights
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalAction
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalCoordinates
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalCore
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalDecomposition
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalEnlarge
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalError
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalInput
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalJoin
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalLift
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalModel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalPathClearance
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalPauli
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalPenalties
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalPropagation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalRealification
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalSubdivision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalSupported
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalTensor
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalThird
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalThirdSupported
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumManhattanListProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumManhattanRoute
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumManhattanSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumMappedGate
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumMask
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumMatrixError
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumMediatorGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumMergeEdges
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumMergedCoefficientBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumMergedEndpointPairs
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumMergedOutputRoutes
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumMergedSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumNearestCircuit
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumNearestGate
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumNearestProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOddPathGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOffsetProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOffsetSample
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOperatorQuadratic
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedCellProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedCellTable
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedCoefficient
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedDescriptorProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedDescriptors
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedFinalBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedHistory
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedIncidence
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelBlocks
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelCompile
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelCorrectness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelData
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelEnergy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelOutput
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelPacking
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelPipeline
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelSubdivision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelTable
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelThird
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelYY
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedModel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedOutputBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedOutputSpatial
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedPrivate
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedPrivateSpatial
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedRawBlock
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedRawCells
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedRawPacking
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedRawPackingProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedReference
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedSampling
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedSourceIndex
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedSpatial
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedSpatialComplete
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedSpatialSites
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedSplit
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedSubdivision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedTable
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedThird
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedThirdSites
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedThirdXZ
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedTriple
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedTripleFactors
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedTwoStage
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedWeightBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedWeightProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedXZEnergy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedXZPipeline
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedXZTerm
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedYYFactors
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedYYReduction
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrdinalPlacement
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrdinalProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrdinalSlots
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrdinalSpatial
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPackedSchedule
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPacketGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPacketRoutingGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedBasis
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedEvolution
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedGate
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedHistory
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedInput
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedLabelData
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedLabelEnergy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedLabelMeaning
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedLabelProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedLabelTable
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedLocal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedPacketProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedPauli
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedSampling
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPaddedTableProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPairDedup
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumParallelGraph
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumParallelRouteSearch
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPartialPaths
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPatchEdgeCover
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPatchPhysical
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPatchPoints
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPatchSeparation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathCoverage
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathCoverageReverse
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathDegrees
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathEmbedding
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathIteratedBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathPatch
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathPieces
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathPlacement
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathPolynomialBound
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathRelabeling
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathRelabelingIteration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathRelabelingNext
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathRelabelingProperties
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathScaleProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathSchedule
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathScheduleSize
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathSpectrum
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathSubdivision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathTable
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathVisitCorrectness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathVisitProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathWeightBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathsCalibration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathsGraph
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPathsParallel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliAlgebra
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliBasis
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliCongestion
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliExpansion
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliExtend
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliLocal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliMonomial
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliParity
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliProduct
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliReal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliRounding
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliSingle
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliSplit
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliSubdivision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliThird
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliTripleSplit
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPermittedEndpointAvoidance
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPermittedRouteSeparation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPhysicalCells
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPhysicalEndpointCover
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPinnedClock
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPlanarDegree
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPlanarListData
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPlanarRelabel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPlanarRouteData
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPlanarRouteRealization
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPlanarSelectorTransport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPlanarTapeGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPlanarTapeProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPlanarTapeSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPolarizedSubdivision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPolarizedThird
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPolynomialUnary
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortCellPositive
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortChain
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortChainActual
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortChainBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortChainProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortChainSeparation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortCrossingSelection
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortGraphPairs
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortInnerPair
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortLinks
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortPairing
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortPlanarRealization
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortRank
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortRankActual
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortRankProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortRaySupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortRouteData
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortScheduleActual
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortSchedulePacking
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortScheduleTape
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortSelectionProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPortSpinCoverage
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPrefix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPreparedCircuit
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPreparedLattice
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPreparedVerifier
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPrivateAccuracy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPrivateCompiler
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPrivateFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPrivateList
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPrivateProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPrivateRaw
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPrivateSupported
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPrivateTerms
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPromisePowers
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPropagationAction
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPropagationOrder
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPropagationSampler
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPropagationSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPropagationTable
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumQuadratic
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumQuadraticReindex
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRationalCrossing
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRationalDegreeReduction
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRationalFork
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRationalPathStep
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRationalSpatialPackage
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawCellDensity
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawCellLocality
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawCoefficientBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawCompiler
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawCorrectness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawEnvelope
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawExchange
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawFamilyCorrectness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawFamilyProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawIncidence
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawOutputBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawOutputSize
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawSchedule
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawTermProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRealCircuit
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRealLocalFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRealification
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRebitDiagonal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRebitLocal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRebitSoundness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRectangularOperator
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceBasis
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceBlocks
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceComparison
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceCongestion
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceEdgeTable
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceEdges
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceHistory
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceLocal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceLower
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceModel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferencePenalty
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceReal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceTensor
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceTerms
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumReferenceWalls
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRetainedCrossing
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRetainedGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRetainedRoutes
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRetainedSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRouteCandidates
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRouteCongestion
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRouteEnumeration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRouteLanes
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRouteLeaf
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRouteLeafProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutePermissionCongr
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRouteProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRouteSelectorCorrectness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRouteSelectorProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutedSubdivision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingBlocks
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingCrossingTest
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingForms
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingGraph
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingInputActual
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingInputProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingPhysical
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingSize
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingSpectrum
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingTable
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingTableCorrectness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRowInsertion
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRowOrder
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRowStageBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRowStageSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRowTransfer
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSampleAssembly
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSampleBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSamplePrecision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumScalarFaithful
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumScalarReindex
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumScaledDirection
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumScaledEdge
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumScheduleCrossingGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSelectedRoute
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSingletStar
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSingletStarBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSingletStarSpectrum
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSortedTime
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSoundness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpacedListProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSparseEndpoint
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSparseFirstUse
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialCircuit
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialClockTerms
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialCrossingGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialCrossingProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialCrossingSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialDegreeReduction
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialDegreeThree
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialExchange
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialExchangeCircuit
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialExchangeModel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialFinalCount
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialFinalEnergy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialFinalGeometry
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialGadgets
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialInput
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialInputBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialInputTape
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialLattice
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialModel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialOccupancy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialPlaced
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialPlanarBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialPlanarRealization
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialPortBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialPortMatching
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialPortProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialPrivate
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialPropagation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialRational
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialReference
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialReindex
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialRoutingTape
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialSlotProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialSourcePromise
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialSubdivision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialTerms
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialThird
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialTotal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialXZ
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialXZBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpecifiedLattice
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumStageIndex
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumStagePath
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumStageStep
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSubdivisionSites
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSupportDedup
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSupportLookup
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSupportedSubdivision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSupportedThird
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSwapConjugation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSweepCellProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSweepCells
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSweepCircuit
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSweepCongestion
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSweepCoverage
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSweepCursor
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSweepEndpoint
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSweepIndex
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSweepListProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSweepProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTaggedRouteProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTaggedStage
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTaggedSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTaggedSweep
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTaggedTransfer
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTensorAction
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTensorMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTensorPair
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTensorPairLinear
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTensorSucc
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTermTime
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumThirdCounterterm
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTimeCongestion
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTimeGrouping
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTransferGate
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTransferIndex
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTransferSweep
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTranslatedInternalSeparation
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTranslatedPatch
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumTripleSupported
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnaryClock
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnaryEmbedding
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnaryEmbeddingEnergy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnaryEnergy
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnaryForm
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnaryMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnaryPenalty
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnaryPrefix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnaryPrefixCertificate
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnaryPrefixRun
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnaryPrefixTransfers
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnarySoundness
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnarySpectrum
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUnitaryGround
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumUntouchedInput
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumVerifier
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumWalkErasure
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumWalkErasureProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumWalkSeek
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumWalkSupport
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumWireGrid
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumWireIntertwining
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumWireRelabel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumWireRouting
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumWireState
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumWireSwap
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZEnvelopes
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZFamilySplit
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZHeisenberg
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZModel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZPrivate
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZReduction
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZSample
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZScalarSample
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZSubdivision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZSupportFactors
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZSupported
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZTerms
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZThird
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZThirdSupported
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumXZTriple
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumYYElimination
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumYYFactor
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumYYReduction
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumYYSupported
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorAncilla
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorForms
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorGround
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorHilbert
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorNorm
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorNormBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorPenalty
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorPhysical
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorProjection
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorSeriesError
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorSeriesMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorTargetGround
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorThirdForm
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitMediatorTrial
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitPhase
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitPhaseLocal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitPhasePhysical
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitPhysicalComparison
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitSubdivisionCalibration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitSubdivisionDecomposition
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitSubdivisionEnvelope
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitSubdivisionGadget
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitSubdivisionGround
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitSubdivisionHermitian
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitSubdivisionLocalFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitSubdivisionMatrix
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitSubdivisionNorm
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitSubdivisionReal
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitSubdivisionScale
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitThirdCalibration
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitThirdDecomposition
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitThirdEnvelope
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitThirdFamilyBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitThirdGadget
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitThirdHermitian
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitThirdLocalFamily
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitThirdLocality
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitThirdNormBudget
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitThirdPhased
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QubitThirdPhasedLocal

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumLocalPathClearance.lean

@@ -0,0 +1,44 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHalfCorridor
+
+namespace OAI
+
+/-! Exact endpoint clearance inside one cell. These finite facts separate
+external corridors from the rays, ordinary pairs and nine gadget paths. -/
+
+namespace ContinuumCoulomb
+
+def qmaLocalPhysicalSites (cross : Bool) : Finset (ℕ × ℕ) :=
+  if cross then {(16,16),(10,16),(16,22),(22,16),(16,10),(14,18),(18,14)}
+  else {(16,16),(23,16),(16,23),(9,16),(16,9)}
+
+theorem qmaHalfCorridor_sites (cross : Bool) (a : Fin 4) :
+    Disjoint ((qmaHalfCorridorPath cross a).drop 1).toFinset (qmaLocalPhysicalSites cross) := by
+  cases cross <;> fin_cases a <;> decide
+
+theorem qmaCellRay_sites (a : Fin 4) :
+    Disjoint (((qmaCellRayPath a).drop 1).dropLast).toFinset (qmaLocalPhysicalSites false) := by
+  fin_cases a <;> decide
+
+theorem qmaLocalPatch_sites (e : Fin 9) :
+    Disjoint (((qmaLocalPatchPath e).drop 1).dropLast).toFinset (qmaLocalPhysicalSites true) := by
+  fin_cases e <;> decide
+
+theorem qmaCellPair_half (e : Fin 6) (a : Fin 4) :
+    Disjoint (((qmaCellPairPath e).drop 1).dropLast).toFinset (qmaHalfCorridorPath false a).toFinset := by
+  fin_cases e <;> fin_cases a <;> decide
+
+theorem qmaCellRay_half (e a : Fin 4) :
+    Disjoint (((qmaCellRayPath e).drop 1).dropLast).toFinset (qmaHalfCorridorPath false a).toFinset := by
+  fin_cases e <;> fin_cases a <;> decide
+
+theorem qmaLocalPatch_half (e : Fin 9) (a : Fin 4) :
+    Disjoint (((qmaLocalPatchPath e).drop 1).dropLast).toFinset (qmaHalfCorridorPath true a).toFinset := by
+  fin_cases e <;> fin_cases a <;> decide
+
+theorem qmaLocalPatch_bounded (e : Fin 9) :
+    ∀ p ∈ qmaLocalPatchPath e, 10 ≤ p.1 ∧ p.1 ≤ 22 ∧ 10 ≤ p.2 ∧ p.2 ≤ 22 := by
+  fin_cases e <;> decide
+
+end ContinuumCoulomb
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumLocalPauli.lean

@@ -0,0 +1,91 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliExtend
+
+namespace OAI
+
+/-! A bounded-support real family expands into only even-Y Pauli words. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped BigOperators Classical
+variable {ι α : Type*} [Fintype ι] [DecidableEq ι] [Fintype α]
+
+abbrev QMALocalPauliTerm (S : α → Finset ι) :=
+  (a : α) × ({i // i ∈ S a} → Fin 4)
+
+abbrev QMALocalEvenPauliTerm (S : α → Finset ι) :=
+  {p : QMALocalPauliTerm S // Even (qmaPauliYCount p.2)}
+
+def qmaLocalPauliWord (S : α → Finset ι) (p : QMALocalPauliTerm S) : ι → Fin 4 :=
+  qmaPauliExtend (S p.1) p.2
+
+def qmaLocalPauliCoefficient (F : α → Matrix (ι → Fin 2) (ι → Fin 2) ℂ)
+    (S : α → Finset ι) (p : QMALocalPauliTerm S) : ℝ :=
+  (qmaPauliCoefficient (qmaLocalCore (S p.1) (F p.1)) p.2).re
+
+def qmaLocalPauliMatrix (F : α → Matrix (ι → Fin 2) (ι → Fin 2) ℂ)
+    (S : α → Finset ι) (p : QMALocalPauliTerm S) : Matrix (ι → Fin 2) (ι → Fin 2) ℂ :=
+  (qmaLocalPauliCoefficient F S p : ℂ) • qmaPauliWord (qmaLocalPauliWord S p)
+
+theorem qmaLocalPauli_sum (F : α → Matrix (ι → Fin 2) (ι → Fin 2) ℂ)
+    (S : α → Finset ι) (hF : ∀ a, QMALocalOn (S a) (F a)) (hH : ∀ a, (F a).IsHermitian) :
+    (∑ p : QMALocalPauliTerm S, qmaLocalPauliMatrix F S p) = ∑ a, F a := by
+  rw [Fintype.sum_sigma]
+  apply Finset.sum_congr rfl
+  intro a _
+  simp only [qmaLocalPauliMatrix,qmaLocalPauliWord,qmaPauliExtend_lift]
+  exact (hF a).pauli_expansion (hH a)
+
+omit [Fintype α] in
+theorem qmaLocalPauli_odd_zero (F : α → Matrix (ι → Fin 2) (ι → Fin 2) ℂ)
+    (S : α → Finset ι) (hH : ∀ a, (F a).IsHermitian)
+    (hR : ∀ a, QMAEntryParity false (F a)) (p : QMALocalPauliTerm S)
+    (hp : Odd (qmaPauliYCount p.2)) : qmaLocalPauliMatrix F S p = 0 := by
+  have he := qmaPauliCoefficient_odd_zero (qmaLocalCore (S p.1) (F p.1))
+    (qmaLocalCore_hermitian _ _ (hH p.1)) (qmaLocalCore_real _ _ (hR p.1)) p.2 hp
+  simp only [qmaLocalPauliMatrix,qmaLocalPauliCoefficient,he,Complex.zero_re,
+    Complex.ofReal_zero,zero_smul]
+
+theorem qmaLocalEvenPauli_sum (F : α → Matrix (ι → Fin 2) (ι → Fin 2) ℂ)
+    (S : α → Finset ι) (hF : ∀ a, QMALocalOn (S a) (F a)) (hH : ∀ a, (F a).IsHermitian)
+    (hR : ∀ a, QMAEntryParity false (F a)) :
+    (∑ p : QMALocalEvenPauliTerm S, qmaLocalPauliMatrix F S p.val) = ∑ a, F a := by
+  rw [← qmaLocalPauli_sum F S hF hH]
+  let T : Finset (QMALocalPauliTerm S) := Finset.univ.filter (fun p => Even (qmaPauliYCount p.2))
+  have hsub := Finset.sum_subtype (F := inferInstance) T
+    (by simp [T] : ∀ p, p ∈ T ↔ Even (qmaPauliYCount p.2)) (qmaLocalPauliMatrix F S)
+  rw [← hsub]
+  apply Finset.sum_subset (Finset.subset_univ T)
+  intro p _ hp
+  have hn : ¬Even (qmaPauliYCount p.2) := by simpa [T] using hp
+  exact qmaLocalPauli_odd_zero F S hH hR p ((Nat.even_or_odd _).resolve_left hn)
+
+omit [Fintype ι] in
+theorem qmaLocalEvenPauli_count (S : α → Finset ι) {d : ℕ} (hS : ∀ a, (S a).card ≤ d) :
+    Fintype.card (QMALocalEvenPauliTerm S) ≤ 4^d*Fintype.card α := by
+  apply (Fintype.card_subtype_le _).trans
+  calc
+    Fintype.card (QMALocalPauliTerm S) = ∑ a : α, 4^(S a).card := by
+      simp only [QMALocalPauliTerm,Fintype.card_sigma,Fintype.card_fun,Fintype.card_fin,
+        Fintype.card_coe]
+    _ ≤ ∑ _a : α, 4^d := Finset.sum_le_sum (fun a _ =>
+      pow_le_pow_right₀ (by norm_num : (1:ℕ) ≤ 4) (hS a))
+    _ = _ := by simp [Nat.mul_comm]
+
+omit [Fintype α] in
+theorem qmaLocalEvenPauli_support (S : α → Finset ι) {d : ℕ}
+    (hS : ∀ a, (S a).card ≤ d) (p : QMALocalEvenPauliTerm S) :
+    (qmaPauliSupport (qmaLocalPauliWord S p.val)).card ≤ d :=
+  (Finset.card_le_card (qmaPauliExtend_support _ _)).trans (hS p.val.1)
+
+omit [Fintype α] in
+theorem qmaLocalEvenPauli_even (S : α → Finset ι) (p : QMALocalEvenPauliTerm S) :
+    Even (qmaPauliYCount (qmaLocalPauliWord S p.val)) := by
+  rw [qmaLocalPauliWord,qmaPauliExtend_yCount]
+  exact p.property
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumLocalPenalties.lean

@@ -0,0 +1,79 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalPropagation
+
+namespace OAI
+
+/-! The clock and endpoint penalties are explicit one- and two-qubit terms. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped BigOperators Classical
+
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+def qmaBitDiagonal (i : ι) (f : Fin 2 → ℂ) : Matrix (ι → Fin 2) (ι → Fin 2) ℂ :=
+  Matrix.diagonal (fun s => f (s i))
+
+def qmaPairDiagonal (i j : ι) (f : Fin 2 → Fin 2 → ℂ) :
+    Matrix (ι → Fin 2) (ι → Fin 2) ℂ :=
+  Matrix.diagonal (fun s => f (s i) (s j))
+
+theorem qmaBitDiagonal_local (i : ι) (f : Fin 2 → ℂ) :
+    QMALocalOn {i} (qmaBitDiagonal i f) := by
+  apply qmaLocalOn_diagonal
+  intro s t h
+  rw [h i (by simp)]
+
+theorem qmaPairDiagonal_local (i j : ι) (f : Fin 2 → Fin 2 → ℂ) :
+    QMALocalOn {i,j} (qmaPairDiagonal i j f) := by
+  apply qmaLocalOn_diagonal
+  intro s t h
+  rw [h i (by simp),h j (by simp)]
+
+def qmaClockFaultTerm (c : QMACircuit) (i : Fin (c.gates.length+1)) :
+    Matrix (QMACircuitQubit c → Fin 2) (QMACircuitQubit c → Fin 2) ℂ :=
+  qmaPairDiagonal (Sum.inl i.castSucc) (Sum.inl i.succ)
+    (fun a b => if a = 0 ∧ b = 1 then 1 else 0)
+
+def qmaClockLeftTerm (c : QMACircuit) :
+    Matrix (QMACircuitQubit c → Fin 2) (QMACircuitQubit c → Fin 2) ℂ :=
+  qmaBitDiagonal (Sum.inl 0) (fun a => if a = 1 then 0 else 1)
+
+def qmaClockRightTerm (c : QMACircuit) :
+    Matrix (QMACircuitQubit c → Fin 2) (QMACircuitQubit c → Fin 2) ℂ :=
+  qmaBitDiagonal (Sum.inl (Fin.last (c.gates.length+1))) (fun a => if a = 0 then 0 else 1)
+
+def qmaInputTerm (c : QMACircuit) (i : Fin (c.work+1)) :
+    Matrix (QMACircuitQubit c → Fin 2) (QMACircuitQubit c → Fin 2) ℂ :=
+  qmaPairDiagonal (Sum.inl (qmaInputMarker c)) (Sum.inr i)
+    (fun a b => if a = 0 then if c.witness ≤ i.val ∧ b ≠ 0 then 7 else 0 else 0)
+
+def qmaOutputTerm (c : QMACircuit) :
+    Matrix (QMACircuitQubit c → Fin 2) (QMACircuitQubit c → Fin 2) ℂ :=
+  qmaPairDiagonal (Sum.inl (qmaOutputMarker c)) (Sum.inr (Fin.last c.work))
+    (fun a b => if a = 1 ∧ b ≠ 1 then 1 else 0)
+
+theorem qmaClockFaultTerm_local (c : QMACircuit) (i : Fin (c.gates.length+1)) :
+    QMALocalOn {Sum.inl i.castSucc,Sum.inl i.succ} (qmaClockFaultTerm c i) :=
+  qmaPairDiagonal_local _ _ _
+
+theorem qmaClockLeftTerm_local (c : QMACircuit) :
+    QMALocalOn {Sum.inl 0} (qmaClockLeftTerm c) := qmaBitDiagonal_local _ _
+
+theorem qmaClockRightTerm_local (c : QMACircuit) :
+    QMALocalOn {Sum.inl (Fin.last (c.gates.length+1))} (qmaClockRightTerm c) :=
+  qmaBitDiagonal_local _ _
+
+theorem qmaInputTerm_local (c : QMACircuit) (i : Fin (c.work+1)) :
+    QMALocalOn {Sum.inl (qmaInputMarker c),Sum.inr i} (qmaInputTerm c i) :=
+  qmaPairDiagonal_local _ _ _
+
+theorem qmaOutputTerm_local (c : QMACircuit) :
+    QMALocalOn {Sum.inl (qmaOutputMarker c),Sum.inr (Fin.last c.work)} (qmaOutputTerm c) :=
+  qmaPairDiagonal_local _ _ _
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumLocalPropagation.lean

@@ -0,0 +1,87 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalAction
+
+namespace OAI
+
+/-! Every guarded propagation term acts on three clock bits and at most two
+computation bits. This is the actual unary-clock operator. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped BigOperators Classical
+
+abbrev QMACircuitQubit (c : QMACircuit) := Fin (c.gates.length+2) ⊕ Fin (c.work+1)
+
+def qmaCircuitQubitSplit (c : QMACircuit) :
+    (QMACircuitQubit c → Fin 2) ≃ QMAUnaryBasis c :=
+  Equiv.sumArrowEquivProdArrow _ _ _
+
+def qmaPropagationSites (c : QMACircuit) (t : Fin c.gates.length) : Finset (QMACircuitQubit c) :=
+  {Sum.inl (qmaClockLeft c.gates.length t),Sum.inl (qmaClockMiddle c.gates.length t),
+    Sum.inl (qmaClockRight c.gates.length t)} ∪
+    (qmaGateSites c.work (c.gates.getD t.val (.hadamard 0))).map Function.Embedding.inr
+
+theorem qmaPropagationSites_card (c : QMACircuit) (t : Fin c.gates.length) :
+    (qmaPropagationSites c t).card ≤ 5 := by
+  have h := Finset.card_union_le
+    ({Sum.inl (qmaClockLeft c.gates.length t),Sum.inl (qmaClockMiddle c.gates.length t),
+      Sum.inl (qmaClockRight c.gates.length t)} : Finset (QMACircuitQubit c))
+    ((qmaGateSites c.work (c.gates.getD t.val (.hadamard 0))).map Function.Embedding.inr)
+  have hclock : ({Sum.inl (qmaClockLeft c.gates.length t),
+      Sum.inl (qmaClockMiddle c.gates.length t),Sum.inl (qmaClockRight c.gates.length t)} :
+      Finset (QMACircuitQubit c)).card ≤ 3 := by
+    apply le_trans (Finset.card_insert_le _ _)
+    have h2 := Finset.card_insert_le (Sum.inl (qmaClockMiddle c.gates.length t))
+      ({Sum.inl (qmaClockRight c.gates.length t)} : Finset (QMACircuitQubit c))
+    simp only [Finset.card_singleton] at h2
+    omega
+  have hgate := qmaGateSites_card c.work (c.gates.getD t.val (.hadamard 0))
+  simp only [Finset.card_map] at h
+  unfold qmaPropagationSites
+  omega
+
+def qmaGuardProjection (c : QMACircuit) (t : Fin c.gates.length) :
+    Matrix (QMACircuitQubit c → Fin 2) (QMACircuitQubit c → Fin 2) ℂ :=
+  Matrix.diagonal (fun s => if QMAClockGuard c.gates.length t (s ∘ Sum.inl) ∧
+    s (Sum.inl (qmaClockMiddle c.gates.length t)) = 0 then 1 else 0)
+
+def qmaLocalPropagationDelta (c : QMACircuit) (t : Fin c.gates.length) :
+    Matrix (QMACircuitQubit c → Fin 2) (QMACircuitQubit c → Fin 2) ℂ :=
+  qmaGuardProjection c t *
+    (qmaBitFlipMatrix (Sum.inl (qmaClockMiddle c.gates.length t))-
+      qmaJoinMatrix 1 (qmaStepMatrix c t.val))
+
+theorem qmaGuardProjection_local (c : QMACircuit) (t : Fin c.gates.length) :
+    QMALocalOn (qmaPropagationSites c t) (qmaGuardProjection c t) := by
+  apply qmaLocalOn_diagonal
+  intro s r h
+  have hl := h (Sum.inl (qmaClockLeft c.gates.length t)) (by simp [qmaPropagationSites])
+  have hm := h (Sum.inl (qmaClockMiddle c.gates.length t)) (by simp [qmaPropagationSites])
+  have hr := h (Sum.inl (qmaClockRight c.gates.length t)) (by simp [qmaPropagationSites])
+  simp only [QMAClockGuard,Function.comp_apply,hl,hm,hr]
+  split_ifs with hp
+  · exact (ite_eq_left hp).symm
+  · exact (ite_eq_right hp).symm
+
+theorem qmaLocalPropagationDelta_local (c : QMACircuit) (t : Fin c.gates.length) :
+    QMALocalOn (qmaPropagationSites c t) (qmaLocalPropagationDelta c t) := by
+  have hf := (qmaBitFlipMatrix_local (Sum.inl (qmaClockMiddle c.gates.length t))).mono
+    (T := qmaPropagationSites c t)
+    (by intro i hi; simp only [Finset.mem_singleton] at hi; subst i; simp [qmaPropagationSites])
+  have hg := ((qmaGateMatrix_local c.work (c.gates.getD t.val (.hadamard 0))).joinRight
+    (ι := Fin (c.gates.length+2))).mono (T := qmaPropagationSites c t) (Finset.subset_union_right)
+  have hn := hg.smul (-1)
+  have hs := hf.add hn
+  simp only [neg_one_smul,←sub_eq_add_neg] at hs
+  exact (qmaGuardProjection_local c t).mul hs
+
+theorem qmaLocalPropagationGram_local (c : QMACircuit) (t : Fin c.gates.length) :
+    QMALocalOn (qmaPropagationSites c t)
+      ((qmaLocalPropagationDelta c t).conjTranspose*qmaLocalPropagationDelta c t) :=
+  (qmaLocalPropagationDelta_local c t).adjoint.mul (qmaLocalPropagationDelta_local c t)
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumLocalRealification.lean

@@ -0,0 +1,86 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalCoordinates
+
+namespace OAI
+
+/-! The realification uses one shared extra qubit and adds at most one
+qubit to each interaction support. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped BigOperators Classical
+
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+def qmaRebitSites (S : Finset ι) : Finset (Unit ⊕ ι) :=
+  insert (Sum.inl ()) (S.map Function.Embedding.inr)
+
+def qmaRebitOnQubits (A : Matrix (ι → Fin 2) (ι → Fin 2) ℂ) :
+    Matrix (Unit ⊕ ι → Fin 2) (Unit ⊕ ι → Fin 2) ℂ :=
+  fun s t => qmaRebitMatrix A (s (Sum.inl ()),s ∘ Sum.inr) (t (Sum.inl ()),t ∘ Sum.inr)
+
+omit [Fintype ι] in
+theorem qmaRebitSites_card (S : Finset ι) : (qmaRebitSites S).card = S.card+1 := by
+  simp [qmaRebitSites]
+
+theorem qmaRebitOnQubits_local {S : Finset ι}
+    {A : Matrix (ι → Fin 2) (ι → Fin 2) ℂ} (hA : QMALocalOn S A) :
+    QMALocalOn (qmaRebitSites S) (qmaRebitOnQubits A) := by
+  obtain ⟨B,rfl⟩ := hA
+  let z : {i // i ∈ qmaRebitSites S} := ⟨Sum.inl (),by simp [qmaRebitSites]⟩
+  let k : {i // i ∈ S} → {i // i ∈ qmaRebitSites S} := fun i =>
+    ⟨Sum.inr i.val,by simp [qmaRebitSites,i.property]⟩
+  refine ⟨(fun u v => qmaRebitMatrix B (u z,u ∘ k) (v z,v ∘ k)),?_⟩
+  ext s t
+  change qmaRebitMatrix (qmaLocalLift S B) (s (Sum.inl ()),s ∘ Sum.inr)
+    (t (Sum.inl ()),t ∘ Sum.inr) =
+    qmaRebitMatrix B (s (Sum.inl ()),fun i => s (Sum.inr i.val))
+      (t (Sum.inl ()),fun i => t (Sum.inr i.val))*
+      if (fun i : {i // i ∉ qmaRebitSites S} => s i.val) =
+        (fun i : {i // i ∉ qmaRebitSites S} => t i.val) then 1 else 0
+  have he : ((fun i : {i // i ∉ qmaRebitSites S} => s i.val) =
+      (fun i : {i // i ∉ qmaRebitSites S} => t i.val)) ↔
+      ((fun i : {i // i ∉ S} => s (Sum.inr i.val)) =
+        (fun i : {i // i ∉ S} => t (Sum.inr i.val))) := by
+    constructor
+    · intro h
+      funext i
+      exact congrFun h ⟨Sum.inr i.val,by simpa [qmaRebitSites] using i.property⟩
+    · intro h
+      funext i
+      rcases i with ⟨i,hi⟩
+      cases i with
+      | inl j => exact False.elim (hi (by simp [qmaRebitSites]))
+      | inr j => exact congrFun h ⟨j,by simpa [qmaRebitSites] using hi⟩
+  by_cases hr : (fun i : {i // i ∉ S} => s (Sum.inr i.val)) =
+      (fun i : {i // i ∉ S} => t (Sum.inr i.val))
+  · have hr' := he.mpr hr
+    simp only [qmaRebitMatrix,qmaLocalLift_apply,
+      Function.comp_apply,hr,hr',ite_true,mul_one]
+  · have hr' : (fun i : {i // i ∉ qmaRebitSites S} => s i.val) ≠
+        (fun i : {i // i ∉ qmaRebitSites S} => t i.val) := fun h => hr (he.mp h)
+    simp only [qmaRebitMatrix,qmaLocalLift_apply,
+      Function.comp_apply,hr,hr',ite_false,mul_zero,Complex.zero_re,Complex.zero_im,
+      Complex.ofReal_zero,neg_zero,ite_self]
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem qmaRebitOnQubits_add (A B : Matrix (ι → Fin 2) (ι → Fin 2) ℂ) :
+    qmaRebitOnQubits (A+B) = qmaRebitOnQubits A+qmaRebitOnQubits B := by
+  ext s t
+  simp only [qmaRebitOnQubits,qmaRebitMatrix,Matrix.add_apply,Complex.add_re,Complex.add_im]
+  split_ifs <;> push_cast <;> ring
+
+omit [Fintype ι] [DecidableEq ι] in
+theorem qmaRebitOnQubits_smul (a : ℝ) (A : Matrix (ι → Fin 2) (ι → Fin 2) ℂ) :
+    qmaRebitOnQubits ((a:ℂ) • A) = (a:ℂ) • qmaRebitOnQubits A := by
+  ext s t
+  simp only [qmaRebitOnQubits,qmaRebitMatrix,Matrix.smul_apply,smul_eq_mul,
+    Complex.mul_re,Complex.mul_im,Complex.ofReal_re,Complex.ofReal_im,zero_mul,
+    add_zero,sub_zero]
+  split_ifs <;> push_cast <;> ring
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumLocalSubdivision.lean

@@ -0,0 +1,44 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliSubdivision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalPauli
+
+namespace OAI
+
+/-! Each real local family admits the actual simultaneous subdivision step. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped BigOperators Classical
+variable {ι α : Type*} [Fintype ι] [DecidableEq ι] [Fintype α]
+
+theorem qmaLocalSubdivision_exists (F : α → Matrix (ι → Fin 2) (ι → Fin 2) ℂ)
+    (S : α → Finset ι) {d : ℕ} (hS : ∀ a, (S a).card ≤ 2*d)
+    (hF : ∀ a, QMALocalOn (S a) (F a)) (hH : ∀ a, (F a).IsHermitian)
+    (hR : ∀ a, QMAEntryParity false (F a)) {N : ℝ} (hN : 1 ≤ N) :
+    ∃ G : (QMALocalEvenPauliTerm S × Fin 4) →
+        Matrix (ι ⊕ QMALocalEvenPauliTerm S → Fin 2) (ι ⊕ QMALocalEvenPauliTerm S → Fin 2) ℂ,
+      (∀ p, (G p).IsHermitian) ∧ (∀ p, QMAEntryParity false (G p)) ∧
+      (∀ p, ∃ T : Finset (ι ⊕ QMALocalEvenPauliTerm S), T.card ≤ d+1 ∧ QMALocalOn T (G p)) ∧
+      |MediatorGraph.normalizedBottom (∑ p, G p)-MediatorGraph.normalizedBottom (∑ a, F a)| ≤ 1/N := by
+  obtain ⟨G,hGH,hGR,hGS,hGE⟩ := qmaPauliSubdivision_exists
+    (fun p : QMALocalEvenPauliTerm S => qmaLocalPauliWord S p.val)
+    (fun p => qmaLocalPauliCoefficient F S p.val)
+    (qmaLocalEvenPauli_support S hS) (qmaLocalEvenPauli_even S) hN
+  refine ⟨G,hGH,hGR,hGS,?_⟩
+  have hs : (∑ p : QMALocalEvenPauliTerm S,
+      (qmaLocalPauliCoefficient F S p.val : ℂ) • qmaPauliWord (qmaLocalPauliWord S p.val)) =
+        ∑ a, F a := qmaLocalEvenPauli_sum F S hF hH hR
+  rwa [hs] at hGE
+
+theorem qmaLocalSubdivision_size (S : α → Finset ι) {d : ℕ} (hS : ∀ a, (S a).card ≤ 2*d) :
+    Fintype.card (ι ⊕ QMALocalEvenPauliTerm S) ≤ Fintype.card ι+4^(2*d)*Fintype.card α ∧
+    Fintype.card (QMALocalEvenPauliTerm S × Fin 4) ≤ 4*4^(2*d)*Fintype.card α := by
+  have hc := qmaLocalEvenPauli_count S hS
+  simp only [Fintype.card_sum,Fintype.card_prod,Fintype.card_fin]
+  constructor <;> nlinarith
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumLocalSupported.lean

@@ -0,0 +1,41 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSupportedSubdivision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalPauli
+
+namespace OAI
+
+/-! Each real local family admits the actual simultaneous subdivision step. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped BigOperators Classical
+variable {ι α : Type*} [Fintype ι] [DecidableEq ι] [Fintype α]
+
+theorem qmaLocalSubdivision_supported (F : α → Matrix (ι → Fin 2) (ι → Fin 2) ℂ)
+    (S : α → Finset ι) {d : ℕ} (hS : ∀ a, (S a).card ≤ 2*d)
+    (hF : ∀ a, QMALocalOn (S a) (F a)) (hH : ∀ a, (F a).IsHermitian)
+    (hR : ∀ a, QMAEntryParity false (F a)) {N : ℝ} (hN : 1 ≤ N) :
+    ∃ G : (QMALocalEvenPauliTerm S × Fin 4) →
+        Matrix (ι ⊕ QMALocalEvenPauliTerm S → Fin 2) (ι ⊕ QMALocalEvenPauliTerm S → Fin 2) ℂ,
+      (∀ p, (G p).IsHermitian) ∧ (∀ p, QMAEntryParity false (G p)) ∧
+      (∀ p, ∃ T : Finset (ι ⊕ QMALocalEvenPauliTerm S), T.card ≤ d+1 ∧ QMALocalOn T (G p) ∧
+        T ⊆ qmaMediatorSupport (S p.1.val.1) p.1) ∧
+      |MediatorGraph.normalizedBottom (∑ p, G p)-MediatorGraph.normalizedBottom (∑ a, F a)| ≤ 1/N := by
+  obtain ⟨G,hGH,hGR,hGS,hGE⟩ := qmaPauliSubdivision_supported
+    (fun p : QMALocalEvenPauliTerm S => qmaLocalPauliWord S p.val)
+    (fun p => qmaLocalPauliCoefficient F S p.val)
+    (qmaLocalEvenPauli_support S hS) (qmaLocalEvenPauli_even S) hN
+  refine ⟨G,hGH,hGR,?_,?_⟩
+  · intro p
+    obtain ⟨T,hTc,hTl,hTs⟩ := hGS p
+    exact ⟨T,hTc,hTl,hTs.trans (qmaMediatorSupport_mono (qmaPauliExtend_support _ _) _)⟩
+  · have hs : (∑ p : QMALocalEvenPauliTerm S,
+        (qmaLocalPauliCoefficient F S p.val : ℂ) • qmaPauliWord (qmaLocalPauliWord S p.val)) =
+          ∑ a, F a := qmaLocalEvenPauli_sum F S hF hH hR
+    rwa [hs] at hGE
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumLocalTensor.lean

@@ -0,0 +1,76 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalLift
+
+namespace OAI
+
+/-! Tensor products with identity spectators are actual finite-support
+operators, with their small matrix given explicitly. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped BigOperators Kronecker
+
+variable {ι : Type*} [Fintype ι] [DecidableEq ι]
+
+theorem qmaLocalLift_apply (S : Finset ι)
+    (A : Matrix (QMASupportBasis S) (QMASupportBasis S) ℂ) (s t : ι → Fin 2) :
+    qmaLocalLift S A s t =
+      A (fun i => s i.val) (fun i => t i.val)*
+        if (fun i : {i // i ∉ S} => s i.val) = (fun i : {i // i ∉ S} => t i.val) then 1 else 0 := by
+  rfl
+
+theorem qmaLocalOn_permutation (S : Finset ι) (F : (ι → Fin 2) → (ι → Fin 2))
+    (f : QMASupportBasis S → QMASupportBasis S)
+    (hcore : ∀ t, (qmaSupportSplit S (F t)).1 = f (qmaSupportSplit S t).1)
+    (hrest : ∀ t, (qmaSupportSplit S (F t)).2 = (qmaSupportSplit S t).2) :
+    QMALocalOn S (fun s t => if s = F t then (1:ℂ) else 0) := by
+  refine ⟨(fun s t => if s = f t then 1 else 0),?_⟩
+  ext s t
+  change (if s = F t then (1:ℂ) else 0) =
+    (if (qmaSupportSplit S s).1 = f (qmaSupportSplit S t).1 then 1 else 0)*
+      if (qmaSupportSplit S s).2 = (qmaSupportSplit S t).2 then 1 else 0
+  by_cases hr : (qmaSupportSplit S s).2 = (qmaSupportSplit S t).2
+  · have he : (qmaSupportSplit S s).1 = f (qmaSupportSplit S t).1 ↔ s = F t := by
+      constructor
+      · intro hc
+        apply (qmaSupportSplit S).injective
+        exact Prod.ext (hc.trans (hcore t).symm) (hr.trans (hrest t).symm)
+      · intro h
+        subst s
+        exact hcore t
+    simp [hr,he]
+  · have he : s ≠ F t := by
+      intro h
+      subst s
+      exact hr (hrest t)
+    simp [hr,he]
+
+theorem qmaLocalOn_sourceTensor (n : ℕ) (S : Finset (Fin n))
+    (M : Fin n → Matrix (Fin 2) (Fin 2) ℂ) (hM : ∀ i, i ∉ S → M i = 1) :
+    QMALocalOn S (sourceTensor n M) := by
+  refine ⟨(fun s t => ∏ i : {i // i ∈ S}, M i.val (s i) (t i)),?_⟩
+  ext s t
+  change (∏ i, M i (s i) (t i)) =
+    (∏ i : {i // i ∈ S}, M i.val (s i.val) (t i.val))*
+      if (fun i : {i // i ∉ S} => s i.val) = (fun i : {i // i ∉ S} => t i.val) then 1 else 0
+  by_cases hr : (fun i : {i // i ∉ S} => s i.val) = (fun i : {i // i ∉ S} => t i.val)
+  · rw [ite_eq_left hr,mul_one]
+    have he (i : Fin n) (_hi : i ∈ Finset.univ) (hi : i ∉ S) : M i (s i) (t i) = 1 := by
+      rw [hM i hi]
+      have ht := congrFun hr ⟨i,hi⟩
+      exact ite_eq_left ht
+    have hp := Finset.prod_subset (Finset.subset_univ S) he
+    have hs := Finset.prod_subtype (F := inferInstance) S
+      (by simp : ∀ i, i ∈ S ↔ i ∈ S) (fun i => M i (s i) (t i))
+    exact hp.symm.trans hs
+  · rw [ite_eq_right hr,mul_zero]
+    obtain ⟨i,hi⟩ := Function.ne_iff.mp hr
+    apply Finset.prod_eq_zero (Finset.mem_univ i.val)
+    rw [hM i.val i.property]
+    exact ite_eq_right hi
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumLocalThird.lean

@@ -0,0 +1,46 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPauliThird
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalPauli
+
+namespace OAI
+
+/-! A real three-local family reduces to a real two-local family, with
+seven output terms per even Pauli word and the actual spectral error. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped BigOperators Classical
+variable {ι α : Type*} [Fintype ι] [DecidableEq ι] [Fintype α]
+
+theorem qmaLocalThird_exists (F : α → Matrix (ι → Fin 2) (ι → Fin 2) ℂ)
+    (S : α → Finset ι) (hS : ∀ a, (S a).card ≤ 3)
+    (hF : ∀ a, QMALocalOn (S a) (F a)) (hH : ∀ a, (F a).IsHermitian)
+    (hR : ∀ a, QMAEntryParity false (F a)) {N : ℝ} (hN : 1 ≤ N) :
+    ∃ G : (QMALocalEvenPauliTerm S × Fin 7) →
+        Matrix (ι ⊕ QMALocalEvenPauliTerm S → Fin 2) (ι ⊕ QMALocalEvenPauliTerm S → Fin 2) ℂ,
+      (∀ p, (G p).IsHermitian) ∧ (∀ p, QMAEntryParity false (G p)) ∧
+      (∀ p, ∃ T : Finset (ι ⊕ QMALocalEvenPauliTerm S), T.card ≤ 2 ∧ QMALocalOn T (G p)) ∧
+      |MediatorGraph.normalizedBottom (∑ p, G p)-MediatorGraph.normalizedBottom (∑ a, F a)| ≤ 1/N := by
+  obtain ⟨G,hGH,hGR,hGS,hGE⟩ := qmaPauliThird_exists
+    (fun p : QMALocalEvenPauliTerm S => qmaLocalPauliWord S p.val)
+    (fun p => qmaLocalPauliCoefficient F S p.val)
+    (qmaLocalEvenPauli_support S hS) (qmaLocalEvenPauli_even S) hN
+  refine ⟨G,hGH,hGR,hGS,?_⟩
+  have hs : (∑ p : QMALocalEvenPauliTerm S,
+      (qmaLocalPauliCoefficient F S p.val : ℂ) • qmaPauliWord (qmaLocalPauliWord S p.val)) =
+        ∑ a, F a := qmaLocalEvenPauli_sum F S hF hH hR
+  rwa [hs] at hGE
+
+theorem qmaLocalThird_size (S : α → Finset ι) (hS : ∀ a, (S a).card ≤ 3) :
+    Fintype.card (ι ⊕ QMALocalEvenPauliTerm S) ≤ Fintype.card ι+64*Fintype.card α ∧
+    Fintype.card (QMALocalEvenPauliTerm S × Fin 7) ≤ 448*Fintype.card α := by
+  have hc := qmaLocalEvenPauli_count S hS
+  norm_num only [show (4:ℕ)^3 = 64 by norm_num] at hc
+  simp only [Fintype.card_sum,Fintype.card_prod,Fintype.card_fin]
+  constructor <;> omega
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumLocalThirdSupported.lean

@@ -0,0 +1,41 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSupportedThird
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalPauli
+
+namespace OAI
+
+/-! Each real local family admits the actual simultaneous subdivision step. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped BigOperators Classical
+variable {ι α : Type*} [Fintype ι] [DecidableEq ι] [Fintype α]
+
+theorem qmaLocalThird_supported (F : α → Matrix (ι → Fin 2) (ι → Fin 2) ℂ)
+    (S : α → Finset ι) (hS : ∀ a, (S a).card ≤ 3)
+    (hF : ∀ a, QMALocalOn (S a) (F a)) (hH : ∀ a, (F a).IsHermitian)
+    (hR : ∀ a, QMAEntryParity false (F a)) {N : ℝ} (hN : 1 ≤ N) :
+    ∃ G : (QMALocalEvenPauliTerm S × Fin 7) →
+        Matrix (ι ⊕ QMALocalEvenPauliTerm S → Fin 2) (ι ⊕ QMALocalEvenPauliTerm S → Fin 2) ℂ,
+      (∀ p, (G p).IsHermitian) ∧ (∀ p, QMAEntryParity false (G p)) ∧
+      (∀ p, ∃ T : Finset (ι ⊕ QMALocalEvenPauliTerm S), T.card ≤ 2 ∧ QMALocalOn T (G p) ∧
+        T ⊆ qmaMediatorSupport (S p.1.val.1) p.1) ∧
+      |MediatorGraph.normalizedBottom (∑ p, G p)-MediatorGraph.normalizedBottom (∑ a, F a)| ≤ 1/N := by
+  obtain ⟨G,hGH,hGR,hGS,hGE⟩ := qmaPauliThird_supported
+    (fun p : QMALocalEvenPauliTerm S => qmaLocalPauliWord S p.val)
+    (fun p => qmaLocalPauliCoefficient F S p.val)
+    (qmaLocalEvenPauli_support S hS) (qmaLocalEvenPauli_even S) hN
+  refine ⟨G,hGH,hGR,?_,?_⟩
+  · intro p
+    obtain ⟨T,hTc,hTl,hTs⟩ := hGS p
+    exact ⟨T,hTc,hTl,hTs.trans (qmaMediatorSupport_mono (qmaPauliExtend_support _ _) _)⟩
+  · have hs : (∑ p : QMALocalEvenPauliTerm S,
+        (qmaLocalPauliCoefficient F S p.val : ℂ) • qmaPauliWord (qmaLocalPauliWord S p.val)) =
+          ∑ a, F a := qmaLocalEvenPauli_sum F S hF hH hR
+    rwa [hs] at hGE
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumManhattanListProgram.lean

@@ -0,0 +1,43 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRouteProgram
+import OAI.Computability.QuantumFactoring.BitStackBoundedUnary
+import OAI.Computability.QuantumFactoring.BitStackTabulate
+
+namespace OAI
+
+/-! Enumerate the Manhattan segment with an explicit fixed route budget.
+The cap makes enumeration polynomial on every input, and disappears for
+the spatial routes satisfying the proved length bound. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumManhattanListProgram
+open ExactQuantumFactoring.BitStackProgram QuantumRouteCode
+
+abbrev Ends := Pair × Pair
+def endsCode : Ends → List Bool := prodCode pairCode pairCode
+
+def value (K : ℕ) (x : Ends) : List Pair :=
+  (List.range (min K (qmaManhattanLength x.1 x.2)+1)).map (qmaManhattanPoint x.1 x.2)
+
+noncomputable def distanceProgram : Procedure endsCode Nat.bits
+    (fun x => qmaManhattanLength x.1 x.2) :=
+  QuantumRouteCode.lengthProgram.comp
+    ((Procedure.identity endsCode).pair (Procedure.constant endsCode Nat.bits 0))
+
+noncomputable def program (K : ℕ) : Procedure endsCode (listCode pairCode) (value K) := by
+  let length := Procedure.clippedUnary.comp
+    ((Procedure.constant endsCode unaryCode K).pair distanceProgram)
+  let point := QuantumRouteCode.pointProgram.comp
+    ((Procedure.second unaryCode endsCode).pair
+      (Procedure.unaryToBits.comp (Procedure.first unaryCode endsCode)))
+  exact (Procedure.tabulate (f := fun x i => qmaManhattanPoint x.1 x.2 i) (0,0) point).comp
+    ((Procedure.unarySuccessor.comp length).pair (Procedure.identity endsCode))
+
+theorem value_exact (K : ℕ) (x : Ends) (h : qmaManhattanLength x.1 x.2 ≤ K) :
+    value K x = (List.range (qmaManhattanLength x.1 x.2+1)).map (qmaManhattanPoint x.1 x.2) := by
+  simp only [value,Nat.min_eq_right h]
+
+end ContinuumCoulomb.QuantumManhattanListProgram
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumManhattanRoute.lean

@@ -0,0 +1,130 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridSlots
+import Mathlib.Data.Nat.Dist
+import Mathlib.Data.Int.NatAbs
+
+namespace OAI
+
+/-! Short, simple lattice paths between the bounded-density fine-grid sites. -/
+
+namespace ContinuumCoulomb
+
+def qmaAxisWalk (a b k : ℕ) : ℕ := if a ≤ b then a+k else a-k
+
+@[simp] theorem qmaAxisWalk_zero (a b : ℕ) : qmaAxisWalk a b 0 = a := by
+  simp [qmaAxisWalk]
+
+@[simp] theorem qmaAxisWalk_last (a b : ℕ) : qmaAxisWalk a b (Nat.dist a b) = b := by
+  unfold qmaAxisWalk Nat.dist
+  split_ifs <;> omega
+
+theorem qmaAxisWalk_distance (a b k : ℕ) (hk : k ≤ Nat.dist a b) :
+    Nat.dist a (qmaAxisWalk a b k) = k := by
+  unfold qmaAxisWalk Nat.dist at *
+  split_ifs <;> omega
+
+theorem qmaAxisWalk_step (a b k : ℕ) (hk : k < Nat.dist a b) :
+    Nat.dist (qmaAxisWalk a b k) (qmaAxisWalk a b (k+1)) = 1 := by
+  unfold qmaAxisWalk Nat.dist at *
+  split_ifs <;> omega
+
+theorem qmaAxisWalk_bounds (a b k : ℕ) (hk : k ≤ Nat.dist a b) :
+    min a b ≤ qmaAxisWalk a b k ∧ qmaAxisWalk a b k ≤ max a b := by
+  unfold qmaAxisWalk Nat.dist at *
+  split_ifs <;> omega
+
+def qmaManhattanLength (p q : ℕ × ℕ) : ℕ := Nat.dist p.1 q.1+Nat.dist p.2 q.2
+
+def qmaManhattanPoint (p q : ℕ × ℕ) (k : ℕ) : ℕ × ℕ :=
+  if k ≤ Nat.dist p.1 q.1 then (qmaAxisWalk p.1 q.1 k,p.2)
+  else (q.1,qmaAxisWalk p.2 q.2 (k-Nat.dist p.1 q.1))
+
+@[simp] theorem qmaManhattanPoint_zero (p q : ℕ × ℕ) : qmaManhattanPoint p q 0 = p := by
+  simp [qmaManhattanPoint]
+
+@[simp] theorem qmaManhattanPoint_last (p q : ℕ × ℕ) :
+    qmaManhattanPoint p q (qmaManhattanLength p q) = q := by
+  by_cases h : Nat.dist p.2 q.2 = 0
+  · have he := Nat.eq_of_dist_eq_zero h
+    simp [qmaManhattanLength,qmaManhattanPoint,he]
+  · have hn : ¬qmaManhattanLength p q ≤ Nat.dist p.1 q.1 := by unfold qmaManhattanLength; omega
+    simp only [qmaManhattanPoint,ite_eq_right hn]
+    simp [qmaManhattanLength]
+
+theorem qmaManhattanPoint_distance (p q : ℕ × ℕ) (k : ℕ) (hk : k ≤ qmaManhattanLength p q) :
+    Nat.dist p.1 (qmaManhattanPoint p q k).1+
+      Nat.dist p.2 (qmaManhattanPoint p q k).2 = k := by
+  by_cases hx : k ≤ Nat.dist p.1 q.1
+  · simp [qmaManhattanPoint,hx,qmaAxisWalk_distance _ _ _ hx]
+  · have hy : k-Nat.dist p.1 q.1 ≤ Nat.dist p.2 q.2 := by unfold qmaManhattanLength at hk; omega
+    simp only [qmaManhattanPoint,hx,ite_false]
+    rw [qmaAxisWalk_distance _ _ _ hy]
+    omega
+
+theorem qmaManhattanPoint_step (p q : ℕ × ℕ) (k : ℕ) (hk : k < qmaManhattanLength p q) :
+    Nat.dist (qmaManhattanPoint p q k).1 (qmaManhattanPoint p q (k+1)).1+
+      Nat.dist (qmaManhattanPoint p q k).2 (qmaManhattanPoint p q (k+1)).2 = 1 := by
+  by_cases hx : k < Nat.dist p.1 q.1
+  · have hx0 : k ≤ Nat.dist p.1 q.1 := by omega
+    have hx1 : k+1 ≤ Nat.dist p.1 q.1 := by omega
+    simp [qmaManhattanPoint,hx0,hx1,qmaAxisWalk_step _ _ _ hx]
+  · by_cases he : k = Nat.dist p.1 q.1
+    · subst k
+      have hy : 0 < Nat.dist p.2 q.2 := by unfold qmaManhattanLength at hk; omega
+      simpa [qmaManhattanPoint] using qmaAxisWalk_step p.2 q.2 0 hy
+    · have hx0 : ¬k ≤ Nat.dist p.1 q.1 := by omega
+      have hx1 : ¬k+1 ≤ Nat.dist p.1 q.1 := by omega
+      have hy : k-Nat.dist p.1 q.1 < Nat.dist p.2 q.2 := by unfold qmaManhattanLength at hk; omega
+      have hs : k+1-Nat.dist p.1 q.1 = (k-Nat.dist p.1 q.1)+1 := by omega
+      simp [qmaManhattanPoint,hx0,hx1,hs,qmaAxisWalk_step _ _ _ hy]
+
+def qmaManhattanRoute (p q : ℕ × ℕ) : Fin (qmaManhattanLength p q+1) → ℕ × ℕ :=
+  fun k => qmaManhattanPoint p q k.val
+
+theorem qmaManhattanRoute_injective (p q : ℕ × ℕ) : Function.Injective (qmaManhattanRoute p q) := by
+  intro a b hab
+  apply Fin.ext
+  have ha := qmaManhattanPoint_distance p q a.val (by omega)
+  have hb := qmaManhattanPoint_distance p q b.val (by omega)
+  change qmaManhattanPoint p q a.val = qmaManhattanPoint p q b.val at hab
+  rw [hab] at ha
+  omega
+
+theorem qmaManhattanPoint_bounds (p q : ℕ × ℕ) (k : ℕ) (hk : k ≤ qmaManhattanLength p q) :
+    min p.1 q.1 ≤ (qmaManhattanPoint p q k).1 ∧
+    (qmaManhattanPoint p q k).1 ≤ max p.1 q.1 ∧
+    min p.2 q.2 ≤ (qmaManhattanPoint p q k).2 ∧
+    (qmaManhattanPoint p q k).2 ≤ max p.2 q.2 := by
+  by_cases hx : k ≤ Nat.dist p.1 q.1
+  · simpa only [qmaManhattanPoint,hx,ite_true] using
+      And.intro (qmaAxisWalk_bounds _ _ _ hx).1
+        (And.intro (qmaAxisWalk_bounds _ _ _ hx).2 (And.intro (min_le_left _ _) (le_max_left _ _)))
+  · have hy : k-Nat.dist p.1 q.1 ≤ Nat.dist p.2 q.2 := by unfold qmaManhattanLength at hk; omega
+    simpa only [qmaManhattanPoint,hx,ite_false] using
+      And.intro (min_le_right _ _)
+        (And.intro (le_max_right _ _) (qmaAxisWalk_bounds _ _ _ hy))
+
+noncomputable def qmaFineGridPoint {Q : Type*} [Fintype Q] {rows width A : ℕ}
+    (cell : Q → QMAGridCell rows width)
+    (h : ∀ p, (Finset.univ.filter (fun q => cell q = p)).card ≤ A) (q : Q) : ℕ × ℕ :=
+  ((qmaFineGridSite cell h q).1.val,(qmaFineGridSite cell h q).2.val)
+
+theorem qmaFineGridPoint_length {Q : Type*} [Fintype Q] {rows width A : ℕ}
+    (cell : Q → QMAGridCell rows width)
+    (h : ∀ p, (Finset.univ.filter (fun q => cell q = p)).card ≤ A)
+    (p q : Q) (a : QMAGridCell rows width)
+    (hp : QMAGridCellsNear (cell p) a) (hq : QMAGridCellsNear (cell q) a) :
+    qmaManhattanLength (qmaFineGridPoint cell h p) (qmaFineGridPoint cell h q) ≤ 3*A+2 := by
+  obtain ⟨hp1,hp2,hp3,hp4⟩ := qmaFineGridSite_bounds cell h p a hp
+  obtain ⟨hq1,hq2,hq3,hq4⟩ := qmaFineGridSite_bounds cell h q a hq
+  simp only [Nat.add_mul] at hp1 hq1
+  unfold qmaManhattanLength qmaFineGridPoint Nat.dist
+  omega
+
+theorem qmaNatDist_eq_int (a b : ℕ) : Nat.dist a b = Int.natAbs ((a:ℤ)-(b:ℤ)) := by
+  by_cases h : a ≤ b
+  · rw [Nat.dist_eq_sub_of_le h,Int.natAbs_natCast_sub_natCast_of_le h]
+  · rw [Nat.dist_eq_sub_of_le_right (by omega),Int.natAbs_natCast_sub_natCast_of_ge (by omega)]
+
+end ContinuumCoulomb
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumManhattanSupport.lean

@@ -0,0 +1,61 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumManhattanRoute
+
+namespace OAI
+
+/-! Exact support of the two-segment lattice route. -/
+
+namespace ContinuumCoulomb
+
+def qmaBetween (a b x : ℕ) : Prop := min a b ≤ x ∧ x ≤ max a b
+
+def qmaManhattanSupport (p q z : ℕ × ℕ) : Prop :=
+  (z.2 = p.2 ∧ qmaBetween p.1 q.1 z.1) ∨
+    (z.1 = q.1 ∧ qmaBetween p.2 q.2 z.2)
+
+theorem qmaAxisWalk_at_between {a b x : ℕ} (h : qmaBetween a b x) :
+    qmaAxisWalk a b (Nat.dist a x) = x ∧ Nat.dist a x ≤ Nat.dist a b := by
+  unfold qmaBetween qmaAxisWalk Nat.dist at *
+  split_ifs <;> omega
+
+theorem qmaManhattanPoint_support (p q : ℕ × ℕ) (k : ℕ)
+    (hk : k ≤ qmaManhattanLength p q) : qmaManhattanSupport p q (qmaManhattanPoint p q k) := by
+  by_cases hx : k ≤ Nat.dist p.1 q.1
+  · left
+    simp only [qmaManhattanPoint,ite_eq_left hx]
+    exact ⟨True.intro,qmaAxisWalk_bounds _ _ _ hx⟩
+  · right
+    have hy : k-Nat.dist p.1 q.1 ≤ Nat.dist p.2 q.2 := by
+      unfold qmaManhattanLength at hk
+      omega
+    simp only [qmaManhattanPoint,ite_eq_right hx]
+    exact ⟨True.intro,qmaAxisWalk_bounds _ _ _ hy⟩
+
+theorem qmaManhattanSupport_point {p q z : ℕ × ℕ} (hz : qmaManhattanSupport p q z) :
+    ∃ k, k ≤ qmaManhattanLength p q ∧ qmaManhattanPoint p q k = z := by
+  rcases hz with ⟨hy,hx⟩ | ⟨hx,hy⟩
+  · obtain ⟨he,hk⟩ := qmaAxisWalk_at_between hx
+    refine ⟨Nat.dist p.1 z.1,by unfold qmaManhattanLength; omega,?_⟩
+    simp only [qmaManhattanPoint,ite_eq_left hk,he]
+    exact Prod.ext rfl hy.symm
+  · obtain ⟨he,hk⟩ := qmaAxisWalk_at_between hy
+    refine ⟨Nat.dist p.1 q.1+Nat.dist p.2 z.2,by unfold qmaManhattanLength; omega,?_⟩
+    by_cases hzero : Nat.dist p.2 z.2 = 0
+    · have hyz := Nat.eq_of_dist_eq_zero hzero
+      simp only [qmaManhattanPoint,hzero,add_zero,le_refl,ite_true,qmaAxisWalk_last]
+      exact Prod.ext hx.symm hyz
+    · have hn : ¬Nat.dist p.1 q.1+Nat.dist p.2 z.2 ≤ Nat.dist p.1 q.1 := by omega
+      simp only [qmaManhattanPoint,ite_eq_right hn,Nat.add_sub_cancel_left,he]
+      exact Prod.ext hx.symm rfl
+
+theorem qmaManhattanRoute_range (p q z : ℕ × ℕ) :
+    z ∈ Set.range (qmaManhattanRoute p q) ↔ qmaManhattanSupport p q z := by
+  constructor
+  · rintro ⟨k,rfl⟩
+    exact qmaManhattanPoint_support p q k.val (by omega)
+  · intro hz
+    obtain ⟨k,hk,he⟩ := qmaManhattanSupport_point hz
+    exact ⟨⟨k,by omega⟩,he⟩
+
+end ContinuumCoulomb
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumMappedGate.lean

@@ -0,0 +1,49 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumWireRouting
+
+namespace OAI
+
+/-! Explicit gate addresses for a logical register embedded in a larger wire grid. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open scoped Classical
+
+def qmaMapGate (sourceWork targetWork : ℕ) (f : Fin (sourceWork+1) → Fin (targetWork+1)) :
+    QMAGate → QMAGate
+  | .hadamard i => .hadamard (f (qmaQubit sourceWork i)).val
+  | .phaseT i => .phaseT (f (qmaQubit sourceWork i)).val
+  | .controlledNot i j =>
+      .controlledNot (f (qmaQubit sourceWork i)).val (f (qmaQubit sourceWork j)).val
+
+theorem qmaMapGate_wellFormed (sourceWork targetWork : ℕ)
+    (f : Fin (sourceWork+1) → Fin (targetWork+1)) (hf : Function.Injective f)
+    (g : QMAGate) (hg : g.WellFormed (sourceWork+1)) :
+    (qmaMapGate sourceWork targetWork f g).WellFormed (targetWork+1) := by
+  cases g with
+  | hadamard i => exact (f (qmaQubit sourceWork i)).isLt
+  | phaseT i => exact (f (qmaQubit sourceWork i)).isLt
+  | controlledNot i j =>
+    refine ⟨(f (qmaQubit sourceWork i)).isLt,(f (qmaQubit sourceWork j)).isLt,?_⟩
+    intro he
+    have h := congrArg Fin.val (hf (Fin.ext he))
+    simp only [qmaQubit,Nat.mod_eq_of_lt hg.1,Nat.mod_eq_of_lt hg.2.1] at h
+    exact hg.2.2 h
+
+theorem qmaRelabelGate_map (sourceWork targetWork : ℕ)
+    (f : Fin (sourceWork+1) → Fin (targetWork+1))
+    (σ : Equiv.Perm (Fin (targetWork+1))) (g : QMAGate) :
+    qmaRelabelGate targetWork σ (qmaMapGate sourceWork targetWork f g) =
+      qmaMapGate sourceWork targetWork (σ ∘ f) g := by
+  cases g <;> simp only [qmaMapGate,qmaRelabelGate,qmaQubit_fin,Function.comp_apply]
+
+theorem qmaMapGate_congr (sourceWork targetWork : ℕ)
+    (f h : Fin (sourceWork+1) → Fin (targetWork+1)) (he : ∀ i, f i = h i) (g : QMAGate) :
+    qmaMapGate sourceWork targetWork f g = qmaMapGate sourceWork targetWork h g := by
+  have hf : f = h := funext he
+  rw [hf]
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumMask.lean

@@ -0,0 +1,65 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAncilla
+
+namespace OAI
+
+/-! Coordinate projections for the initial and output penalties. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open scoped BigOperators Classical
+
+def qmaMask {n : ℕ} (p : SourceSpinBasis n → Prop) :
+    EuclideanSpace ℂ (SourceSpinBasis n) →ₗ[ℂ] EuclideanSpace ℂ (SourceSpinBasis n) := by
+  classical
+  exact {
+    toFun := fun u => WithLp.toLp 2 (fun s => if p s then u s else 0)
+    map_add' := by intro u v; ext s; by_cases hs : p s <;> simp [hs]
+    map_smul' := by intro a u; ext s; by_cases hs : p s <;> simp [hs] }
+
+@[simp] theorem qmaMask_apply {n : ℕ} (p : SourceSpinBasis n → Prop)
+    (u : EuclideanSpace ℂ (SourceSpinBasis n)) (s : SourceSpinBasis n) :
+    qmaMask p u s = if p s then u s else 0 := rfl
+
+theorem qmaMask_norm_le {n : ℕ} (p : SourceSpinBasis n → Prop)
+    (u : EuclideanSpace ℂ (SourceSpinBasis n)) : ‖qmaMask p u‖ ≤ ‖u‖ := by
+  classical
+  apply (sq_le_sq₀ (norm_nonneg _) (norm_nonneg _)).mp
+  rw [EuclideanSpace.norm_sq_eq,EuclideanSpace.norm_sq_eq]
+  apply Finset.sum_le_sum
+  intro s _
+  by_cases hs : p s <;> simp [qmaMask_apply,hs]
+
+theorem qmaMask_complement_square {n : ℕ} (p : SourceSpinBasis n → Prop)
+    (u : EuclideanSpace ℂ (SourceSpinBasis n)) :
+    ‖qmaMask p u‖^2+‖qmaMask (fun s => ¬p s) u‖^2 = ‖u‖^2 := by
+  classical
+  simp only [EuclideanSpace.norm_sq_eq,←Finset.sum_add_distrib]
+  apply Finset.sum_congr rfl
+  intro s _
+  by_cases hs : p s <;> simp [hs]
+
+theorem qmaMask_sub_norm_le {n : ℕ} (p : SourceSpinBasis n → Prop)
+    (u v : EuclideanSpace ℂ (SourceSpinBasis n)) :
+    ‖qmaMask p u-qmaMask p v‖ ≤ ‖u-v‖ := by
+  rw [←map_sub]
+  exact qmaMask_norm_le p (u-v)
+
+theorem qmaMask_square_difference {n : ℕ} (p : SourceSpinBasis n → Prop)
+    (u v : EuclideanSpace ℂ (SourceSpinBasis n)) :
+    |‖qmaMask p u‖^2-‖qmaMask p v‖^2| ≤ (‖u‖+‖v‖)*‖u-v‖ := by
+  rw [sq_sub_sq,abs_mul,abs_of_nonneg (add_nonneg (norm_nonneg _) (norm_nonneg _))]
+  have ha := (abs_norm_sub_norm_le (qmaMask p u) (qmaMask p v)).trans (qmaMask_sub_norm_le p u v)
+  have hb := add_le_add (qmaMask_norm_le p u) (qmaMask_norm_le p v)
+  exact mul_le_mul hb ha (abs_nonneg _) (by positivity)
+
+theorem qmaMask_sub_self {n : ℕ} (p : SourceSpinBasis n → Prop)
+    (u : EuclideanSpace ℂ (SourceSpinBasis n)) :
+    u-qmaMask p u = qmaMask (fun s => ¬p s) u := by
+  ext s
+  by_cases hs : p s <;> simp [hs]
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumMatrixError.lean

@@ -0,0 +1,53 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalCore
+
+namespace OAI
+
+/-! Entrywise errors of the bounded-size local matrices give quadratic
+bounds that can be summed before any spectral approximation. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped BigOperators Classical
+
+theorem qmaQuadratic_entry_bound {ι : Type*} [Fintype ι]
+    (A : Matrix ι ι ℂ) (B : ℝ) (hB : 0 ≤ B) (hA : ∀ i j, ‖A i j‖ ≤ B)
+    (u : ι → ℂ) :
+    |qmaQuadratic A u| ≤ (Fintype.card ι:ℝ)*B*(∑ i, ‖u i‖^2) := by
+  have he : qmaQuadratic A u = (∑ i, ∑ j, star (u i)*(A i j*u j)).re := by
+    simp [qmaQuadratic,Matrix.mulVec,dotProduct,Finset.mul_sum]
+  rw [he]
+  calc
+    _ ≤ ‖∑ i, ∑ j, star (u i)*(A i j*u j)‖ := Complex.abs_re_le_norm _
+    _ ≤ ∑ i, ∑ j, ‖star (u i)*(A i j*u j)‖ := by
+      apply (norm_sum_le _ _).trans
+      apply Finset.sum_le_sum
+      intro i _
+      exact norm_sum_le _ _
+    _ ≤ ∑ i, ∑ j, ‖u i‖*B*‖u j‖ := by
+      apply Finset.sum_le_sum
+      intro i _
+      apply Finset.sum_le_sum
+      intro j _
+      simp only [norm_mul,norm_star]
+      calc
+        _ ≤ ‖u i‖*(B*‖u j‖) := mul_le_mul_of_nonneg_left
+          (mul_le_mul_of_nonneg_right (hA i j) (norm_nonneg _)) (norm_nonneg _)
+        _ = _ := by ring
+    _ ≤ ∑ i, ∑ j, (B/2)*(‖u i‖^2+‖u j‖^2) := by
+      apply Finset.sum_le_sum
+      intro i _
+      apply Finset.sum_le_sum
+      intro j _
+      have h := mul_nonneg hB (sq_nonneg (‖u i‖-‖u j‖))
+      nlinarith
+    _ = _ := by
+      simp only [mul_add,Finset.sum_add_distrib,←Finset.mul_sum,Finset.sum_const,
+        nsmul_eq_mul,Finset.card_univ]
+      ring
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumMediatorGeometry.lean

@@ -0,0 +1,36 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialModel
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumLocalSupported
+
+namespace OAI
+
+/-! Placing a mediator at its source term's anchor preserves the spatial support bound. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open scoped Classical
+variable {ι κ : Type*} [DecidableEq ι] [DecidableEq κ]
+
+omit [DecidableEq ι] [DecidableEq κ] in
+def qmaMediatorCell {rows width : ℕ} (cell : ι → QMAGridCell rows width)
+    (anchor : κ → QMAGridCell rows width) : ι ⊕ κ → QMAGridCell rows width :=
+  Sum.elim cell anchor
+
+theorem qmaMediatorSupport_geometry {rows width : ℕ} (cell : ι → QMAGridCell rows width)
+    (anchor : κ → QMAGridCell rows width) (S : Finset ι) (e : κ)
+    (hS : ∀ i ∈ S, QMAGridCellsNear (cell i) (anchor e))
+    (q : ι ⊕ κ) (hq : q ∈ qmaMediatorSupport S e) :
+    QMAGridCellsNear (qmaMediatorCell cell anchor q) (anchor e) := by
+  cases q with
+  | inl i =>
+    apply hS
+    simpa [qmaMediatorSupport] using hq
+  | inr j =>
+    have he : j = e := by simpa [qmaMediatorSupport] using hq
+    subst j
+    exact qmaGridCellsNear_refl _
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumMergeEdges.lean

@@ -0,0 +1,104 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRationalPathStep
+
+namespace OAI
+
+/-! Parallel interactions are combined at one canonically ordered physical edge.
+This is an exact matrix operation, with no perturbative error. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open scoped BigOperators Classical
+namespace QMARationalExchangeGraph
+
+def orderedPair (G : QMARationalExchangeGraph) (e : G.Edge) : Fin G.n × Fin G.n :=
+  (min (G.left e) (G.right e),max (G.left e) (G.right e))
+
+def edgePairs (G : QMARationalExchangeGraph) : Finset (Fin G.n × Fin G.n) :=
+  Finset.univ.image G.orderedPair
+
+abbrev MergedEdge (G : QMARationalExchangeGraph) := {p // p ∈ G.edgePairs}
+
+def edgeClass (G : QMARationalExchangeGraph) (e : G.Edge) : G.MergedEdge :=
+  ⟨G.orderedPair e,Finset.mem_image.mpr ⟨e,Finset.mem_univ _,rfl⟩⟩
+
+theorem orderedPair_lt (G : QMARationalExchangeGraph) (e : G.Edge) :
+    (G.orderedPair e).1 < (G.orderedPair e).2 := by
+  rcases lt_or_gt_of_ne (G.distinct e) with h | h
+  · simpa only [orderedPair,min_eq_left h.le,max_eq_right h.le] using h
+  · simpa only [orderedPair,min_eq_right h.le,max_eq_left h.le] using h
+
+theorem mergedEdge_lt (G : QMARationalExchangeGraph) (p : G.MergedEdge) : p.val.1 < p.val.2 := by
+  obtain ⟨e,_,he⟩ := Finset.mem_image.mp p.property
+  rw [← he]
+  exact G.orderedPair_lt e
+
+theorem orderedPair_matrix (G : QMARationalExchangeGraph) (e : G.Edge) :
+    sourceHeisenbergMatrix G.n (G.orderedPair e).1 (G.orderedPair e).2 =
+      sourceHeisenbergMatrix G.n (G.left e) (G.right e) := by
+  rcases le_total (G.left e) (G.right e) with h | h
+  · simp only [orderedPair,min_eq_left h,max_eq_right h]
+  · simpa only [orderedPair,min_eq_right h,max_eq_left h] using
+      qmaHeisenberg_symm G.n (G.right e) (G.left e)
+
+def merge (G : QMARationalExchangeGraph) : QMARationalExchangeGraph where
+  n := G.n
+  Edge := G.MergedEdge
+  left := fun p => p.val.1
+  right := fun p => p.val.2
+  distinct := fun p => (G.mergedEdge_lt p).ne
+  weight := fun p => ∑ e, if G.edgeClass e = p then G.weight e else 0
+  constant := G.constant
+
+theorem merge_matrix (G : QMARationalExchangeGraph) :
+    qmaExchangeMatrix G.merge.left G.merge.right (fun e => (G.merge.weight e:ℝ)) G.merge.constant =
+      qmaExchangeMatrix G.left G.right (fun e => (G.weight e:ℝ)) G.constant := by
+  unfold qmaExchangeMatrix
+  congr 1
+  change (∑ p : G.MergedEdge,
+    (((∑ e, if G.edgeClass e = p then G.weight e else 0):ℚ):ℂ) •
+      sourceHeisenbergMatrix G.n p.val.1 p.val.2) = _
+  push_cast
+  simp only [Finset.sum_smul]
+  rw [Finset.sum_comm]
+  apply Finset.sum_congr rfl
+  intro e _
+  have hcast (p : G.MergedEdge) : (((if G.edgeClass e = p then G.weight e else 0):ℚ):ℂ) =
+      (if G.edgeClass e = p then (G.weight e:ℂ) else 0) := by split_ifs <;> simp
+  simp_rw [hcast,ite_smul,zero_smul]
+  rw [Finset.sum_ite_eq]
+  simp only [Finset.mem_univ,ite_true]
+  rw [show (G.edgeClass e).val = G.orderedPair e from rfl,G.orderedPair_matrix]
+
+theorem merge_energy (G : QMARationalExchangeGraph) : G.merge.energy = G.energy := by
+  unfold energy
+  rw [G.merge_matrix]
+  rfl
+
+theorem merge_pair_injective (G : QMARationalExchangeGraph) :
+    Function.Injective (fun e : G.merge.Edge => (G.merge.left e,G.merge.right e)) := by
+  intro e f h
+  exact Subtype.ext h
+
+theorem merge_edge_count (G : QMARationalExchangeGraph) : Fintype.card G.merge.Edge ≤ Fintype.card G.Edge := by
+  change Fintype.card G.MergedEdge ≤ _
+  rw [Fintype.card_coe]
+  exact (Finset.card_image_le).trans_eq (Finset.card_univ)
+
+theorem merge_edge_source (G : QMARationalExchangeGraph) (p : G.merge.Edge) :
+    ∃ e : G.Edge, (G.merge.left p = G.left e ∧ G.merge.right p = G.right e) ∨
+      (G.merge.left p = G.right e ∧ G.merge.right p = G.left e) := by
+  obtain ⟨e,_,he⟩ := Finset.mem_image.mp p.property
+  refine ⟨e,?_⟩
+  change (p.val.1 = G.left e ∧ p.val.2 = G.right e) ∨
+    (p.val.1 = G.right e ∧ p.val.2 = G.left e)
+  rw [← he]
+  rcases le_total (G.left e) (G.right e) with h | h
+  · exact Or.inl ⟨min_eq_left h,max_eq_right h⟩
+  · exact Or.inr ⟨min_eq_right h,max_eq_left h⟩
+
+end QMARationalExchangeGraph
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumMergedCoefficientBounds.lean

@@ -0,0 +1,142 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingPacketBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumPlanarTapeSupport
+
+namespace OAI
+
+/-! Merging the actual bond tape reduces its length and increases each
+coefficient by at most the input length. These bounds apply directly to the
+numeric graph used by the final route compiler. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumListMerge
+open MediatorListProgram
+
+theorem value_length_le_input (n : ℕ) (xs : List Bond) :
+    (value n xs).length ≤ xs.length := by
+  have hs : support n xs ⊆ xs.map ordered := by
+    intro p hp
+    exact of_decide_eq_true (List.mem_filter.mp hp).2
+  have h := (support_nodup n xs).length_le_of_subset hs
+  simpa only [value,List.length_map] using h
+
+theorem value_coefficient_bound (n : ℕ) (xs : List Bond) {L : ℝ}
+    (hL : 0 ≤ L) (hw : ∀ e ∈ xs, |(e.2.2 : ℝ)| ≤ L) :
+    ∀ e ∈ value n xs, |(e.2.2 : ℝ)| ≤ xs.length*L := by
+  intro e he
+  obtain ⟨p,_,rfl⟩ := List.mem_map.mp he
+  exact weight_abs_le xs p hL hw
+
+end ContinuumCoulomb.QuantumListMerge
+
+namespace ContinuumCoulomb.QuantumPlanarTapeGeometry
+open QuantumPlanarTapeProgram
+open scoped Classical
+
+theorem graph_count (x : Input) (hn : ∀ e ∈ x.1.1.2.1, e.1 ≠ e.2.1) :
+    Fintype.card (graph x hn).Edge ≤ x.1.1.2.1.length := by
+  change Fintype.card (Fin (merged x).length) ≤ _
+  rw [Fintype.card_fin]
+  exact QuantumListMerge.value_length_le_input _ _
+
+theorem graph_coefficientBound (x : Input)
+    (hn : ∀ e ∈ x.1.1.2.1, e.1 ≠ e.2.1) {m L : ℝ}
+    (hm : (x.1.1.2.1.length : ℝ) ≤ m) (hL : 0 ≤ L)
+    (hc : |(x.1.1.2.2 : ℝ)| ≤ L)
+    (hw : ∀ e ∈ x.1.1.2.1, |(e.2.2 : ℝ)| ≤ L) :
+    (graph x hn).CoefficientBound ((m+1)*L) := by
+  have hm0 : 0 ≤ m := (Nat.cast_nonneg _).trans hm
+  constructor
+  · change |(x.1.1.2.2 : ℝ)| ≤ _
+    nlinarith
+  · intro e
+    have h := QuantumListMerge.value_coefficient_bound x.1.1.1 x.1.1.2.1 hL hw
+      _ (List.get_mem (merged x) e)
+    change |(((merged x).get e).2.2 : ℝ)| ≤ _
+    exact h.trans ((mul_le_mul_of_nonneg_right hm hL).trans (by nlinarith))
+
+theorem graph_coefficientBound_of_raw (x : Input)
+    (hb : SourceBondLists.bounded x.1.1.1 x.1.1.2.1)
+    (hn : ∀ e ∈ x.1.1.2.1, e.1 ≠ e.2.1) {m L : ℝ}
+    (hm : (Fintype.card (rawGraph x hb hn).Edge : ℝ) ≤ m) (hL : 0 ≤ L)
+    (hc : (rawGraph x hb hn).CoefficientBound L) :
+    (graph x hn).CoefficientBound ((m+1)*L) := by
+  have hlen : (x.1.1.2.1.length : ℝ) ≤ m := by
+    change (Fintype.card (Fin x.1.1.2.1.length) : ℝ) ≤ m at hm
+    simpa only [Fintype.card_fin] using hm
+  apply graph_coefficientBound x hn hlen hL hc.1
+  intro e he
+  obtain ⟨i,rfl⟩ := List.mem_iff_get.mp he
+  exact hc.2 i
+
+end ContinuumCoulomb.QuantumPlanarTapeGeometry
+
+namespace ContinuumCoulomb.QuantumCrossingSelectProgram
+open QuantumPlanarTapeProgram
+open scoped Classical
+
+variable {G : QMARationalExchangeGraph} {r k : ℕ}
+    (S : QMARationalCrossingSelection G r) (labels : G.Edge ≃ Fin k)
+
+theorem compiled_planar_bounds {N : ℚ} (hN : 0 ≤ N) {m L T : ℝ}
+    (hm : (Fintype.card G.Edge : ℝ) ≤ m) (hL : 1 ≤ L) (hT : |(N : ℝ)| ≤ T)
+    (hc : G.CoefficientBound L) (x : QuantumPlanarTapeProgram.Input)
+    (hx : x.1.1 = QuantumCrossingListLayer.value
+      (QuantumCrossingListLayer.actualInput (computedLayer S labels) N (Equiv.refl _)))
+    (hn : ∀ e ∈ x.1.1.2.1, e.1 ≠ e.2.1) :
+    (QuantumPlanarTapeGeometry.graph x hn).CoefficientBound
+      ((m+9*r+1)*qmaCrossingCoefficientBound m r ((m+1)*L) T) ∧
+    (Fintype.card (QuantumPlanarTapeGeometry.graph x hn).Edge : ℝ) ≤ m+9*r := by
+  let E := qmaCrossingCoefficientBound m r ((m+1)*L) T
+  have hm0 : 0 ≤ m := (Nat.cast_nonneg _).trans hm
+  have hL0 : 0 ≤ L := by linarith
+  have hE : 0 ≤ E := by
+    dsimp [E,qmaCrossingCoefficientBound]
+    positivity
+  have hout := computedLayer_output_coefficientBound S labels hN hm hL hT hc
+  have hlen : (x.1.1.2.1.length : ℝ) ≤ m+9*r := by
+    rw [hx]
+    change ((QuantumCrossingListLayer.bonds
+      (QuantumCrossingListLayer.actualInput (computedLayer S labels) N (Equiv.refl _))).length : ℝ)
+      ≤ m+9*r
+    have h := compiled_graph_count S labels hm N
+    change (Fintype.card (Fin (QuantumCrossingListLayer.bonds
+      (QuantumCrossingListLayer.actualInput (computedLayer S labels) N (Equiv.refl _))).length) : ℝ)
+      ≤ m+9*r at h
+    simpa only [Fintype.card_fin] using h
+  constructor
+  · apply QuantumPlanarTapeGeometry.graph_coefficientBound x hn hlen hE
+    · rw [hx]
+      change |(QuantumCrossingListLayer.constant
+        (QuantumCrossingListLayer.actualInput (computedLayer S labels) N (Equiv.refl _)) : ℝ)| ≤ E
+      rw [QuantumCrossingListLayer.constant_actual (computedLayer S labels) N (Equiv.refl _)]
+      exact hout.1
+    · intro e he
+      rw [hx] at he
+      exact QuantumCrossingListLayer.actual_bonds_coefficientBound _ _ _ hout e he
+  · have h : (Fintype.card (QuantumPlanarTapeGeometry.graph x hn).Edge : ℝ) ≤
+        (x.1.1.2.1.length : ℝ) := by
+      exact_mod_cast QuantumPlanarTapeGeometry.graph_count x hn
+    exact h.trans hlen
+
+theorem compiled_planar_nat {N : ℚ} (hN : 0 ≤ N) {m L T : ℕ}
+    (hm : Fintype.card G.Edge ≤ m) (hL : 1 ≤ L) (hT : |(N : ℝ)| ≤ T)
+    (hc : G.CoefficientBound L) (x : QuantumPlanarTapeProgram.Input)
+    (hx : x.1.1 = QuantumCrossingListLayer.value
+      (QuantumCrossingListLayer.actualInput (computedLayer S labels) N (Equiv.refl _)))
+    (hn : ∀ e ∈ x.1.1.2.1, e.1 ≠ e.2.1) :
+    (QuantumPlanarTapeGeometry.graph x hn).CoefficientBound
+      ((m+9*r+1)*QuantumCoefficientPrograms.crossingCoefficient m r ((m+1)*L) T) ∧
+    Fintype.card (QuantumPlanarTapeGeometry.graph x hn).Edge ≤ m+9*r := by
+  have hm' : (Fintype.card G.Edge : ℝ) ≤ m := by exact_mod_cast hm
+  have hL' : (1 : ℝ) ≤ L := by exact_mod_cast hL
+  have h := compiled_planar_bounds S labels hN hm' hL' hT hc x hx hn
+  constructor
+  · simpa only [Nat.cast_mul,Nat.cast_add,Nat.cast_one,Nat.cast_ofNat,
+      QuantumCoefficientPrograms.crossingCoefficient_cast] using h.1
+  · exact_mod_cast h.2
+
+end ContinuumCoulomb.QuantumCrossingSelectProgram
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumMergedEndpointPairs.lean

@@ -0,0 +1,55 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumMergedOutputRoutes
+
+namespace OAI
+
+/-! Distinct merged interactions have different unordered physical endpoints. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open scoped Classical
+
+theorem qmaMergedEndpointPairs_injective (G : QMARationalExchangeGraph)
+    (position : Fin G.n → ℕ × ℕ) (hp : Function.Injective position) :
+    Function.Injective (fun e : G.merge.Edge => s(position (G.merge.left e),position (G.merge.right e))) := by
+  intro e f h
+  rcases Sym2.eq_iff.mp h with ⟨hl,hr⟩ | ⟨hl,hr⟩
+  · exact G.merge_pair_injective (Prod.ext (hp hl) (hp hr))
+  · have hleft := hp hl
+    have hright := hp hr
+    have he := G.mergedEdge_lt e
+    have hf := G.mergedEdge_lt f
+    change G.merge.left e < G.merge.right e at he
+    change G.merge.left f < G.merge.right f at hf
+    rw [hleft,hright] at he
+    exact (lt_asymm he hf).elim
+
+namespace QMACellRoute
+
+def endpointPair (R : QMACellRoute) : Sym2 (ℕ × ℕ) := s(R.source,R.target)
+
+theorem endpointPair_body (R : QMACellRoute) : R.endpointPair = s(R.body.source,R.body.target) := by
+  rcases R with ⟨b,r⟩
+  cases r
+  · rfl
+  · exact Sym2.eq_swap
+
+end QMACellRoute
+namespace QMAPortRouteData
+variable {G : QMARationalExchangeGraph} (P : QMAPortRouteData G)
+
+theorem mergedOutputRoute_pairs_injective (N : ℚ) {D : ℕ} (hD : ∀ e, P.length e ≤ D)
+    (havoid : ∀ i : P.Interior, ∀ v, P.cell i ≠ P.position v) :
+    Function.Injective (fun e => (P.mergedOutputRoute N hD havoid e).endpointPair) := by
+  intro e f h
+  apply qmaMergedEndpointPairs_injective (P.crossingOutput N hD)
+    (P.crossingPosition N D) (P.crossingPosition_injective N D)
+  have he := P.mergedOutputRoute_spec N hD havoid e
+  have hf := P.mergedOutputRoute_spec N hD havoid f
+  simpa only [QMACellRoute.endpointPair,he.2.2.1,he.2.2.2,hf.2.2.1,hf.2.2.2] using h
+
+end QMAPortRouteData
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumMergedOutputRoutes.lean

@@ -0,0 +1,104 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCrossingOutputRoutes
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumMergeEdges
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRouteEnumeration
+
+namespace OAI
+
+/-! Exact parallel-edge merging preserves the physical placement and reverses
+the catalog route when canonical endpoint ordering requires it. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open scoped Classical
+namespace QMACellRoute
+
+def reverse (R : QMACellRoute) : QMACellRoute := ⟨R.body,!R.reversed⟩
+
+@[simp] theorem reverse_body (R : QMACellRoute) : R.reverse.body = R.body := rfl
+
+@[simp] theorem reverse_source (R : QMACellRoute) : R.reverse.source = R.target := by
+  rcases R with ⟨b,r⟩
+  cases r <;> rfl
+
+@[simp] theorem reverse_target (R : QMACellRoute) : R.reverse.target = R.source := by
+  rcases R with ⟨b,r⟩
+  cases r <;> rfl
+
+@[simp] theorem reverse_valid (R : QMACellRoute) : R.reverse.Valid = R.Valid := rfl
+
+end QMACellRoute
+namespace QMAPortRouteData
+variable {G : QMARationalExchangeGraph} (P : QMAPortRouteData G)
+
+theorem mergedOutput_route_exists (N : ℚ) {D : ℕ} (hD : ∀ e, P.length e ≤ D)
+    (havoid : ∀ i : P.Interior, ∀ v, P.cell i ≠ P.position v)
+    (e : (P.crossingOutput N hD).merge.Edge) :
+    ∃ R : QMACellRoute, P.RoutingAllowed R.body ∧ R.Valid ∧
+      R.source = P.crossingPosition N D ((P.crossingOutput N hD).merge.left e) ∧
+      R.target = P.crossingPosition N D ((P.crossingOutput N hD).merge.right e) := by
+  obtain ⟨f,hf⟩ := (P.crossingOutput N hD).merge_edge_source e
+  obtain ⟨R,hR,hv,hl,hr⟩ := P.crossingOutput_route_exists N hD havoid f
+  rcases hf with ⟨hleft,hright⟩ | ⟨hleft,hright⟩
+  · exact ⟨R,hR,hv,hl.trans (congrArg (P.crossingPosition N D) hleft.symm),
+      hr.trans (congrArg (P.crossingPosition N D) hright.symm)⟩
+  · refine ⟨R.reverse,hR,hv,?_,?_⟩
+    · exact R.reverse_source.trans (hr.trans (congrArg (P.crossingPosition N D) hleft.symm))
+    · exact R.reverse_target.trans (hl.trans (congrArg (P.crossingPosition N D) hright.symm))
+
+def findMergedRoute (N : ℚ) {D : ℕ} (hD : ∀ e, P.length e ≤ D)
+    (e : (P.crossingOutput N hD).merge.Edge) : Option QMACellRoute :=
+  (qmaRouteCandidates
+    (P.crossingPosition N D ((P.crossingOutput N hD).merge.left e))
+    (P.crossingPosition N D ((P.crossingOutput N hD).merge.right e))).find? (fun R =>
+      decide (P.RoutingAllowed R.body ∧ R.Valid ∧
+        R.source = P.crossingPosition N D ((P.crossingOutput N hD).merge.left e) ∧
+        R.target = P.crossingPosition N D ((P.crossingOutput N hD).merge.right e)))
+
+theorem findMergedRoute_isSome (N : ℚ) {D : ℕ} (hD : ∀ e, P.length e ≤ D)
+    (havoid : ∀ i : P.Interior, ∀ v, P.cell i ≠ P.position v)
+    (e : (P.crossingOutput N hD).merge.Edge) : (P.findMergedRoute N hD e).isSome := by
+  obtain ⟨R,hR,hvalid,hs,ht⟩ := P.mergedOutput_route_exists N hD havoid e
+  apply List.find?_isSome.mpr
+  refine ⟨R,?_,?_⟩
+  · simpa only [hs,ht] using qmaRouteCandidates_complete R
+  · exact decide_eq_true ⟨hR,hvalid,hs,ht⟩
+
+theorem findMergedRoute_spec (N : ℚ) {D : ℕ} (hD : ∀ e, P.length e ≤ D)
+    (e : (P.crossingOutput N hD).merge.Edge) {R : QMACellRoute}
+    (h : P.findMergedRoute N hD e = some R) :
+    P.RoutingAllowed R.body ∧ R.Valid ∧
+      R.source = P.crossingPosition N D ((P.crossingOutput N hD).merge.left e) ∧
+      R.target = P.crossingPosition N D ((P.crossingOutput N hD).merge.right e) := by
+  unfold findMergedRoute at h
+  have hp := List.find?_some h
+  exact of_decide_eq_true hp
+
+
+def mergedOutputRoute (N : ℚ) {D : ℕ} (hD : ∀ e, P.length e ≤ D)
+    (havoid : ∀ i : P.Interior, ∀ v, P.cell i ≠ P.position v)
+    (e : (P.crossingOutput N hD).merge.Edge) : QMACellRoute :=
+  (P.findMergedRoute N hD e).get (P.findMergedRoute_isSome N hD havoid e)
+
+theorem mergedOutputRoute_spec (N : ℚ) {D : ℕ} (hD : ∀ e, P.length e ≤ D)
+    (havoid : ∀ i : P.Interior, ∀ v, P.cell i ≠ P.position v)
+    (e : (P.crossingOutput N hD).merge.Edge) :
+    P.RoutingAllowed (P.mergedOutputRoute N hD havoid e).body ∧
+    (P.mergedOutputRoute N hD havoid e).Valid ∧
+    (P.mergedOutputRoute N hD havoid e).source =
+      P.crossingPosition N D ((P.crossingOutput N hD).merge.left e) ∧
+    (P.mergedOutputRoute N hD havoid e).target =
+      P.crossingPosition N D ((P.crossingOutput N hD).merge.right e) := by
+  apply P.findMergedRoute_spec N hD e
+  exact (Option.some_get (P.findMergedRoute_isSome N hD havoid e)).symm
+
+theorem mergedOutput_energy_error {N : ℚ} (hN : 0 < N) {D : ℕ} (hD : ∀ e, P.length e ≤ D) :
+    |(P.crossingOutput N hD).merge.energy-G.energy| ≤ ((D+1:ℕ):ℝ)/(N:ℝ) := by
+  rw [QMARationalExchangeGraph.merge_energy]
+  exact P.portCrossing_energy_error hN hD
+
+end QMAPortRouteData
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumMergedSupport.lean

@@ -0,0 +1,168 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumListMergeProperties
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumMergeEdges
+
+namespace OAI
+
+/-! Canonical merging preserves exactly the unordered endpoint support.
+This includes edges whose merged coefficient is zero. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open scoped Classical
+
+theorem qmaUnorderedPair_map {α β : Type*} (f : α → β) {a b c d : α}
+    (h : s(a,b) = s(c,d)) : s(f a,f b) = s(f c,f d) := by
+  rcases Sym2.eq_iff.mp h with ⟨ha,hb⟩ | ⟨ha,hb⟩
+  · rw [ha,hb]
+  · rw [ha,hb]
+    exact Sym2.eq_swap
+
+namespace QuantumListMerge
+open MediatorListProgram
+
+theorem ordered_endpointPair (e : Bond) :
+    s((ordered e).1,(ordered e).2) = s(e.1,e.2.1) := by
+  rcases le_total e.1 e.2.1 with h | h
+  · simp only [ordered,min_eq_left h,max_eq_right h]
+  · simpa only [ordered,min_eq_right h,max_eq_left h] using
+      (Sym2.eq_swap : s(e.2.1,e.1) = s(e.1,e.2.1))
+
+theorem value_edge_source (n : ℕ) (xs : List Bond) {e : Bond}
+    (he : e ∈ value n xs) :
+    ∃ f ∈ xs, s(e.1,e.2.1) = s(f.1,f.2.1) := by
+  obtain ⟨p,hp,rfl⟩ := List.mem_map.mp he
+  have hm := of_decide_eq_true (List.mem_filter.mp hp).2
+  obtain ⟨f,hf,hfp⟩ := List.mem_map.mp hm
+  refine ⟨f,hf,?_⟩
+  rw [← hfp]
+  exact ordered_endpointPair f
+
+theorem value_edge_target {n : ℕ} {xs : List Bond}
+    (hb : SourceBondLists.bounded n xs) {f : Bond} (hf : f ∈ xs) :
+    ∃ e ∈ value n xs, s(e.1,e.2.1) = s(f.1,f.2.1) := by
+  have hp : ordered f ∈ support n xs :=
+    (mem_support hb _).mpr (List.mem_map.mpr ⟨f,hf,rfl⟩)
+  refine ⟨((ordered f).1,(ordered f).2,weight xs (ordered f)),?_,ordered_endpointPair f⟩
+  exact List.mem_map.mpr ⟨ordered f,hp,rfl⟩
+
+theorem value_support {n : ℕ} {xs : List Bond}
+    (hb : SourceBondLists.bounded n xs) (p : Sym2 ℕ) :
+    (∃ e ∈ value n xs, s(e.1,e.2.1) = p) ↔ ∃ e ∈ xs, s(e.1,e.2.1) = p := by
+  constructor
+  · rintro ⟨e,he,hp⟩
+    obtain ⟨f,hf,hef⟩ := value_edge_source n xs he
+    exact ⟨f,hf,hef.symm.trans hp⟩
+  · rintro ⟨f,hf,hp⟩
+    obtain ⟨e,he,hef⟩ := value_edge_target hb hf
+    exact ⟨e,he,hef.trans hp⟩
+
+end QuantumListMerge
+
+namespace QMARationalExchangeGraph
+
+theorem orderedPair_endpointPair (G : QMARationalExchangeGraph) (e : G.Edge) :
+    s((G.orderedPair e).1,(G.orderedPair e).2) = s(G.left e,G.right e) := by
+  rcases le_total (G.left e) (G.right e) with h | h
+  · simp only [orderedPair,min_eq_left h,max_eq_right h]
+  · simpa only [orderedPair,min_eq_right h,max_eq_left h] using
+      (Sym2.eq_swap : s(G.right e,G.left e) = s(G.left e,G.right e))
+
+theorem merge_unordered_source (G : QMARationalExchangeGraph) (e : G.merge.Edge) :
+    ∃ f : G.Edge, s(G.merge.left e,G.merge.right e) = s(G.left f,G.right f) := by
+  obtain ⟨f,hf⟩ := G.merge_edge_source e
+  exact ⟨f,Sym2.eq_iff.mpr hf⟩
+
+theorem merge_unordered_target (G : QMARationalExchangeGraph) (f : G.Edge) :
+    ∃ e : G.merge.Edge, s(G.merge.left e,G.merge.right e) = s(G.left f,G.right f) :=
+  ⟨G.edgeClass f,G.orderedPair_endpointPair f⟩
+
+theorem merge_support (G : QMARationalExchangeGraph) (p : Sym2 (Fin G.n)) :
+    (∃ e : G.merge.Edge, s(G.merge.left e,G.merge.right e) = p) ↔
+      ∃ f : G.Edge, s(G.left f,G.right f) = p := by
+  constructor
+  · rintro ⟨e,hp⟩
+    obtain ⟨f,hef⟩ := G.merge_unordered_source e
+    exact ⟨f,hef.symm.trans hp⟩
+  · rintro ⟨f,hp⟩
+    obtain ⟨e,hef⟩ := G.merge_unordered_target f
+    exact ⟨e,hef.trans hp⟩
+
+theorem merge_nat_support (G : QMARationalExchangeGraph) (p : Sym2 ℕ) :
+    (∃ e : G.merge.Edge, s((G.merge.left e).val,(G.merge.right e).val) = p) ↔
+      ∃ f : G.Edge, s((G.left f).val,(G.right f).val) = p := by
+  constructor
+  · rintro ⟨e,hp⟩
+    obtain ⟨f,hef⟩ := G.merge_unordered_source e
+    exact ⟨f,(qmaUnorderedPair_map Fin.val hef).symm.trans hp⟩
+  · rintro ⟨f,hp⟩
+    obtain ⟨e,hef⟩ := G.merge_unordered_target f
+    exact ⟨e,(qmaUnorderedPair_map Fin.val hef).trans hp⟩
+
+variable (G H : QMARationalExchangeGraph) (vertex : Fin G.n ≃ Fin H.n)
+
+theorem merge_support_forward
+    (forward : ∀ e : G.Edge, ∃ f : H.Edge,
+      s(vertex (G.left e),vertex (G.right e)) = s(H.left f,H.right f))
+    (e : G.merge.Edge) :
+    ∃ f : H.merge.Edge,
+      s(vertex (G.merge.left e),vertex (G.merge.right e)) = s(H.merge.left f,H.merge.right f) := by
+  obtain ⟨a,ha⟩ := G.merge_unordered_source e
+  obtain ⟨b,hb⟩ := forward a
+  obtain ⟨f,hf⟩ := H.merge_unordered_target b
+  exact ⟨f,(qmaUnorderedPair_map vertex ha).trans (hb.trans hf.symm)⟩
+
+theorem merge_support_backward
+    (backward : ∀ f : H.Edge, ∃ e : G.Edge,
+      s(vertex (G.left e),vertex (G.right e)) = s(H.left f,H.right f))
+    (f : H.merge.Edge) :
+    ∃ e : G.merge.Edge,
+      s(vertex (G.merge.left e),vertex (G.merge.right e)) = s(H.merge.left f,H.merge.right f) := by
+  obtain ⟨b,hb⟩ := H.merge_unordered_source f
+  obtain ⟨a,ha⟩ := backward b
+  obtain ⟨e,he⟩ := G.merge_unordered_target a
+  exact ⟨e,(qmaUnorderedPair_map vertex he).trans (ha.trans hb.symm)⟩
+
+end QMARationalExchangeGraph
+
+namespace QuantumListGraph
+open MediatorListProgram
+
+theorem ofBonds_nat_support (n : ℕ) (xs : List Bond) (c : ℚ)
+    (hb : SourceBondLists.bounded n xs) (hn : ∀ e ∈ xs, e.1 ≠ e.2.1)
+    (p : Sym2 ℕ) :
+    (∃ i : (ofBonds n xs c hb hn).Edge,
+      s(((ofBonds n xs c hb hn).left i).val,((ofBonds n xs c hb hn).right i).val) = p) ↔
+      ∃ e ∈ xs, s(e.1,e.2.1) = p := by
+  constructor
+  · rintro ⟨i,hi⟩
+    exact ⟨xs.get i,List.get_mem xs i,hi⟩
+  · rintro ⟨e,he,hp⟩
+    obtain ⟨i,hi⟩ := List.mem_iff_get.mp he
+    refine ⟨i,?_⟩
+    change s((xs.get i).1,(xs.get i).2.1) = p
+    rwa [hi]
+
+theorem mergedTape_nat_support (n : ℕ) (xs : List Bond) (c : ℚ)
+    (hb : SourceBondLists.bounded n xs) (hn : ∀ e ∈ xs, e.1 ≠ e.2.1)
+    (p : Sym2 ℕ) :
+    (∃ i : (ofBonds n (QuantumListMerge.value n xs) c
+      (QuantumListMerge.bounded n xs) (QuantumListMerge.noLoops hn)).Edge,
+      s(((ofBonds n (QuantumListMerge.value n xs) c
+        (QuantumListMerge.bounded n xs) (QuantumListMerge.noLoops hn)).left i).val,
+        ((ofBonds n (QuantumListMerge.value n xs) c
+          (QuantumListMerge.bounded n xs) (QuantumListMerge.noLoops hn)).right i).val) = p) ↔
+      ∃ e : (ofBonds n xs c hb hn).merge.Edge,
+        s((((ofBonds n xs c hb hn).merge).left e).val,
+          (((ofBonds n xs c hb hn).merge).right e).val) = p := by
+  exact (ofBonds_nat_support n (QuantumListMerge.value n xs) c
+    (QuantumListMerge.bounded n xs) (QuantumListMerge.noLoops hn) p).trans
+    ((QuantumListMerge.value_support hb p).trans
+      ((ofBonds_nat_support n xs c hb hn p).symm.trans
+        ((ofBonds n xs c hb hn).merge_nat_support p).symm))
+
+end QuantumListGraph
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumNearestCircuit.lean

@@ -0,0 +1,66 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumNearestGate
+
+namespace OAI
+
+/-! Exact nearest-neighbor compilation with an explicit polynomial size bound. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped Classical
+
+theorem qmaNearestList_matrix (work : ℕ) (gs : List QMAGate) :
+    qmaGateProduct work (gs.flatMap (qmaNearestGate work)) = qmaGateProduct work gs := by
+  induction gs with
+  | nil => rfl
+  | cons g gs ih =>
+    change qmaGateProduct work (qmaNearestGate work g ++ gs.flatMap (qmaNearestGate work)) = _
+    rw [qmaGateProduct_append,ih,qmaNearestGate_matrix]
+    change _ = qmaGateProduct work ([g]++gs)
+    rw [qmaGateProduct_append,qmaGateProduct_singleton]
+
+theorem qmaNearestList_length (work : ℕ) (gs : List QMAGate) :
+    (gs.flatMap (qmaNearestGate work)).length ≤ (6*work+7)*gs.length := by
+  induction gs with
+  | nil => simp
+  | cons g gs ih =>
+    simp only [List.flatMap_cons,List.length_append,List.length_cons]
+    have hg := qmaNearestGate_length work g
+    nlinarith
+
+abbrev qmaNearestCircuit (c : QMACircuit) : QMACircuit :=
+  ⟨c.work,c.witness,c.gates.flatMap (qmaNearestGate c.work)⟩
+
+theorem qmaNearestCircuit_wellFormed (c : QMACircuit) (hc : c.WellFormed) :
+    (qmaNearestCircuit c).WellFormed := by
+  refine ⟨hc.1,?_⟩
+  intro g hg
+  obtain ⟨k,hk,hg⟩ := List.mem_flatMap.mp hg
+  exact (qmaNearestGate_valid c.work k (hc.2 k hk) g hg).1
+
+theorem qmaNearestCircuit_adjacent (c : QMACircuit) (hc : c.WellFormed) :
+    ∀ g ∈ (qmaNearestCircuit c).gates, g.Adjacent := by
+  intro g hg
+  obtain ⟨k,hk,hg⟩ := List.mem_flatMap.mp hg
+  exact (qmaNearestGate_valid c.work k (hc.2 k hk) g hg).2
+
+theorem qmaNearestCircuit_acceptance (c : QMACircuit) (hc : c.WellFormed)
+    (psi : EuclideanSpace ℂ (SourceSpinBasis c.witness)) :
+    qmaAcceptance (qmaNearestCircuit c) (qmaNearestCircuit_wellFormed c hc) psi =
+      qmaAcceptance c hc psi := by
+  have hm : qmaCircuitMatrix (qmaNearestCircuit c) = qmaCircuitMatrix c :=
+    qmaNearestList_matrix c.work c.gates
+  unfold qmaAcceptance
+  rw [hm]
+  rfl
+
+theorem qmaNearestCircuit_size (c : QMACircuit) :
+    (qmaNearestCircuit c).work+(qmaNearestCircuit c).gates.length ≤
+      c.work+(6*c.work+7)*c.gates.length := by
+  exact Nat.add_le_add_left (qmaNearestList_length c.work c.gates) c.work
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumNearestGate.lean

@@ -0,0 +1,102 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAdjacentCnot
+
+namespace OAI
+
+/-! Replacing a gate by an exact bounded-length nearest-neighbor gate sequence. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped Classical
+
+def QMAGate.Adjacent : QMAGate → Prop
+  | .controlledNot i j => i+1 = j ∨ j+1 = i
+  | _ => True
+
+theorem qmaAdjacentCnot_valid (work a d : ℕ) (h : a+d+1 < work+1) (b : Bool) :
+    ∀ g ∈ qmaAdjacentCnot work a d h b, g.WellFormed (work+1) ∧ g.Adjacent := by
+  induction d generalizing a with
+  | zero =>
+    intro g hg
+    have he : g = qmaOrderedCnot a (a+1) b := by simpa [qmaAdjacentCnot] using hg
+    subst g
+    cases b <;> simp only [qmaOrderedCnot,Bool.false_eq_true,ite_false,ite_true,
+      QMAGate.WellFormed,QMAGate.Adjacent]
+    · exact ⟨⟨h,by omega,by omega⟩,by simp⟩
+    · exact ⟨⟨by omega,h,by omega⟩,by simp⟩
+  | succ d ih =>
+    intro g hg
+    simp only [qmaAdjacentCnot,List.mem_append] at hg
+    rcases hg with (hg | hg) | hg
+    · have hs : g.WellFormed (work+1) := qmaWireSwapGates_wellFormed
+        (⟨a,by omega⟩ : Fin (work+1)) ⟨a+1,by omega⟩ (by intro he; cases he) g hg
+      refine ⟨hs,?_⟩
+      simp only [qmaWireSwapGates,List.mem_cons,List.not_mem_nil,or_false] at hg
+      rcases hg with rfl | rfl | rfl <;> simp [QMAGate.Adjacent]
+    · exact ih (a+1) (by omega) g hg
+    · have hs : g.WellFormed (work+1) := qmaWireSwapGates_wellFormed
+        (⟨a,by omega⟩ : Fin (work+1)) ⟨a+1,by omega⟩ (by intro he; cases he) g hg
+      refine ⟨hs,?_⟩
+      simp only [qmaWireSwapGates,List.mem_cons,List.not_mem_nil,or_false] at hg
+      rcases hg with rfl | rfl | rfl <;> simp [QMAGate.Adjacent]
+
+def qmaNearestGate (work : ℕ) : QMAGate → List QMAGate
+  | .controlledNot i j =>
+      if h : i < j ∧ j < work+1 then
+        qmaAdjacentCnot work i (j-i-1) (by omega) true
+      else if h : j < i ∧ i < work+1 then
+        qmaAdjacentCnot work j (i-j-1) (by omega) false
+      else [.controlledNot i j]
+  | g => [g]
+
+theorem qmaNearestGate_matrix (work : ℕ) (g : QMAGate) :
+    qmaGateProduct work (qmaNearestGate work g) = qmaGateMatrix work g := by
+  cases g with
+  | hadamard i => exact qmaGateProduct_singleton _ _
+  | phaseT i => exact qmaGateProduct_singleton _ _
+  | controlledNot i j =>
+    by_cases h : i < j ∧ j < work+1
+    · simp only [qmaNearestGate,dite_eq_left h,qmaAdjacentCnot_matrix,qmaOrderedCnot,ite_true]
+      have he : i+(j-i-1)+1 = j := by omega
+      rw [he]
+    · by_cases h' : j < i ∧ i < work+1
+      · simp only [qmaNearestGate,dite_eq_right h,dite_eq_left h',qmaAdjacentCnot_matrix,
+          qmaOrderedCnot,Bool.false_eq_true,ite_false]
+        have he : j+(i-j-1)+1 = i := by omega
+        rw [he]
+      · simp only [qmaNearestGate,dite_eq_right h,dite_eq_right h',qmaGateProduct_singleton]
+
+theorem qmaNearestGate_valid (work : ℕ) (g : QMAGate) (hg : g.WellFormed (work+1)) :
+    ∀ k ∈ qmaNearestGate work g, k.WellFormed (work+1) ∧ k.Adjacent := by
+  cases g with
+  | hadamard i => simpa [qmaNearestGate,QMAGate.Adjacent] using hg
+  | phaseT i => simpa [qmaNearestGate,QMAGate.Adjacent] using hg
+  | controlledNot i j =>
+    rcases hg with ⟨hi,hj,hne⟩
+    by_cases h : i < j ∧ j < work+1
+    · simp only [qmaNearestGate,dite_eq_left h]
+      exact qmaAdjacentCnot_valid _ _ _ _ _
+    · have h' : j < i ∧ i < work+1 := by omega
+      simp only [qmaNearestGate,dite_eq_right h,dite_eq_left h']
+      exact qmaAdjacentCnot_valid _ _ _ _ _
+
+theorem qmaNearestGate_length (work : ℕ) (g : QMAGate) :
+    (qmaNearestGate work g).length ≤ 6*work+7 := by
+  cases g with
+  | hadamard i => simp [qmaNearestGate]
+  | phaseT i => simp [qmaNearestGate]
+  | controlledNot i j =>
+    by_cases h : i < j ∧ j < work+1
+    · simp only [qmaNearestGate,dite_eq_left h,qmaAdjacentCnot_length]
+      omega
+    · by_cases h' : j < i ∧ i < work+1
+      · simp only [qmaNearestGate,dite_eq_right h,dite_eq_left h',qmaAdjacentCnot_length]
+        omega
+      · simp only [qmaNearestGate,dite_eq_right h,dite_eq_right h',List.length_singleton]
+        omega
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumNearestProgram.lean

@@ -0,0 +1,128 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAdjacentProgram
+
+namespace OAI
+
+/-! Literal nearest-neighbor gate compilation. All finite loops use the
+unary work bound; malformed gate indices take the original singleton branch. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumCircuitCode
+open ExactQuantumFactoring.BitStackProgram
+
+abbrev NearestInput := ℕ × QMAGate
+def nearestInputCode : NearestInput → List Bool := prodCode unaryCode gateCode
+
+def forwardGuard (x : NearestInput) : Bool :=
+  decide (gateLeft x.2+1 ≤ gateRight x.2 ∧ gateRight x.2 ≤ x.1)
+def backwardGuard (x : NearestInput) : Bool :=
+  decide (gateRight x.2+1 ≤ gateLeft x.2 ∧ gateLeft x.2 ≤ x.1)
+
+def nearestValue (x : NearestInput) : List QMAGate :=
+  if gateTag x.2=2 then
+    if forwardGuard x then
+      adjacentList (gateLeft x.2) (min x.1 (gateRight x.2-gateLeft x.2-1)) true
+    else if backwardGuard x then
+      adjacentList (gateRight x.2) (min x.1 (gateLeft x.2-gateRight x.2-1)) false
+    else [x.2]
+  else [x.2]
+
+theorem nearestValue_eq (x : NearestInput) : nearestValue x=qmaNearestGate x.1 x.2 := by
+  rcases x with ⟨work,g⟩
+  cases g with
+  | hadamard i => rfl
+  | phaseT i => rfl
+  | controlledNot i j =>
+    by_cases h : i < j ∧ j < work+1
+    · have hg : forwardGuard (work,.controlledNot i j)=true := by
+        change decide (i+1 ≤ j ∧ j ≤ work) = true
+        simp only [decide_eq_true_eq]
+        omega
+      have hd : j-i-1 ≤ work := by omega
+      simp only [nearestValue,gateTag,gateLeft,gateRight,ite_true,hg,min_eq_right hd,
+        qmaNearestGate,dite_eq_left h]
+      exact (adjacentList_eq work i (j-i-1) (by omega) true).symm
+    · have hg : forwardGuard (work,.controlledNot i j)=false := by
+        change decide (i+1 ≤ j ∧ j ≤ work) = false
+        simp only [decide_eq_false_iff_not]
+        omega
+      by_cases h' : j < i ∧ i < work+1
+      · have hr : backwardGuard (work,.controlledNot i j)=true := by
+          change decide (j+1 ≤ i ∧ i ≤ work) = true
+          simp only [decide_eq_true_eq]
+          omega
+        have hd : i-j-1 ≤ work := by omega
+        simp only [nearestValue,gateTag,gateLeft,gateRight,ite_true,hg,Bool.false_eq_true,ite_false,hr,min_eq_right hd,
+          qmaNearestGate,dite_eq_right h,dite_eq_left h']
+        exact (adjacentList_eq work j (i-j-1) (by omega) false).symm
+      · have hr : backwardGuard (work,.controlledNot i j)=false := by
+          change decide (j+1 ≤ i ∧ i ≤ work) = false
+          simp only [decide_eq_false_iff_not]
+          omega
+        simp only [nearestValue,gateTag,gateLeft,gateRight,ite_true,hg,hr,Bool.false_eq_true,ite_false,
+          qmaNearestGate,dite_eq_right h,dite_eq_right h']
+
+private noncomputable def workBits : Procedure nearestInputCode Nat.bits Prod.fst :=
+  Procedure.unaryToBits.comp (Procedure.first unaryCode gateCode)
+private noncomputable def leftBits : Procedure nearestInputCode Nat.bits (fun x => gateLeft x.2) :=
+  gateLeftProgram.comp (Procedure.second unaryCode gateCode)
+private noncomputable def rightBits : Procedure nearestInputCode Nat.bits (fun x => gateRight x.2) :=
+  gateRightProgram.comp (Procedure.second unaryCode gateCode)
+
+noncomputable def forwardGuardProgram : Procedure nearestInputCode Procedure.boolCode forwardGuard :=
+  (Procedure.boolAnd.comp
+    ((Procedure.binaryLe.comp ((Procedure.successor.comp leftBits).pair rightBits)).pair
+      (Procedure.binaryLe.comp (rightBits.pair workBits)))).congrFun (by
+        intro x
+        simp [forwardGuard,Function.comp_apply])
+
+noncomputable def backwardGuardProgram : Procedure nearestInputCode Procedure.boolCode backwardGuard :=
+  (Procedure.boolAnd.comp
+    ((Procedure.binaryLe.comp ((Procedure.successor.comp rightBits).pair leftBits)).pair
+      (Procedure.binaryLe.comp (leftBits.pair workBits)))).congrFun (by
+        intro x
+        simp [backwardGuard,Function.comp_apply])
+
+noncomputable def nearestProgram : Procedure nearestInputCode (listCode gateCode) nearestValue := by
+  let work := Procedure.first unaryCode gateCode
+  let gate := Procedure.second unaryCode gateCode
+  let one := (Procedure.listCons gateCode).comp
+    (gate.pair (Procedure.constant nearestInputCode (listCode gateCode) []))
+  let dForward := Procedure.binarySub.comp
+    ((Procedure.binarySub.comp (rightBits.pair leftBits)).pair
+      (Procedure.constant nearestInputCode Nat.bits 1))
+  let dBackward := Procedure.binarySub.comp
+    ((Procedure.binarySub.comp (leftBits.pair rightBits)).pair
+      (Procedure.constant nearestInputCode Nat.bits 1))
+  let forward := adjacentProgram.comp ((Procedure.clippedUnary.comp (work.pair dForward)).pair
+    (leftBits.pair (Procedure.constant nearestInputCode Procedure.boolCode true)))
+  let backward := adjacentProgram.comp ((Procedure.clippedUnary.comp (work.pair dBackward)).pair
+    (rightBits.pair (Procedure.constant nearestInputCode Procedure.boolCode false)))
+  let cnot := Procedure.binaryEq.comp ((gateTagProgram.comp gate).pair
+    (Procedure.constant nearestInputCode Nat.bits 2))
+  exact (Procedure.conditional cnot
+    (Procedure.conditional forwardGuardProgram forward
+      (Procedure.conditional backwardGuardProgram backward one)) one).congrFun (by
+        intro x
+        simp only [nearestValue,Function.comp_apply,decide_eq_true_eq])
+
+noncomputable def nearestListProgram :
+    Procedure circuitCode (listCode gateCode) (fun c => c.gates.flatMap (qmaNearestGate c.work)) := by
+  let rows := Procedure.listMapWith (ea := unaryCode) (eb := gateCode) (ec := listCode gateCode)
+    (f := fun work g => nearestValue (work,g)) (.hadamard 0) [] nearestProgram
+  exact ((QuantumRawExchange.flattenProgram gateCode (.hadamard 0)).comp
+    (rows.comp (workProgram.pair gatesProgram))).congrFun (by
+      intro c
+      simp only [Function.comp_apply,List.flatMap_def]
+      congr 1
+      apply List.map_congr_left
+      intro g _
+      exact nearestValue_eq (c.work,g))
+
+noncomputable def nearestCircuitProgram : Procedure circuitCode circuitCode qmaNearestCircuit :=
+  (workProgram.pair (witnessProgram.pair nearestListProgram)).result (by intro c; rfl)
+
+end ContinuumCoulomb.QuantumCircuitCode
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOddPathGeometry.lean

@@ -0,0 +1,67 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumGridWalk
+
+namespace OAI
+
+/-! The odd subdivision gadget splits a routed edge into two unit edges and
+its reversed remaining tail. The two fresh vertices are the first two route points. -/
+
+namespace ContinuumCoulomb
+
+def qmaOddSplitLength (L : ℕ) : Fin 3 → ℕ := ![1,1,L-2]
+def qmaOddSplitIndex (L : ℕ) (e : Fin 3) (k : ℕ) : ℕ :=
+  if e = 0 then k+1 else if e = 1 then k else L-k
+
+theorem qmaOddSplitIndex_bounds {L : ℕ} (hL : 3 ≤ L) (e : Fin 3) {k : ℕ}
+    (hk : k ≤ qmaOddSplitLength L e) : qmaOddSplitIndex L e k ≤ L := by
+  fin_cases e <;> simp [qmaOddSplitLength,qmaOddSplitIndex] at * <;> omega
+
+theorem qmaOddSplitIndex_zero (L : ℕ) :
+    (fun e => qmaOddSplitIndex L e 0) = ![1,0,L] := by
+  funext e
+  fin_cases e <;> simp [qmaOddSplitIndex]
+
+theorem qmaOddSplitIndex_last {L : ℕ} (hL : 3 ≤ L) :
+    (fun e => qmaOddSplitIndex L e (qmaOddSplitLength L e)) = ![2,1,2] := by
+  funext e
+  fin_cases e <;> simp [qmaOddSplitLength,qmaOddSplitIndex]
+  omega
+
+theorem qmaOddSplitIndex_injective {L : ℕ} (hL : 3 ≤ L) (e : Fin 3)
+    {i j : ℕ} (hi : i ≤ qmaOddSplitLength L e) (hj : j ≤ qmaOddSplitLength L e)
+    (h : qmaOddSplitIndex L e i = qmaOddSplitIndex L e j) : i = j := by
+  fin_cases e <;> (simp [qmaOddSplitLength,qmaOddSplitIndex] at *; omega)
+
+theorem qmaOddSplitIndex_interior {L : ℕ} (hL : 3 ≤ L) (e : Fin 3) {i : ℕ}
+    (hi0 : 0 < i) (hi : i < qmaOddSplitLength L e) :
+    e = 2 ∧ 2 < qmaOddSplitIndex L e i ∧ qmaOddSplitIndex L e i < L := by
+  fin_cases e <;> simp [qmaOddSplitLength,qmaOddSplitIndex] at * <;> omega
+
+theorem qmaOddSplitIndex_separated {L : ℕ} (hL : 3 ≤ L) (e f : Fin 3) {i j : ℕ}
+    (hi0 : 0 < i) (hi : i < qmaOddSplitLength L e)
+    (hj : j ≤ qmaOddSplitLength L f)
+    (h : qmaOddSplitIndex L e i = qmaOddSplitIndex L f j) : e = f := by
+  obtain ⟨rfl,hi2,hiL⟩ := qmaOddSplitIndex_interior hL e hi0 hi
+  fin_cases f <;> simp [qmaOddSplitLength,qmaOddSplitIndex] at * <;> omega
+
+theorem qmaOddSplitIndex_step {L : ℕ} (hL : 3 ≤ L) (e : Fin 3) {i : ℕ}
+    (hi : i < qmaOddSplitLength L e) :
+    qmaOddSplitIndex L e (i+1) = qmaOddSplitIndex L e i+1 ∨
+      qmaOddSplitIndex L e i = qmaOddSplitIndex L e (i+1)+1 := by
+  fin_cases e <;> simp [qmaOddSplitLength,qmaOddSplitIndex] at *
+  omega
+
+theorem qmaOddSplitPoint_step {L : ℕ} (hL : 3 ≤ L) (p : ℕ → ℕ × ℕ)
+    (hp : ∀ i < L, qmaSquareGrid.Adj (p i) (p (i+1))) (e : Fin 3) {i : ℕ}
+    (hi : i < qmaOddSplitLength L e) :
+    qmaSquareGrid.Adj (p (qmaOddSplitIndex L e i)) (p (qmaOddSplitIndex L e (i+1))) := by
+  rcases qmaOddSplitIndex_step hL e hi with h | h
+  · have hn := qmaOddSplitIndex_bounds hL e (k := i+1) (Nat.succ_le_iff.mpr hi)
+    have hk : qmaOddSplitIndex L e i < L := by omega
+    simpa only [h] using hp (qmaOddSplitIndex L e i) hk
+  · have hb := qmaOddSplitIndex_bounds hL e (k := i) (Nat.le_of_lt hi)
+    have hk : qmaOddSplitIndex L e (i+1) < L := by omega
+    simpa only [h] using (hp (qmaOddSplitIndex L e (i+1)) hk).symm
+
+end ContinuumCoulomb
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOffsetProgram.lean

@@ -0,0 +1,47 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOffsetSample
+
+namespace OAI
+
+/-! Polynomial programs for the counterterm field coefficients and scalar offset. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumAxisSample
+open ExactQuantumFactoring.BitStackProgram
+
+noncomputable opaque shiftValueProgram (a : Fin 2) : Procedure ratCode ratCode (shiftValue a) := by
+  by_cases ha : a = 0
+  · exact (Procedure.constant ratCode ratCode 0).congrFun (by intro t; simp [shiftValue,ha])
+  · exact (Procedure.ratMul.comp ((Procedure.identity ratCode).pair
+      (Procedure.constant ratCode ratCode (1/2)))).congrFun (by
+        intro t
+        simp only [shiftValue,ha,ite_false,Function.comp_apply,id_eq]
+        ring)
+
+noncomputable opaque counterFieldAProgram (a b : Fin 2) (e : Fin 3) :
+    Procedure radialCode ratCode (fun x => fieldValue x.1 a (counterA x.1 a b x.2) e) :=
+  ((fieldValueProgram a e).comp (inputPrecisionProgram.pair (counterAProgram a b))).congrFun
+    (by intro x; rfl)
+
+noncomputable opaque counterFieldBProgram (a b : Fin 2) (e : Fin 3) :
+    Procedure radialCode ratCode (fun x => fieldValue x.1 b (counterB x.1 a b x.2) e) :=
+  ((fieldValueProgram b e).comp (inputPrecisionProgram.pair (counterBProgram a b))).congrFun
+    (by intro x; rfl)
+
+noncomputable opaque offsetProgram (a b : Fin 2) : Procedure radialCode ratCode
+    (fun x => offset x.1 a b x.2) := by
+  let left := (shiftValueProgram a).comp (counterAProgram a b)
+  let right := (shiftValueProgram b).comp (counterBProgram a b)
+  let first := Procedure.ratMul.comp ((factorProgram a b).pair (Procedure.constant radialCode ratCode (shift a true)))
+  let second := (shiftProgram b).comp inputCoefficientProgram
+  let product := Procedure.ratMul.comp (first.pair second)
+  exact (Procedure.ratSub.comp ((Procedure.ratAdd.comp (left.pair right)).pair product)).congrFun
+    (by intro x; rfl)
+
+noncomputable def offsetCertificate (a b : Fin 2) : Turing.TM2ComputableInPolyTime
+    radialCode ratCode (fun x => offset x.1 a b x.2) := (offsetProgram a b).toTM2
+
+end ContinuumCoulomb.QuantumAxisSample
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOffsetSample.lean

@@ -0,0 +1,104 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumCountertermProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumFieldSample
+
+namespace OAI
+
+/-! Error bounds for the sampled counterterm fields and their scalar shifts. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumAxisSample
+open ExactQuantumFactoring.BitStackProgram
+open scoped Classical
+
+theorem counterA_abs (k : ℕ) (a b : Fin 2) (t : ℚ) :
+    |(counterA k a b t:ℝ)| ≤ 400*|(t:ℝ)| := by
+  simp only [counterA,Rat.cast_mul,Rat.cast_abs,shift_cast,sign_cast,abs_mul,abs_abs,
+    abs_of_nonneg (value_bounds k b).1]
+  calc
+    _ ≤ (|(t:ℝ)| *1)*400 := mul_le_mul
+      (mul_le_mul_of_nonneg_left (value_bounds k b).2 (abs_nonneg _))
+      (qmaFourAxisShift_abs_bound b _) (abs_nonneg _) (by positivity)
+    _ = _ := by ring
+
+theorem counterB_abs (k : ℕ) (a b : Fin 2) (t : ℚ) :
+    |(counterB k a b t:ℝ)| ≤ 400*|(t:ℝ)| := by
+  simp only [counterB,Rat.cast_mul,Rat.cast_abs,shift_cast,polarity_cast,abs_mul,abs_abs,
+    abs_of_nonneg (value_bounds k a).1,qmaFourAxisSign_abs,mul_one]
+  calc
+    _ ≤ (|(t:ℝ)| *1)*400 := mul_le_mul
+      (mul_le_mul_of_nonneg_left (value_bounds k a).2 (abs_nonneg _))
+      (qmaFourAxisShift_abs_bound a true) (abs_nonneg _) (by positivity)
+    _ = _ := by ring
+
+theorem counterFieldA_error (k : ℕ) (a b : Fin 2) (t : ℚ) (e : Fin 3) :
+    |(fieldValue k a (counterA k a b t) e:ℝ)-qmaFieldEdgeWeight a (qmaFourCounterA a b (t:ℝ)) e| ≤
+      26000*|(t:ℝ)| *(2:ℝ)⁻¹^k := by
+  have hfield := fieldValue_error k a (counterA k a b t) e
+  have hcoef := counterA_abs k a b t
+  have hsample := counterA_error k a b t
+  have hweight := (fieldWeight_lipschitz a (counterA k a b t:ℝ) (qmaFourCounterA a b (t:ℝ)) e).trans hsample
+  apply ((abs_sub_le _ _ _).trans (add_le_add hfield hweight)).trans
+  have hm := mul_le_mul_of_nonneg_right hcoef (by positivity : 0 ≤ (2:ℝ)⁻¹^k)
+  nlinarith
+
+theorem counterFieldB_error (k : ℕ) (a b : Fin 2) (t : ℚ) (e : Fin 3) :
+    |(fieldValue k b (counterB k a b t) e:ℝ)-qmaFieldEdgeWeight b (qmaFourCounterB a b (t:ℝ)) e| ≤
+      26000*|(t:ℝ)| *(2:ℝ)⁻¹^k := by
+  have hfield := fieldValue_error k b (counterB k a b t) e
+  have hcoef := counterB_abs k a b t
+  have hsample := counterB_error k a b t
+  have hweight := (fieldWeight_lipschitz b (counterB k a b t:ℝ) (qmaFourCounterB a b (t:ℝ)) e).trans hsample
+  apply ((abs_sub_le _ _ _).trans (add_le_add hfield hweight)).trans
+  have hm := mul_le_mul_of_nonneg_right hcoef (by positivity : 0 ≤ (2:ℝ)⁻¹^k)
+  nlinarith
+
+def shiftValue (a : Fin 2) (t : ℚ) : ℚ := if a = 0 then 0 else t/2
+
+theorem shiftValue_error (a : Fin 2) (q : ℚ) (x : ℝ) :
+    |(shiftValue a q:ℝ)-qmaFourAxisFieldShift a x| ≤ |(q:ℝ)-x| := by
+  by_cases ha : a = 0
+  · simp [shiftValue,qmaFourAxisFieldShift,ha]
+  · simp only [shiftValue,qmaFourAxisFieldShift,ha,ite_false,Rat.cast_div,Rat.cast_ofNat]
+    rw [← sub_div,abs_div]
+    norm_num
+
+def offset (k : ℕ) (a b : Fin 2) (t : ℚ) : ℚ :=
+  shiftValue a (counterA k a b t)+shiftValue b (counterB k a b t)-
+    factor k a b t*shift a true*shift b (decide (t ≤ 0))
+
+theorem offset_error (k : ℕ) (a b : Fin 2) (t : ℚ) :
+    |(offset k a b t:ℝ)-qmaFourEnergyOffset a b (t:ℝ)| ≤
+      320800*|(t:ℝ)| *(2:ℝ)⁻¹^k := by
+  have ha := (shiftValue_error a (counterA k a b t) (qmaFourCounterA a b (t:ℝ))).trans
+    (counterA_error k a b t)
+  have hb := (shiftValue_error b (counterB k a b t) (qmaFourCounterB a b (t:ℝ))).trans
+    (counterB_error k a b t)
+  have hc : |((factor k a b t:ℝ)-qmaFourCouplingFactor a b (t:ℝ))*qmaFourAxisShift a true*
+      qmaFourAxisShift b (qmaFourCouplingSign (t:ℝ))| ≤ 320000*|(t:ℝ)| *(2:ℝ)⁻¹^k := by
+    rw [abs_mul,abs_mul]
+    calc
+      _ ≤ ((2*|(t:ℝ)| *(2:ℝ)⁻¹^k)*400)*400 := mul_le_mul
+        (mul_le_mul (factor_error k a b t) (qmaFourAxisShift_abs_bound a true)
+          (abs_nonneg _) (by positivity)) (qmaFourAxisShift_abs_bound b _)
+          (abs_nonneg _) (by positivity)
+      _ = _ := by ring
+  have he : (offset k a b t:ℝ)-qmaFourEnergyOffset a b (t:ℝ) =
+      ((shiftValue a (counterA k a b t):ℝ)-qmaFourAxisFieldShift a (qmaFourCounterA a b (t:ℝ)))+
+      ((shiftValue b (counterB k a b t):ℝ)-qmaFourAxisFieldShift b (qmaFourCounterB a b (t:ℝ)))-
+      ((factor k a b t:ℝ)-qmaFourCouplingFactor a b (t:ℝ))*qmaFourAxisShift a true*
+        qmaFourAxisShift b (qmaFourCouplingSign (t:ℝ)) := by
+    simp only [offset,qmaFourEnergyOffset,Rat.cast_sub,Rat.cast_add,Rat.cast_mul,shift_cast,sign_cast]
+    ring
+  rw [he]
+  apply (abs_sub _ _).trans
+  apply (add_le_add (abs_add_le _ _) le_rfl).trans
+  calc
+    _ ≤ (400*|(t:ℝ)| *(2:ℝ)⁻¹^k+400*|(t:ℝ)| *(2:ℝ)⁻¹^k)+320000*|(t:ℝ)| *(2:ℝ)⁻¹^k :=
+      add_le_add (add_le_add ha hb) hc
+    _ = _ := by ring
+
+end ContinuumCoulomb.QuantumAxisSample
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOperatorQuadratic.lean

@@ -0,0 +1,52 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRectangularOperator
+
+namespace OAI
+
+/-! Matrix quadratic forms agree with the real forms of their actual
+complex Euclidean operators, including rectangular compressions. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped InnerProductSpace
+variable {α β : Type*} [Fintype α] [Fintype β]
+
+theorem qmaMatrixOperator_real_adjoint (B : Matrix α β ℂ)
+    (p : EuclideanSpace ℂ β) (y : EuclideanSpace ℂ α) :
+    ⟪qmaMatrixOperator B p,y⟫_ℝ = ⟪p,qmaMatrixOperator B.conjTranspose y⟫_ℝ := by
+  rw [qmaEuclidean_real_inner,qmaEuclidean_real_inner]
+  have h := ContinuousLinearMap.adjoint_inner_right (qmaMatrixOperator B) p y
+  rw [← qmaMatrixOperator_star] at h
+  exact congrArg Complex.re h.symm
+
+theorem qmaQuadratic_operator (M : Matrix α α ℂ) (p : EuclideanSpace ℂ α) :
+    qmaQuadratic M (fun i => p i) = ⟪p,qmaMatrixOperator M p⟫_ℝ := by
+  rw [qmaEuclidean_real_inner]
+  simp only [qmaQuadratic,PiLp.inner_apply,RCLike.inner_apply',qmaMatrixOperator_apply,
+    Matrix.mulVec,dotProduct,Pi.star_apply,starRingEnd_apply]
+
+theorem qmaQuadratic_sandwich [DecidableEq α] [DecidableEq β] (B : Matrix α β ℂ) (M : Matrix α α ℂ)
+    (p : EuclideanSpace ℂ β) :
+    qmaQuadratic (B.conjTranspose*M*B) (fun i => p i) =
+      ⟪qmaMatrixOperator B p,qmaMatrixOperator M (qmaMatrixOperator B p)⟫_ℝ := by
+  rw [qmaQuadratic_operator,qmaMatrixOperator_mul,qmaMatrixOperator_mul]
+  simp only [ContinuousLinearMap.comp_apply]
+  exact (qmaMatrixOperator_real_adjoint B p _).symm
+
+theorem qmaQuadratic_sub (M N : Matrix α α ℂ) (p : α → ℂ) :
+    qmaQuadratic (M-N) p = qmaQuadratic M p-qmaQuadratic N p := by
+  have hn : qmaQuadratic (-N) p = -qmaQuadratic N p := by
+    have h := qmaQuadratic_smul N (-1) p
+    simpa using h
+  simp only [sub_eq_add_neg,qmaQuadratic_add,hn]
+
+theorem qmaQuadratic_real_smul (M : Matrix α α ℂ) (a : ℝ) (p : α → ℂ) :
+    qmaQuadratic (a • M) p = a*qmaQuadratic M p := by
+  have he : a • M = (a:ℂ) • M := rfl
+  rw [he,qmaQuadratic_smul]
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedCellProgram.lean

@@ -0,0 +1,61 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRoutingInputProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawFamilyProgram
+
+namespace OAI
+
+/-! Cell arrays follow the same term-major order as the literal local-word
+compiler. Each new mediator inherits its term's cell; each output word retains
+that cell as its anchor. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedCellProgram
+open ExactQuantumFactoring.BitStackProgram QuantumRouteCode
+
+abbrev State := List Pair × List Pair
+def stateCode : State → List Bool := prodCode (listCode pairCode) (listCode pairCode)
+
+def anchors (d : ℕ) (xs : List Pair) : List Pair :=
+  (xs.map (fun p => List.replicate d p)).flatten
+
+def value (d : ℕ) (x : State) : State := (x.1++x.2,anchors d x.2)
+
+noncomputable def repeatProgram (d : ℕ) :
+    Procedure pairCode (listCode pairCode) (fun p : Pair => List.replicate d p) :=
+  (QuantumRawExchange.fixedListProgram pairCode pairCode d (fun _ p => p)
+    (fun _ => Procedure.identity pairCode)).congrFun (by intro p; simp)
+
+noncomputable def anchorsProgram (d : ℕ) :
+    Procedure (listCode pairCode) (listCode pairCode) (anchors d) :=
+  (QuantumRawExchange.flattenProgram pairCode (0,0)).comp
+    (Procedure.listMap (0,0) [] (repeatProgram d))
+
+noncomputable def program (d : ℕ) : Procedure stateCode stateCode (value d) :=
+  (Procedure.listAppend pairCode (0,0)).pair
+    ((anchorsProgram d).comp (Procedure.second (listCode pairCode) (listCode pairCode)))
+
+theorem cells_length (d : ℕ) (x : State) : (value d x).1.length=x.1.length+x.2.length :=
+  List.length_append
+
+theorem anchors_length (d : ℕ) (xs : List Pair) : (anchors d xs).length=xs.length*d := by
+  induction xs with
+  | nil => simp [anchors]
+  | cons p xs ih =>
+    simp only [anchors,List.map_cons,List.flatten_cons,List.length_append,List.length_replicate] at *
+    rw [ih,List.length_cons]
+    simp only [Nat.add_mul,Nat.one_mul]
+    omega
+
+theorem cells_ofFn {n m : ℕ} (d : ℕ) (cell : Fin n → Pair) (anchor : Fin m → Pair) :
+    (value d (List.ofFn cell,List.ofFn anchor)).1=List.ofFn (Fin.append cell anchor) :=
+  (List.ofFn_fin_append cell anchor).symm
+
+theorem anchors_ofFn {m : ℕ} (d : ℕ) (anchor : Fin m → Pair) :
+    anchors d (List.ofFn anchor)=
+      (List.ofFn (fun i : Fin m => List.ofFn (fun _ : Fin d => anchor i))).flatten := by
+  simp only [anchors,List.map_ofFn,List.ofFn_const,Function.comp_def]
+
+end ContinuumCoulomb.QuantumOrderedCellProgram
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedCellTable.lean

@@ -0,0 +1,57 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedSpatialComplete
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedCellProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelOutput
+
+namespace OAI
+
+/-! The computed spatial arrays use exactly the same sum/product enumeration
+as the actual ordered Hamiltonian compiler. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedCellTable
+open QuantumOrderedCellProgram QuantumOrderedLabelTable QuantumOrderedSpatialComplete
+open ExactQuantumFactoring.BitStackProgram
+open QuantumRouteCode
+variable {ι κ : Type} {n m : ℕ}
+
+def table (q : Fin n ≃ ι) (e : Fin m ≃ κ) (cell : ι → Pair) (anchor : κ → Pair) : State :=
+  (List.ofFn (fun i => cell (q i)),List.ofFn (fun i => anchor (e i)))
+
+theorem value_table (d : ℕ) (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (cell : ι → Pair) (anchor : κ → Pair) :
+    value d (table q e cell anchor)=
+      table (nextQubit q e) (nextTerm e d) (extendCell cell anchor) (extendAnchor d anchor) := by
+  apply Prod.ext
+  · rw [show (value d (table q e cell anchor)).1=
+        List.ofFn (Fin.append (fun i => cell (q i)) (fun i => anchor (e i))) from cells_ofFn d _ _]
+    apply congrArg List.ofFn
+    funext i
+    obtain ⟨i,rfl⟩ := (finSumFinEquiv : Fin n ⊕ Fin m ≃ Fin (n+m)).surjective i
+    cases i <;> simp [nextQubit,extendCell,Fin.append]
+  · change anchors d (List.ofFn (fun i => anchor (e i)))=List.ofFn _
+    rw [anchors_ofFn]
+    rw [← product_table (fun p : Fin m × Fin d => anchor (e p.1))]
+    apply congrArg List.ofFn
+    funext i
+    rfl
+
+def complete (x : State) : State := value 4 (value 7 (value 4 (value 7 (value 4 (value 4 x)))))
+
+noncomputable def completeProgram : Procedure stateCode stateCode complete :=
+  (program 4).comp ((program 7).comp ((program 4).comp ((program 7).comp
+    ((program 4).comp (program 4)))))
+
+theorem complete_table (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (cell : ι → Pair) (anchor : κ → Pair) :
+    complete (table q e cell anchor)=
+      table (QuantumOrderedLabelTable.qubits6 q e) (QuantumOrderedLabelTable.terms6 e)
+        (cell6 cell anchor) (anchor6 anchor) := by
+  unfold complete
+  rw [value_table,value_table,value_table,value_table,value_table,value_table]
+  rfl
+
+end ContinuumCoulomb.QuantumOrderedCellTable
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedCoefficient.lean

@@ -0,0 +1,199 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumAlgebraicHistory
+
+namespace OAI
+
+/-! Exact rational-register tables for every actual ordered history term.
+Only the propagation core is multiplied, so its summation has at most
+32 states regardless of the number of spectator qubits. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumAlgebraicHistory
+open QuantumAlgebraicScalar QuantumFixedPauli Matrix
+open scoped BigOperators Classical
+
+def diagonal {α : Type} [DecidableEq α] (f : α → ℚ) : Matrix α α Scalar :=
+  fun s t => if s = t then rat (f s) else rat 0
+
+theorem denote_diagonal {α : Type} [DecidableEq α] (f : α → ℚ) :
+    denote (diagonal f) = Matrix.diagonal (fun s => (f s:ℂ)) := by
+  ext s t
+  by_cases h : s = t <;> simp [denote,QuantumAlgebraicHistory.diagonal,h]
+
+def distributed (c : QMACircuit) (τ : Fin (c.work+1) → Fin (c.gates.length+1)) :
+    QMACircuitTerm c → Matrix (QMACircuitQubit c → Fin 2) (QMACircuitQubit c → Fin 2) Scalar
+  | .inl i => diagonal (fun s =>
+      if s (Sum.inl i.castSucc) = 0 ∧ s (Sum.inl i.succ) = 1 then 1 else 0)
+  | .inr (.inl b) => if b = 0 then
+      diagonal (fun s => if s (Sum.inl 0) = 1 then 0 else 1) else
+      diagonal (fun s => if s (Sum.inl (Fin.last (c.gates.length+1))) = 0 then 0 else 1)
+  | .inr (.inr (.inl i)) => diagonal (fun s =>
+      if qmaClockAt c.gates.length (τ i) (s ∘ Sum.inl) ∧
+        qmaInputCheck c i (s ∘ Sum.inr) then 14 else 0)
+  | .inr (.inr (.inr (.inl _))) => diagonal (fun s =>
+      if s (Sum.inl (qmaOutputMarker c)) = 1 ∧ s (Sum.inr (Fin.last c.work)) ≠ 1 then 1 else 0)
+  | .inr (.inr (.inr (.inr t))) => fun s r =>
+      mul (rat ((14*(c.work+1)+8)*c.gates.length:ℚ))
+        (lift (qmaPropagationSites c t) (propagationCore c t) s r)
+
+theorem denote_distributed (c : QMACircuit)
+    (τ : Fin (c.work+1) → Fin (c.gates.length+1)) (a : QMACircuitTerm c) :
+    denote (distributed c τ a) = qmaDistributedTermMatrix c τ a := by
+  rcases a with i | (b | (i | (u | t)))
+  · ext s r
+    simp only [distributed,denote,QuantumAlgebraicHistory.diagonal,qmaDistributedTermMatrix,qmaClockFaultTerm,
+      qmaPairDiagonal,Matrix.diagonal_apply]
+    split_ifs <;> simp
+  · fin_cases b
+    · change denote (QuantumAlgebraicHistory.diagonal
+        (fun s : QMACircuitQubit c → Fin 2 => if s (Sum.inl 0) = 1 then 0 else 1)) =
+        qmaClockLeftTerm c
+      rw [denote_diagonal]
+      ext s r
+      simp only [qmaClockLeftTerm,qmaBitDiagonal,Matrix.diagonal_apply]
+      split_ifs <;> norm_num
+    · change denote (QuantumAlgebraicHistory.diagonal
+        (fun s : QMACircuitQubit c → Fin 2 =>
+          if s (Sum.inl (Fin.last (c.gates.length+1))) = 0 then 0 else 1)) =
+        qmaClockRightTerm c
+      rw [denote_diagonal]
+      ext s r
+      simp only [qmaClockRightTerm,qmaBitDiagonal,Matrix.diagonal_apply]
+      split_ifs <;> norm_num
+  · ext s r
+    simp only [distributed,denote,QuantumAlgebraicHistory.diagonal,qmaDistributedTermMatrix,
+      qmaDistributedInputTerm,Matrix.diagonal_apply]
+    split_ifs <;> simp
+  · cases u
+    ext s r
+    simp only [distributed,denote,QuantumAlgebraicHistory.diagonal,qmaDistributedTermMatrix,qmaOutputTerm,
+      qmaPairDiagonal,Matrix.diagonal_apply]
+    split_ifs <;> simp
+  · change (fun s r => value (mul _ (lift _ _ s r))) = _
+    simp only [value_mul,value_rat]
+    have hl := denote_lift (qmaPropagationSites c t) (propagationCore c t)
+    rw [denote_propagationCore] at hl
+    have hc := (qmaLocalPropagationGram_local c t).core_lift
+    rw [hc] at hl
+    ext s r
+    have he := congrFun (congrFun hl s) r
+    dsimp only [denote] at he
+    rw [he]
+    simp only [qmaDistributedTermMatrix,Matrix.smul_apply,smul_eq_mul]
+    push_cast
+    rfl
+
+def localY (n : ℕ) (i : Fin n) (s t : SourceSpinBasis n) : Scalar :=
+  finiteProduct (fun k => if k = i then QuantumFixedPauli.pauli 2 (s k) (t k) else identity (s k) (t k))
+
+theorem value_localY (n : ℕ) (i : Fin n) (s t : SourceSpinBasis n) :
+    value (localY n i s t) = sourceLocalPauli n i 1 s t := by
+  rw [localY,value_finiteProduct]
+  unfold sourceLocalPauli sourceTensor
+  apply Finset.prod_congr rfl
+  intro k _
+  by_cases h : k = i
+  · simp only [h,ite_true,value_pauli]
+    rfl
+  · simp only [h,ite_false,value_identity]
+
+def rebit {ι : Type} [Fintype ι] [DecidableEq ι] (n : ℕ) (i : Fin n)
+    (A : Matrix (ι → Fin 2) (ι → Fin 2) Scalar)
+    (s t : Fin n ⊕ ι → Fin 2) : Scalar :=
+  add (mul (identity (s ∘ Sum.inl) (t ∘ Sum.inl))
+      (realPart (A (s ∘ Sum.inr) (t ∘ Sum.inr))))
+    (mul (neg imaginary) (mul (localY n i (s ∘ Sum.inl) (t ∘ Sum.inl))
+      (imagPart (A (s ∘ Sum.inr) (t ∘ Sum.inr)))))
+
+theorem denote_rebit {ι : Type} [Fintype ι] [DecidableEq ι] (n : ℕ) (i : Fin n)
+    (A : Matrix (ι → Fin 2) (ι → Fin 2) Scalar) :
+    denote (rebit n i A) = qmaDistributedRebitOnQubits n i (denote A) := by
+  rw [qmaDistributedRebitOnQubits_eq]
+  ext s t
+  simp only [denote,rebit,value_add,value_mul,value_identity,value_realPart,value_imagPart,
+    value_neg,value_imaginary,value_localY,qmaJoinMatrix,Matrix.add_apply,
+    Matrix.smul_apply,smul_eq_mul,Matrix.submatrix_apply]
+  rfl
+
+def pairY (n : ℕ) (i j : Fin n) (s t : SourceSpinBasis n) : Scalar :=
+  mul (mul (QuantumFixedPauli.pauli 2 (s i) (t i)) (QuantumFixedPauli.pauli 2 (s j) (t j)))
+    (rat (if ∀ k, k ≠ i → k ≠ j → s k = t k then 1 else 0))
+
+theorem value_pairY (n : ℕ) (i j : Fin n) (hne : i ≠ j) (s t : SourceSpinBasis n) :
+    value (pairY n i j s t) = (sourceLocalPauli n i 1*sourceLocalPauli n j 1) s t := by
+  rw [sourceLocalPauli_product_entry n i j hne]
+  simp only [pairY,value_mul,value_pauli]
+  have he (a b : Fin 2) : qmaPauli 2 a b = ContinuumCoulomb.pauli 1 a b := rfl
+  rw [he,he]
+  by_cases h : ∀ k, k ≠ i → k ≠ j → s k = t k
+  · rw [ite_eq_left h,sourceSpectatorDelta_eq_one n i j s t h]
+    simp
+  · rw [ite_eq_right h,sourceSpectatorDelta_eq_zero n i j s t h]
+    simp
+
+def referenceEdge {ι : Type} [Fintype ι] [DecidableEq ι] (n : ℕ) (i : Fin n)
+    (s t : Fin (n+1) ⊕ ι → Fin 2) : Scalar :=
+  mul (mul (rat (1/2)) (sub (identity (s ∘ Sum.inl) (t ∘ Sum.inl))
+      (pairY (n+1) i.castSucc i.succ (s ∘ Sum.inl) (t ∘ Sum.inl))))
+    (identity (s ∘ Sum.inr) (t ∘ Sum.inr))
+
+theorem denote_referenceEdge {ι : Type} [Fintype ι] [DecidableEq ι] (n : ℕ) (i : Fin n) :
+    denote (referenceEdge (ι := ι) n i) = qmaReferenceEdgeOnQubits (ι := ι) n i := by
+  have hne : i.castSucc ≠ i.succ := by
+    intro h
+    have he := congrArg Fin.val h
+    simp at he
+  ext s t
+  simp only [denote,referenceEdge,value_mul,value_rat,value_sub,value_identity,
+    value_pairY _ _ _ hne,qmaReferenceEdgeOnQubits,qmaJoinMatrix,qmaReferenceYEdge,
+    Matrix.submatrix_apply,Matrix.kroneckerMap_apply,Matrix.smul_apply,smul_eq_mul,
+    Matrix.sub_apply]
+  norm_num
+  rfl
+
+def orderedTerm (c : QMACircuit) (hT : 0 < c.gates.length) :
+    QMAReferenceTerm (qmaHistoryReferenceWork c) →
+      Matrix (Fin (qmaHistoryReferenceWork c+1) ⊕ QMACircuitQubit c → Fin 2)
+        (Fin (qmaHistoryReferenceWork c+1) ⊕ QMACircuitQubit c → Fin 2) Scalar
+  | .inl i => rebit (qmaHistoryReferenceWork c+1) i
+      (distributed c (qmaFirstUseTime c) (qmaOrderedTermEquiv c hT (qmaFirstUseTime c) i))
+  | .inr i => referenceEdge (qmaHistoryReferenceWork c) i
+
+theorem denote_orderedTerm (c : QMACircuit) (hT : 0 < c.gates.length)
+    (a : QMAReferenceTerm (qmaHistoryReferenceWork c)) :
+    denote (orderedTerm c hT a) = (qmaOrderedHistoryModel c hT).matrix a := by
+  cases a with
+  | inl i =>
+    rw [orderedTerm,denote_rebit,denote_distributed]
+    rfl
+  | inr i =>
+    rw [orderedTerm,denote_referenceEdge]
+    rfl
+
+def orderedCore (c : QMACircuit) (hT : 0 < c.gates.length)
+    (a : QMAReferenceTerm (qmaHistoryReferenceWork c)) :
+    Matrix (QMASupportBasis ((qmaOrderedHistoryModel c hT).sites a))
+      (QMASupportBasis ((qmaOrderedHistoryModel c hT).sites a)) Scalar :=
+  fun s t => orderedTerm c hT a (qmaSupportExtend _ s) (qmaSupportExtend _ t)
+
+theorem denote_orderedCore (c : QMACircuit) (hT : 0 < c.gates.length)
+    (a : QMAReferenceTerm (qmaHistoryReferenceWork c)) :
+    denote (orderedCore c hT a) = qmaLocalCore ((qmaOrderedHistoryModel c hT).sites a)
+      ((qmaOrderedHistoryModel c hT).matrix a) := by
+  ext s t
+  exact congrFun (congrFun (denote_orderedTerm c hT a) _) _
+
+theorem orderedCoefficient_eq (c : QMACircuit) (hT : 0 < c.gates.length)
+    (a : QMAReferenceTerm (qmaHistoryReferenceWork c))
+    (w : {x // x ∈ (qmaOrderedHistoryModel c hT).sites a} → Fin 4) :
+    realValue (realCoefficient (orderedCore c hT a) w) =
+      (qmaPauliCoefficient (qmaLocalCore ((qmaOrderedHistoryModel c hT).sites a)
+        ((qmaOrderedHistoryModel c hT).matrix a)) w).re := by
+  rw [realCoefficient_eq]
+  change (qmaPauliCoefficient (denote (orderedCore c hT a)) w).re = _
+  rw [denote_orderedCore]
+
+end ContinuumCoulomb.QuantumAlgebraicHistory
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedDescriptorProgram.lean

@@ -0,0 +1,99 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedDescriptors
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumRawFamilyProgram
+
+namespace OAI
+
+/-! A literal polynomial program for the exact time-grouped descriptor list. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumHistoryDescriptors
+open ExactQuantumFactoring.BitStackProgram QuantumCircuitCode
+
+abbrev TimeInput := QMACircuit × Descriptor
+def timeCode : TimeInput → List Bool := prodCode circuitCode descriptorCode
+
+noncomputable opaque timeValueProgram : Procedure timeCode Nat.bits
+    (fun x => timeValue x.1 x.2) := by
+  let c := Procedure.first circuitCode descriptorCode
+  let d := Procedure.second circuitCode descriptorCode
+  let tag := (Procedure.first Nat.bits Nat.bits).comp d
+  let index := (Procedure.second Nat.bits Nat.bits).comp d
+  let time := Procedure.unaryToBits.comp (timeProgram.comp c)
+  let last := Procedure.binarySub.comp
+    (time.pair (Procedure.constant timeCode Nat.bits 1))
+  let test (n : ℕ) := Procedure.binaryEq.comp
+    (tag.pair (Procedure.constant timeCode Nat.bits n))
+  let minWithLast {f : TimeInput → ℕ} (p : Procedure timeCode Nat.bits f) :
+      Procedure timeCode Nat.bits (fun x => min (f x) (x.1.gates.length-1)) :=
+    (Procedure.conditional (Procedure.binaryLe.comp (p.pair last)) p last).congrFun
+      (by intro x; simp only [Function.comp_apply,id_eq,decide_eq_true_eq]; split_ifs <;> omega)
+  let firstUse := Procedure.unaryToBits.comp
+    (QuantumFirstUseProgram.program.comp (c.pair index))
+  let boundary := Procedure.conditional
+    (Procedure.binaryEq.comp (index.pair (Procedure.constant timeCode Nat.bits 0)))
+    (Procedure.constant timeCode Nat.bits 0) last
+  exact (Procedure.conditional (test 0) (minWithLast index)
+    (Procedure.conditional (test 1) boundary
+    (Procedure.conditional (test 2) (minWithLast firstUse)
+    (Procedure.conditional (test 3) last index)))).congrFun (by
+      intro x
+      simp only [timeValue,Function.comp_apply,id_eq,decide_eq_true_eq])
+
+abbrev BucketInput := QMACircuit × ℕ
+def bucketCode : BucketInput → List Bool := prodCode circuitCode Nat.bits
+abbrev ChunkInput := BucketInput × Descriptor
+def chunkCode : ChunkInput → List Bool := prodCode bucketCode descriptorCode
+
+def chunk (x : ChunkInput) : List Descriptor :=
+  if timeValue x.1.1 x.2=x.1.2 then [x.2] else []
+
+noncomputable opaque chunkProgram : Procedure chunkCode (listCode descriptorCode) chunk := by
+  let env := Procedure.first bucketCode descriptorCode
+  let c := (Procedure.first circuitCode Nat.bits).comp env
+  let t := (Procedure.second circuitCode Nat.bits).comp env
+  let d := Procedure.second bucketCode descriptorCode
+  let hit := Procedure.binaryEq.comp ((timeValueProgram.comp (c.pair d)).pair t)
+  let nil := Procedure.constant chunkCode (listCode descriptorCode) []
+  exact (Procedure.conditional hit ((Procedure.listCons descriptorCode).comp (d.pair nil))
+    nil).congrFun (by intro x; simp only [chunk,Function.comp_apply,decide_eq_true_eq])
+
+private theorem chunks_eq (c : QMACircuit) (t : ℕ) (xs : List Descriptor) :
+    (xs.map (fun d => chunk ((c,t),d))).flatten =
+      xs.filter (fun d => decide (timeValue c d=t)) := by
+  induction xs with
+  | nil => rfl
+  | cons d xs ih =>
+    simp only [List.map_cons,List.flatten_cons,ih,List.filter_cons]
+    by_cases h : timeValue c d=t
+    · simp [chunk,h]
+    · simp [chunk,h]
+
+noncomputable opaque bucketProgram : Procedure bucketCode (listCode descriptorCode)
+    (fun x => bucket x.1 x.2) := by
+  let chunks := (Procedure.listMapWith (f := fun e d => chunk (e,d)) (0,0) []
+    chunkProgram).comp ((Procedure.identity bucketCode).pair
+      (sourceProgram.comp (Procedure.first circuitCode Nat.bits)))
+  exact ((QuantumRawExchange.flattenProgram descriptorCode (0,0)).comp chunks).congrFun
+    (by intro x; exact chunks_eq x.1 x.2 (source x.1))
+
+noncomputable opaque orderedEntryProgram :
+    Procedure (prodCode unaryCode circuitCode) (listCode descriptorCode)
+      (fun x => bucket x.2 x.1) :=
+  bucketProgram.comp ((Procedure.second unaryCode circuitCode).pair
+    (Procedure.unaryToBits.comp (Procedure.first unaryCode circuitCode)))
+
+noncomputable opaque orderedProgram : Procedure circuitCode (listCode descriptorCode) ordered :=
+  ((QuantumRawExchange.flattenProgram descriptorCode (0,0)).comp
+    ((Procedure.tabulate (f := fun c i => bucket c i) [] orderedEntryProgram).comp
+      (timeProgram.pair (Procedure.identity circuitCode)))).congrFun (by
+        intro c
+        simp only [ordered,List.flatMap_def,Function.comp_apply,id_eq])
+
+noncomputable def orderedCertificate : Turing.TM2ComputableInPolyTime circuitCode
+    (listCode descriptorCode) ordered := orderedProgram.toTM2
+
+end ContinuumCoulomb.QuantumHistoryDescriptors
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedDescriptors.lean

@@ -0,0 +1,91 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumHistoryDescriptorProgram
+
+namespace OAI
+
+/-! Numeric time grouping agrees with the exact ordered reference family.
+The first-use time is computed from the actual gate list. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumHistoryDescriptors
+open ExactQuantumFactoring.BitStackProgram QuantumCircuitCode
+
+def timeValue (c : QMACircuit) (a : Descriptor) : ℕ :=
+  if a.1=0 then min a.2 (c.gates.length-1) else
+  if a.1=1 then (if a.2=0 then 0 else c.gates.length-1) else
+  if a.1=2 then min (QuantumFirstUseProgram.value (c,a.2)) (c.gates.length-1) else
+  if a.1=3 then c.gates.length-1 else a.2
+
+theorem time_encode (c : QMACircuit) (hT : 0<c.gates.length) (a : QMACircuitTerm c) :
+    timeValue c (encode c a) =
+      (qmaHistoryTermTime c hT (qmaFirstUseTime c) a).val := by
+  rcases a with i | (b | (i | (u | t)))
+  · rfl
+  · fin_cases b
+    · simp only [timeValue,encode,qmaHistoryTermTime]
+      norm_num
+    · simp only [timeValue,encode,qmaHistoryTermTime,qmaBoundedClockTime]
+      have he : min c.gates.length (c.gates.length-1)=c.gates.length-1 :=
+        min_eq_right (Nat.sub_le _ _)
+      norm_num [he]
+  · simp only [timeValue,encode,qmaHistoryTermTime,qmaBoundedClockTime]
+    norm_num only
+    rw [QuantumFirstUseProgram.value_eq]
+    rfl
+  · cases u
+    simp only [timeValue,encode,qmaHistoryTermTime,qmaBoundedClockTime]
+    have he : min c.gates.length (c.gates.length-1)=c.gates.length-1 :=
+      min_eq_right (Nat.sub_le _ _)
+    norm_num [he]
+  · simp only [timeValue,encode,qmaHistoryTermTime]
+    norm_num
+
+def bucket (c : QMACircuit) (t : ℕ) : List Descriptor :=
+  (source c).filter (fun a => decide (timeValue c a=t))
+
+def ordered (c : QMACircuit) : List Descriptor :=
+  (List.range c.gates.length).flatMap (bucket c)
+
+theorem bucket_actual (c : QMACircuit) (hT : 0<c.gates.length)
+    (t : Fin c.gates.length) :
+    bucket c t.val =
+      ((qmaHistoryTermList c).filter
+        (fun a => decide (qmaHistoryTermTime c hT (qmaFirstUseTime c) a=t))).map
+        (encode c) := by
+  rw [bucket,source_actual,List.filter_map]
+  congr 1
+  apply List.filter_congr
+  intro a _
+  change decide (timeValue c (encode c a)=t.val) = _
+  rw [time_encode c hT]
+  simp only [Fin.ext_iff]
+
+theorem ordered_actual (c : QMACircuit) (hT : 0<c.gates.length) :
+    ordered c=(qmaOrderedHistoryTerms c hT (qmaFirstUseTime c)).map (encode c) := by
+  unfold ordered qmaOrderedHistoryTerms qmaGroupByTime
+  rw [List.map_flatMap]
+  have hr : List.range c.gates.length =
+      (List.ofFn (fun t : Fin c.gates.length => t)).map Fin.val := by
+    apply List.ext_getElem
+    · simp
+    · intro i hi hj
+      simp only [List.getElem_range,List.getElem_map,List.getElem_ofFn]
+  rw [hr,List.flatMap_map]
+  apply List.flatMap_congr
+  intro t _
+  exact bucket_actual c hT t
+
+theorem ordered_length (c : QMACircuit) (hT : 0<c.gates.length) :
+    (ordered c).length=qmaHistoryReferenceWork c+1 := by
+  rw [ordered_actual c hT,List.length_map,qmaOrderedHistoryTerms_length]
+
+theorem ordered_get (c : QMACircuit) (hT : 0<c.gates.length)
+    (i : Fin (qmaHistoryReferenceWork c+1)) :
+    (ordered c)[i.val]'(by rw [ordered_length c hT]; exact i.isLt) =
+      encode c (qmaOrderedTermEquiv c hT (qmaFirstUseTime c) i) := by
+  simp only [ordered_actual c hT,List.getElem_map,qmaOrderedTermEquiv_get]
+
+end ContinuumCoulomb.QuantumHistoryDescriptors
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedFinalBounds.lean

@@ -0,0 +1,62 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedWeightBounds
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelCompile
+
+namespace OAI
+
+/-! An integer polynomial bound for the complete six-stage ordered compiler,
+including the private-pair subdivision before the physical four-spin step. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedXZ
+open scoped Classical
+
+def weightNat (R B : ℕ) : ℕ := R^3+R^2*B+R^2+R*(1+B^2)+1+B^2
+def scaleNat (m B N : ℕ) : ℕ := 8*(4*(1+m*(1+B)^2))^4*N
+def stepNat (m B N : ℕ) : ℕ := weightNat (scaleNat m B N) B
+def pipelineNat (m B N : ℕ) : ℕ → ℕ
+  | 0 => B
+  | k+1 => stepNat (3136*m) (pipelineNat m B N k) N
+
+theorem weightNat_cast (R B : ℕ) : (weightNat R B:ℚ)=weightEnvelope R B := by
+  simp only [weightNat,weightEnvelope,Nat.cast_add,Nat.cast_mul,Nat.cast_pow,
+    Nat.cast_one]
+
+theorem scaleNat_cast (m B N : ℕ) : (scaleNat m B N:ℚ)=scaleEnvelope m B N := by
+  simp only [scaleNat,scaleEnvelope,Nat.cast_add,Nat.cast_mul,Nat.cast_pow,
+    Nat.cast_one,Nat.cast_ofNat]
+
+theorem stepNat_cast (m B N : ℕ) : (stepNat m B N:ℚ)=stepEnvelope m B N := by
+  simp only [stepNat,stepEnvelope,weightNat_cast,scaleNat_cast]
+
+theorem pipelineNat_cast (m B N k : ℕ) : (pipelineNat m B N k:ℚ)=pipelineBound m B N k := by
+  induction k with
+  | zero => rfl
+  | succ k ih => simp only [pipelineNat,stepNat_cast,ih,pipelineBound]
+
+theorem outputTerm_card {κ : Type} [Fintype κ] :
+    Fintype.card (OutputTerm κ)=3136*Fintype.card κ := by
+  simp only [OutputTerm,XZThreeTerm,TwoTerm,ThreeTerm,Fintype.card_prod,Fintype.card_fin]
+  ring
+
+theorem private_coefficient_bound {κ : Type} [Fintype κ] (J : κ → ℚ)
+    {m B : ℕ} (hm : Fintype.card κ ≤ m) (hJ : ∀ e, |J e| ≤ (B:ℚ))
+    (N : ℕ) (p : OutputTerm κ × Fin 4) :
+    |QuantumOrderedPrivate.outputCoefficient (coefficient J N) N p| ≤
+      (pipelineNat m B N 6:ℚ) := by
+  have hB : (0:ℚ) ≤ B := Nat.cast_nonneg B
+  have hc := pipeline_coefficient_bound J hB hm hJ N
+  have hcount : Fintype.card (OutputTerm κ) ≤ 3136*m := by
+    rw [outputTerm_card]
+    exact Nat.mul_le_mul_left 3136 hm
+  have h := subdivision_coefficient_bound (coefficient J N)
+    (pipelineBound_nonneg m hB N 5) hcount hc N p
+  change |QuantumOrderedSubdivision.outputCoefficient (coefficient J N) N p| ≤
+    (stepNat (3136*m) (pipelineNat m B N 5) N:ℚ)
+  rw [stepNat_cast,pipelineNat_cast]
+  exact h
+
+end ContinuumCoulomb.QuantumOrderedXZ
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedHistory.lean

@@ -0,0 +1,67 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedReference
+
+namespace OAI
+
+/-! Reordering actual history terms preserves the full-space reference gap. -/
+
+noncomputable section
+namespace ContinuumCoulomb
+open Matrix
+open scoped BigOperators Classical
+
+def qmaOrderedReferenceTerms (c : QMACircuit) (hT : 0 < c.gates.length)
+    (τ : Fin (c.work+1) → Fin (c.gates.length+1))
+    (i : Fin (qmaHistoryReferenceWork c+1)) :=
+  qmaDistributedTermMatrix c τ (qmaOrderedTermEquiv c hT τ i)
+
+theorem qmaOrderedReferenceTerms_sum (c : QMACircuit) (hT : 0 < c.gates.length)
+    (τ : Fin (c.work+1) → Fin (c.gates.length+1)) :
+    (∑ i, qmaOrderedReferenceTerms c hT τ i) = qmaDistributedQubitHamiltonian c τ := by
+  unfold qmaOrderedReferenceTerms
+  rw [(qmaOrderedTermEquiv c hT τ).sum_comp,qmaDistributedTerm_sum]
+
+def qmaOrderedReferenceHistory (c : QMACircuit) (hT : 0 < c.gates.length)
+    (τ : Fin (c.work+1) → Fin (c.gates.length+1)) :
+    Matrix (QMAHistoryReferenceBasis c) (QMAHistoryReferenceBasis c) ℂ :=
+  qmaReferenceFamily (qmaHistoryReferenceWork c) (qmaOrderedReferenceTerms c hT τ) 1
+
+theorem qmaOrderedReferenceHistory_lower (c : QMACircuit) (hc : c.WellFormed)
+    (hT : 0 < c.gates.length) (τ : Fin (c.work+1) → Fin (c.gates.length+1))
+    (hi : ∀ i, ∀ g ∈ c.gates.take (τ i).val, i ∉ qmaGateSites c.work g)
+    (hsound : ∀ psi : EuclideanSpace ℂ (SourceSpinBasis c.witness),
+      ‖psi‖ = 1 → qmaAcceptance c hc psi ≤ 1/3)
+    (u : QMAHistoryReferenceBasis c → ℂ) :
+    (2/(5*(c.gates.length+1:ℝ)))*(∑ p, Complex.normSq (u p)) ≤
+      qmaQuadratic (qmaOrderedReferenceHistory c hT τ) u := by
+  have hd : 0 < 5*(c.gates.length+1:ℝ) := by positivity
+  have ha : (2:ℝ)/(5*(c.gates.length+1:ℝ)) ≤ 1 := by
+    apply (div_le_one hd).mpr
+    have : (0:ℝ) ≤ c.gates.length := Nat.cast_nonneg _
+    linarith
+  apply qmaReferenceFamily_lower _ _ (fun i => qmaDistributedTerm_nonnegative c τ _) _ _
+    (by positivity) ha
+  intro v
+  change _ ≤ qmaQuadratic (∑ i, qmaOrderedReferenceTerms c hT τ i) v
+  rw [qmaOrderedReferenceTerms_sum]
+  exact qmaDistributedQubit_lower c hc τ hi hsound v
+
+theorem qmaOrderedReferenceHistory_accepting (c : QMACircuit) (hc : c.WellFormed)
+    (hT : 0 < c.gates.length) (τ : Fin (c.work+1) → Fin (c.gates.length+1))
+    (hi : ∀ i, ∀ g ∈ c.gates.take (τ i).val, i ∉ qmaGateSites c.work g)
+    (psi : EuclideanSpace ℂ (SourceSpinBasis c.witness)) (hpsi : ‖psi‖ = 1)
+    (hacc : 2/3 ≤ qmaAcceptance c hc psi) :
+    ∃ u : QMAHistoryReferenceBasis c → ℂ, (∑ p, Complex.normSq (u p)) = 1 ∧
+      3*(c.gates.length+1:ℝ)*qmaQuadratic (qmaOrderedReferenceHistory c hT τ) u ≤ 1 := by
+  obtain ⟨v,hv,he⟩ := qmaDistributedQubit_accepting c hc τ hi psi hpsi hacc
+  refine ⟨qmaReferenceTrial (qmaHistoryReferenceWork c) v,?_,?_⟩
+  · rw [qmaReferenceTrial_mass]
+    exact hv
+  · unfold qmaOrderedReferenceHistory
+    rw [qmaReferenceTrial_energy,qmaOrderedReferenceTerms_sum]
+    exact he
+
+end ContinuumCoulomb
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedIncidence.lean

@@ -0,0 +1,180 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedXZPipeline
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedPrivate
+
+namespace OAI
+
+/-! Uniform incidence bounds for the actual ordered local reductions.  Every
+new site belongs to one input term, while old sites remain in that term's
+stored support.  The bound counts zero-coefficient terms as well. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedIncidence
+open scoped BigOperators Classical
+
+variable {ι κ : Type} [Fintype κ]
+
+def count (xs : κ → List ι) (q : ι) : ℕ :=
+  ∑ e, if q ∈ xs e then 1 else 0
+
+def Bounded (xs : κ → List ι) (D : ℕ) : Prop := ∀ q, count xs q ≤ D
+
+def Origin (xs : κ → List ι) (e : κ) : ι ⊕ κ → Prop :=
+  Sum.elim (fun q => q ∈ xs e) (fun f => f = e)
+
+theorem extension_bound {d D : ℕ} (xs : κ → List ι)
+    (ys : κ × Fin d → List (ι ⊕ κ)) (hD : 1 ≤ D) (hx : Bounded xs D)
+    (hy : ∀ p q, q ∈ ys p → Origin xs p.1 q) : Bounded ys (d*D) := by
+  intro q
+  cases q with
+  | inl q =>
+    calc
+      count ys (Sum.inl q) ≤ ∑ p : κ × Fin d, if q ∈ xs p.1 then 1 else 0 := by
+        apply Finset.sum_le_sum
+        intro p _
+        by_cases h : Sum.inl q ∈ ys p
+        · have ho : q ∈ xs p.1 := hy p _ h
+          simp only [h,ho,ite_true,le_refl]
+        · simp only [h,ite_false,Nat.zero_le]
+      _ = d*count xs q := by
+        rw [Fintype.sum_prod_type]
+        have hi (e : κ) : (∑ _k : Fin d, if q ∈ xs e then 1 else 0) =
+            d*(if q ∈ xs e then 1 else 0) := by
+          by_cases h : q ∈ xs e <;> simp [h]
+        simp_rw [hi]
+        exact (Finset.mul_sum _ _ _).symm
+      _ ≤ d*D := Nat.mul_le_mul_left d (hx q)
+  | inr q =>
+    calc
+      count ys (Sum.inr q) ≤ ∑ p : κ × Fin d, if q=p.1 then 1 else 0 := by
+        apply Finset.sum_le_sum
+        intro p _
+        by_cases h : Sum.inr q ∈ ys p
+        · have ho : q=p.1 := hy p _ h
+          rw [ite_eq_left h,ite_eq_left ho]
+        · simp only [h,ite_false,Nat.zero_le]
+      _ = d := by
+        rw [Fintype.sum_prod_type]
+        have hi (e : κ) : (∑ _k : Fin d, if q=e then 1 else 0) =
+            if q=e then d else 0 := by
+          by_cases h : q=e <;> simp [h]
+        simp_rw [hi]
+        simp
+      _ ≤ d*D := by simpa only [Nat.mul_one] using Nat.mul_le_mul_left d hD
+
+omit [Fintype κ] in
+theorem append_origin (xs : κ → List ι) (e : κ) (zs : List ι)
+    (hz : ∀ q ∈ zs, q ∈ xs e) (q : ι ⊕ κ)
+    (hq : q ∈ QuantumOrderedSubdivision.appendMediator zs e) : Origin xs e q := by
+  cases q with
+  | inl q =>
+    exact hz q (by simpa only [QuantumOrderedSubdivision.appendMediator,
+      List.mem_append,List.mem_map,Sum.inl.injEq,exists_eq_right,List.mem_singleton,
+      Sum.inl_ne_inr,or_false] using hq)
+  | inr q =>
+    simpa only [Origin,Sum.elim_inr,QuantumOrderedSubdivision.appendMediator,
+      List.mem_append,List.mem_map,Sum.inl_ne_inr,and_false,exists_false,List.mem_singleton,
+      Sum.inr.injEq,false_or] using hq
+
+omit [Fintype κ] in
+theorem subdivision_origin (xs : κ → List ι) (d : ℕ)
+    (p : κ × Fin 4) (q : ι ⊕ κ)
+    (hq : q ∈ QuantumOrderedSubdivision.outputSites xs d p) : Origin xs p.1 q := by
+  rcases p with ⟨e,k⟩
+  fin_cases k
+  · simp [QuantumOrderedSubdivision.outputSites] at hq
+  · have he : q=Sum.inr e := by simpa [QuantumOrderedSubdivision.outputSites] using hq
+    subst q
+    rfl
+  · exact append_origin xs e _ (fun _ h => List.mem_of_mem_take h) q hq
+  · exact append_origin xs e _ (fun _ h => List.mem_of_mem_drop h) q hq
+
+theorem subdivision_bound {D : ℕ} (xs : κ → List ι) (d : ℕ)
+    (hD : 1 ≤ D) (hx : Bounded xs D) :
+    Bounded (QuantumOrderedSubdivision.outputSites xs d) (4*D) :=
+  extension_bound xs _ hD hx (subdivision_origin xs d)
+
+omit [Fintype κ] in
+theorem yy_origin (xs : κ → List ι) (p : κ × Fin 4) (q : ι ⊕ κ)
+    (hq : q ∈ QuantumOrderedYY.outputSites xs p) : Origin xs p.1 q := by
+  rcases p with ⟨e,k⟩
+  fin_cases k
+  · simp [QuantumOrderedYY.outputSites] at hq
+  · have he : q=Sum.inr e := by simpa [QuantumOrderedYY.outputSites] using hq
+    subst q
+    rfl
+  · exact append_origin xs e _ (fun _ h => h) q hq
+  · exact append_origin xs e _ (fun _ h => h) q hq
+
+theorem yy_bound [Fintype ι] [DecidableEq ι] [DecidableEq κ]
+    {D : ℕ} (xs : κ → List ι) (hD : 1 ≤ D) (hx : Bounded xs D) :
+    Bounded (QuantumOrderedYY.outputSites xs) (4*D) :=
+  extension_bound xs _ hD hx (yy_origin xs)
+
+omit [Fintype κ] in
+theorem third_origin (xs : κ → List ι) (w : κ → ι → Fin 4)
+    (hlen : ∀ e, (xs e).length ≤ 3) (p : κ × Fin 7) (q : ι ⊕ κ)
+    (hq : q ∈ QuantumOrderedThird.outputSites xs w p) : Origin xs p.1 q := by
+  rcases p with ⟨e,k⟩
+  have hp : ∀ i ∈ (QuantumOrderedTriple.partition (xs e) (w e)).1, i ∈ xs e := by
+    intro i hi
+    exact (QuantumOrderedTriple.partition_spec (xs e) (w e) (hlen e)).1.mem_iff.mp
+      (List.mem_append_left _ hi)
+  have hr : ∀ i ∈ (QuantumOrderedTriple.partition (xs e) (w e)).2, i ∈ xs e := by
+    intro i hi
+    exact (QuantumOrderedTriple.partition_spec (xs e) (w e) (hlen e)).1.mem_iff.mp
+      (List.mem_append_right _ hi)
+  fin_cases k
+  · simp [QuantumOrderedThird.outputSites] at hq
+  · have he : q=Sum.inr e := by simpa [QuantumOrderedThird.outputSites] using hq
+    subst q
+    rfl
+  · obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hq
+    exact hp i hi
+  · obtain ⟨i,hi,rfl⟩ := List.mem_map.mp hq
+    exact hr i hi
+  · exact append_origin xs e _ hr q hq
+  · exact append_origin xs e _ (fun i h => hp i (List.mem_of_mem_take h)) q hq
+  · exact append_origin xs e _ (fun i h => hp i (List.mem_of_mem_drop h)) q hq
+
+theorem third_bound [Fintype ι] [DecidableEq ι] [DecidableEq κ]
+    {D : ℕ} (xs : κ → List ι) (w : κ → ι → Fin 4)
+    (hlen : ∀ e, (xs e).length ≤ 3) (hD : 1 ≤ D) (hx : Bounded xs D) :
+    Bounded (QuantumOrderedThird.outputSites xs w) (7*D) :=
+  extension_bound xs _ hD hx (third_origin xs w hlen)
+
+theorem xz_bound [Fintype ι] [DecidableEq ι] [DecidableEq κ]
+    {D : ℕ} (xs : κ → List ι) (w : κ → ι → Fin 4)
+    (hlen : ∀ e, (xs e).length ≤ 6) (hD : 1 ≤ D) (hx : Bounded xs D) :
+    Bounded (QuantumOrderedXZ.sites xs w) (3136*D) := by
+  have h1 := subdivision_bound xs 3 hD hx
+  have h2 := subdivision_bound (QuantumOrderedSubdivision.outputSites xs 3) 2
+    (by omega : 1 ≤ 4*D) h1
+  have h3 := third_bound (QuantumOrderedXZ.threeSites xs) (QuantumOrderedXZ.threeWord xs w)
+    (QuantumOrderedXZ.threeSites_length xs hlen) (by omega : 1 ≤ 4*(4*D)) h2
+  have h4 := yy_bound (QuantumOrderedXZ.twoSites xs w) (by omega : 1 ≤ 7*(4*(4*D))) h3
+  have h5 := third_bound (QuantumOrderedXZ.xzThreeSites xs w)
+    (QuantumOrderedXZ.xzThreeWord xs w) (QuantumOrderedXZ.xzThreeSites_length xs w hlen)
+    (by omega : 1 ≤ 4*(7*(4*(4*D)))) h4
+  change Bounded (QuantumOrderedXZ.sites xs w) (7*(4*(7*(4*(4*D))))) at h5
+  convert h5 using 1
+  omega
+
+theorem private_bound [Fintype ι] [DecidableEq ι] [DecidableEq κ]
+    {D : ℕ} (xs : κ → List ι) (hD : 1 ≤ D) (hx : Bounded xs D) :
+    Bounded (QuantumOrderedPrivate.outputSites xs) (4*D) :=
+  subdivision_bound xs 1 hD hx
+
+theorem complete_bound [Fintype ι] [DecidableEq ι] [DecidableEq κ]
+    {D : ℕ} (xs : κ → List ι) (w : κ → ι → Fin 4)
+    (hlen : ∀ e, (xs e).length ≤ 6) (hD : 1 ≤ D) (hx : Bounded xs D) :
+    Bounded (QuantumOrderedPrivate.outputSites (QuantumOrderedXZ.sites xs w)) (12544*D) := by
+  have h := private_bound (QuantumOrderedXZ.sites xs w)
+    (by omega : 1 ≤ 3136*D) (xz_bound xs w hlen hD hx)
+  convert h using 1
+  omega
+
+end ContinuumCoulomb.QuantumOrderedIncidence
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedLabelBlocks.lean

@@ -0,0 +1,176 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelYY
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelProgram
+
+namespace OAI
+
+/-! Literal fixed-size programs for the triple partition and YY/private
+blocks. The branch tests inspect only the stored support labels. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedLabelData
+open ExactQuantumFactoring.BitStackProgram
+
+noncomputable opaque entryProgram (k : ℕ) : Procedure labelsCode labelCode
+    (fun xs => (xs.drop k).headD (0,0)) :=
+  (Procedure.listGet labelCode (0,0)).comp
+    ((Procedure.constant labelsCode Nat.bits k).pair (Procedure.identity labelsCode))
+noncomputable opaque labelTest (k a : ℕ) : Procedure labelsCode Procedure.boolCode
+    (fun xs => decide (((xs.drop k).headD (0,0)).2=a)) :=
+  Procedure.binaryEq.comp (((Procedure.second Nat.bits Nat.bits).comp (entryProgram k)).pair
+    (Procedure.constant labelsCode Nat.bits a))
+noncomputable opaque lengthTest (n : ℕ) : Procedure labelsCode Procedure.boolCode
+    (fun xs => decide (xs.length=n)) :=
+  Procedure.binaryEq.comp ((Procedure.unaryToBits.comp
+    (ExactQuantumFactoring.NativeAIG.Emission.listUnaryLength labelCode (0,0))).pair
+    (Procedure.constant labelsCode Nat.bits n))
+
+private def selected (a b : ℕ) (xs : List Letter) : List Letter :=
+  [(xs.drop a).headD (0,0),(xs.drop b).headD (0,0)]
+private noncomputable def selectedProgram (a b : ℕ) : Procedure labelsCode labelsCode
+    (selected a b) :=
+  (Procedure.listCons labelCode).comp ((entryProgram a).pair
+    (singletonProgram _ (entryProgram b)))
+
+private def partitionLookup (xs : List Letter) : List Letter × List Letter :=
+  if xs.length=3 then
+    if ((xs.drop 0).headD (0,0)).2=2 then
+      if ((xs.drop 1).headD (0,0)).2=2 then
+        (selected 0 1 xs,[(xs.drop 2).headD (0,0)])
+      else (selected 0 2 xs,[(xs.drop 1).headD (0,0)])
+    else (selected 1 2 xs,[(xs.drop 0).headD (0,0)])
+  else (xs,[])
+
+private theorem partitionLookup_eq (xs : List Letter) : partitionLookup xs=partition xs := by
+  cases xs with
+  | nil => rfl
+  | cons a xs =>
+    cases xs with
+    | nil => rfl
+    | cons b xs =>
+      cases xs with
+      | nil => rfl
+      | cons c xs =>
+        cases xs with
+        | nil => simp [partitionLookup,partition,selected]
+        | cons d xs => simp [partitionLookup,partition,List.length_cons]
+
+noncomputable opaque partitionProgram :
+    Procedure labelsCode (prodCode labelsCode labelsCode) partition := by
+  let p01 := (selectedProgram 0 1).pair (singletonProgram _ (entryProgram 2))
+  let p02 := (selectedProgram 0 2).pair (singletonProgram _ (entryProgram 1))
+  let p12 := (selectedProgram 1 2).pair (singletonProgram _ (entryProgram 0))
+  let p := Procedure.conditional (lengthTest 3)
+    (Procedure.conditional (labelTest 0 2) (Procedure.conditional (labelTest 1 2) p01 p02) p12)
+    ((Procedure.identity labelsCode).pair (Procedure.constant labelsCode labelsCode []))
+  exact p.congrFun (by
+    intro xs
+    simpa only [partitionLookup,decide_eq_true_eq,id_eq] using partitionLookup_eq xs)
+
+noncomputable opaque pairLabelsProgram : Procedure blockCode labelsCode
+    (fun x => (partition x.2).1) :=
+  ((Procedure.first labelsCode labelsCode).comp partitionProgram).comp labelsProgram
+noncomputable opaque realLabelsProgram : Procedure blockCode labelsCode
+    (fun x => (partition x.2).2) :=
+  ((Procedure.second labelsCode labelsCode).comp partitionProgram).comp labelsProgram
+noncomputable opaque thirdMediatorProgram : Procedure blockCode labelCode
+    (fun x => (x.1,axis ((partition x.2).1.take 1))) :=
+  mediatorProgram.pair (axisProgram.comp ((takeProgram 1).comp pairLabelsProgram))
+
+noncomputable opaque thirdBlockProgram (k : Fin 7) :
+    Procedure blockCode labelsCode (fun x => thirdBlock x.1 x.2 k) := by
+  refine Fin.cases ?_ (fun k => ?_) k
+  · exact Procedure.constant blockCode labelsCode []
+  · refine Fin.cases ?_ (fun k => ?_) k
+    · exact singletonProgram (fun x : BlockInput => (x.1,3))
+        (mediatorProgram.pair (Procedure.constant blockCode Nat.bits 3))
+    · refine Fin.cases ?_ (fun k => ?_) k
+      · exact pairLabelsProgram
+      · refine Fin.cases ?_ (fun k => ?_) k
+        · exact realLabelsProgram
+        · refine Fin.cases ?_ (fun k => ?_) k
+          · exact (Procedure.listAppend labelCode (0,0)).comp
+              (realLabelsProgram.pair (singletonProgram (fun x : BlockInput => (x.1,3))
+                (mediatorProgram.pair (Procedure.constant blockCode Nat.bits 3))))
+          · refine Fin.cases ?_ (fun k => ?_) k
+            · exact (Procedure.listAppend labelCode (0,0)).comp
+                (((takeProgram 1).comp pairLabelsProgram).pair
+                  (singletonProgram _ thirdMediatorProgram))
+            · refine Fin.cases ?_ (fun k => Fin.elim0 k) k
+              exact (Procedure.listAppend labelCode (0,0)).comp
+                (((dropProgram 1).comp pairLabelsProgram).pair
+                  (singletonProgram _ thirdMediatorProgram))
+
+noncomputable opaque zerosProgram : Procedure labelsCode labelsCode zeros :=
+  Procedure.listMap (0,0) (0,0) ((Procedure.first Nat.bits Nat.bits).pair
+    (Procedure.constant labelCode Nat.bits 0))
+
+private def yyLookup (xs : List Letter) : List Letter × List Letter :=
+  if xs.length=2 ∧ ((xs.drop 0).headD (0,0)).2=2 then
+    ([(((xs.drop 0).headD (0,0)).1,1),(((xs.drop 1).headD (0,0)).1,3)],
+     [(((xs.drop 0).headD (0,0)).1,3),(((xs.drop 1).headD (0,0)).1,1)])
+  else (xs,zeros xs)
+private theorem yyLookup_eq (xs : List Letter) : yyLookup xs=yyFactors xs := by
+  cases xs with
+  | nil => rfl
+  | cons a xs =>
+    cases xs with
+    | nil => simp [yyLookup,yyFactors]
+    | cons b xs =>
+      cases xs with
+      | nil => simp [yyLookup,yyFactors]
+      | cons c xs => simp [yyLookup,yyFactors,List.length_cons]
+
+private noncomputable def relabelProgram (k a : ℕ) : Procedure labelsCode labelCode
+    (fun xs => (((xs.drop k).headD (0,0)).1,a)) :=
+  ((Procedure.first Nat.bits Nat.bits).comp (entryProgram k)).pair
+    (Procedure.constant labelsCode Nat.bits a)
+private noncomputable def crossedProgram (a b : ℕ) : Procedure labelsCode labelsCode
+    (fun xs => [(((xs.drop 0).headD (0,0)).1,a),(((xs.drop 1).headD (0,0)).1,b)]) :=
+  (Procedure.listCons labelCode).comp ((relabelProgram 0 a).pair
+    (singletonProgram _ (relabelProgram 1 b)))
+noncomputable opaque yyFactorsProgram : Procedure labelsCode (prodCode labelsCode labelsCode)
+    yyFactors := by
+  let p := Procedure.conditional (Procedure.boolAnd.comp
+      ((lengthTest 2).pair (labelTest 0 2)))
+    ((crossedProgram 1 3).pair (crossedProgram 3 1))
+    ((Procedure.identity labelsCode).pair zerosProgram)
+  exact p.congrFun (by
+    intro xs
+    simpa only [yyLookup,Function.comp_apply,id_eq,Bool.and_eq_true,decide_eq_true_eq]
+      using yyLookup_eq xs)
+
+noncomputable opaque yyBlockProgram (k : Fin 4) :
+    Procedure blockCode labelsCode (fun x => yyBlock x.1 x.2 k) := by
+  let med := singletonProgram (fun x : BlockInput => (x.1,1))
+    (mediatorProgram.pair (Procedure.constant blockCode Nat.bits 1))
+  refine Fin.cases ?_ (fun k => ?_) k
+  · exact Procedure.constant blockCode labelsCode []
+  · refine Fin.cases ?_ (fun k => ?_) k
+    · exact singletonProgram (fun x : BlockInput => (x.1,3))
+        (mediatorProgram.pair (Procedure.constant blockCode Nat.bits 3))
+    · refine Fin.cases ?_ (fun k => ?_) k
+      · exact (Procedure.listAppend labelCode (0,0)).comp
+          ((((Procedure.first labelsCode labelsCode).comp yyFactorsProgram).comp labelsProgram).pair med)
+      · refine Fin.cases ?_ (fun k => Fin.elim0 k) k
+        exact (Procedure.listAppend labelCode (0,0)).comp
+          ((((Procedure.second labelsCode labelsCode).comp yyFactorsProgram).comp labelsProgram).pair med)
+
+noncomputable opaque privateBlockProgram (k : Fin 4) :
+    Procedure blockCode labelsCode (fun x => privateBlock x.1 x.2 k) := by
+  let med := singletonProgram (fun x : BlockInput => (x.1,1))
+    (mediatorProgram.pair (Procedure.constant blockCode Nat.bits 1))
+  refine Fin.cases ?_ (fun k => ?_) k
+  · exact Procedure.constant blockCode labelsCode []
+  · refine Fin.cases ?_ (fun k => ?_) k
+    · exact singletonProgram (fun x : BlockInput => (x.1,3))
+        (mediatorProgram.pair (Procedure.constant blockCode Nat.bits 3))
+    · refine Fin.cases ?_ (fun k => ?_) k
+      · exact (Procedure.listAppend labelCode (0,0)).comp ((prefixProgram 1).pair med)
+      · refine Fin.cases ?_ (fun k => Fin.elim0 k) k
+        exact (Procedure.listAppend labelCode (0,0)).comp ((suffixProgram 1).pair med)
+
+end ContinuumCoulomb.QuantumOrderedLabelData
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedLabelCompile.lean

@@ -0,0 +1,99 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelPacking
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedRawPackingProgram
+
+namespace OAI
+
+/-! The literal six-local sparse-word compiler followed by the rational
+four-spin compiler.  Its only input is a precision, a unary qubit count,
+and the ordered rational sparse-word list. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedLabelCompile
+open ExactQuantumFactoring.BitStackProgram QuantumOrderedLabelFamily
+open QuantumOrderedLabelTable
+open scoped Classical
+
+abbrev Input := QuantumOrderedLabelFamily.Input
+
+def qubitCount (x : Input) : ℕ := 4*(QuantumOrderedLabelPipeline.output x).1
+
+def classify (xs : List Entry) : List QuantumRawExchange.Raw :=
+  xs.map QuantumOrderedRawPacking.value
+
+def labelEntries (x : Input) : List Entry := (QuantumOrderedLabelPipeline.output x).2
+
+def rawEntries : Input → List QuantumRawExchange.Raw := classify ∘ labelEntries
+
+def outputCount : Input → ℕ := Prod.fst ∘ QuantumOrderedLabelPipeline.output
+
+def rawInput (x : Input) : QuantumRawExchange.ScheduleInput :=
+  (outputCount x,x.1,rawEntries x)
+
+def output : Input → List MediatorListProgram.Bond × ℚ :=
+  QuantumRawExchange.compile ∘ rawInput
+
+noncomputable opaque classifyProgram : Procedure (listCode entryCode)
+    (listCode QuantumRawExchange.rawCode) classify := by
+  let p := Procedure.listMap ([],0) QuantumRawExchange.zeroRaw QuantumOrderedRawPacking.program
+  exact p.congrEncoding (by intro xs; rfl) (by intro ys; rfl)
+
+noncomputable opaque labelEntriesProgram : Procedure inputCode (listCode entryCode)
+    labelEntries :=
+  (Procedure.second unaryCode (listCode entryCode)).comp
+    QuantumOrderedLabelPipeline.outputProgram
+
+noncomputable opaque rawEntriesProgram : Procedure inputCode
+    (listCode QuantumRawExchange.rawCode) rawEntries :=
+  Procedure.comp (f := labelEntries) (g := classify) classifyProgram labelEntriesProgram
+
+noncomputable opaque outputCountProgram : Procedure inputCode unaryCode outputCount :=
+  (Procedure.first unaryCode (listCode entryCode)).comp QuantumOrderedLabelPipeline.outputProgram
+
+noncomputable opaque outputProgram : Procedure inputCode
+    (prodCode (listCode MediatorListProgram.bondCode) ratCode) output := by
+  let input : Procedure inputCode QuantumRawExchange.scheduleCode rawInput :=
+    outputCountProgram.pair
+      ((Procedure.unaryToBits.comp precisionProgram).pair rawEntriesProgram)
+  exact QuantumRawExchange.compileProgram.comp input
+
+noncomputable def certificate : Turing.TM2ComputableInPolyTime inputCode
+    (prodCode (listCode MediatorListProgram.bondCode) ratCode) output := outputProgram.toTM2
+
+variable {ι κ : Type} [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ]
+variable {m n : ℕ}
+
+def finalSites (xs : κ → List ι) (w : κ → ι → Fin 4) :=
+  QuantumOrderedPrivate.outputSites (QuantumOrderedXZ.sites xs w)
+
+def finalWord (xs : κ → List ι) (w : κ → ι → Fin 4) :=
+  QuantumOrderedPrivate.outputWord (QuantumOrderedXZ.sites xs w) (QuantumOrderedXZ.word xs w)
+
+def finalCoefficient (J : κ → ℚ) (N : ℕ) :=
+  QuantumOrderedPrivate.outputCoefficient (QuantumOrderedXZ.coefficient J N) N
+
+theorem output_table (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (w : κ → ι → Fin 4) (J : κ → ℚ)
+    (hlen : ∀ a, (xs a).length ≤ 6) (hx : ∀ a, (xs a).Nodup) (N : ℕ) :
+    output (N,n,table e (index q) xs w J) =
+      QuantumOrderedRawBlock.output N
+        (numberedSites (qubits6 q e) (terms6 e) (finalSites xs w))
+        (numberedWord (qubits6 q e) (terms6 e) (finalWord xs w))
+        (fun i => finalCoefficient J N (terms6 e i)) := by
+  unfold output rawInput outputCount rawEntries labelEntries classify
+  simp only [Function.comp_apply]
+  simp only [QuantumOrderedLabelTable.output_table q e xs w J hlen hx N]
+  rw [packed_table]
+  rfl
+
+omit [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ] in
+theorem qubitCount_table (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (w : κ → ι → Fin 4) (J : κ → ℚ) (N : ℕ) :
+    qubitCount (N,n,table e (index q) xs w J)=4*(n+3717*m) := by
+  rw [qubitCount,QuantumOrderedLabelPipeline.output_qubits]
+  simp only [table,List.length_ofFn]
+
+end ContinuumCoulomb.QuantumOrderedLabelCompile
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedLabelCorrectness.lean

@@ -0,0 +1,89 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelTable
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelPipeline
+
+namespace OAI
+
+/-! Each literal list stage is exactly the corresponding ordered Pauli
+construction, with explicit finite product and sum enumerations. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedLabelTable
+open QuantumOrderedLabelData QuantumOrderedLabelFamily
+open scoped Classical
+
+variable {ι κ : Type} [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ]
+variable {m n d : ℕ}
+
+omit [Fintype ι] [DecidableEq ι] [DecidableEq κ] in
+theorem value_table (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (w : κ → ι → Fin 4) (J : κ → ℚ) (N : ℕ)
+    (f : ℕ → List Letter → Fin d → List Letter)
+    (g : ℚ → ℚ → Fin d → ℚ)
+    (ys : κ × Fin d → List (ι ⊕ κ)) (v : κ × Fin d → ι ⊕ κ → Fin 4)
+    (h : ∀ p, tag (Sum.elim (index q) (fun a => n+(e.symm a).val)) (ys p) (v p) =
+      f (n+(e.symm p.1).val) (tag (index q) (xs p.1) (w p.1)) p.2) :
+    value d f g (N,n,table e (index q) xs w J) =
+      (n+m,table (nextTerm e d) (index (nextQubit q e)) ys v
+        (fun p => g (QuantumOrderedSubdivision.scale J N) (J p.1) p.2)) := by
+  apply Prod.ext
+  · simp only [value,table,List.length_ofFn]
+  · rw [show (value d f g (N,n,table e (index q) xs w J)).2 =
+        family d f g (N,n,table e (index q) xs w J) from rfl,
+      family_table]
+    unfold table
+    apply congrArg List.ofFn
+    funext i
+    dsimp only
+    rw [nextQubit_index,h]
+
+theorem subdivision_table (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (w : κ → ι → Fin 4) (J : κ → ℚ)
+    (hx : ∀ a, (xs a).Nodup) (N cut : ℕ) :
+    QuantumOrderedLabelPipeline.subdivisionStep cut (N,n,table e (index q) xs w J) =
+      (N,n+m,table (nextTerm e 4) (index (nextQubit q e))
+        (QuantumOrderedSubdivision.outputSites xs cut)
+        (QuantumOrderedSubdivision.outputWord xs cut w)
+        (QuantumOrderedSubdivision.outputCoefficient J N)) := by
+  apply congrArg (Prod.mk N)
+  exact value_table q e xs w J N _ _ _ _
+    (subdivision_tag (index q) (fun a => n+(e.symm a).val) xs w hx cut)
+
+theorem third_table (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (w : κ → ι → Fin 4) (J : κ → ℚ)
+    (hlen : ∀ a, (xs a).length ≤ 3) (hx : ∀ a, (xs a).Nodup) (N : ℕ) :
+    QuantumOrderedLabelPipeline.thirdStep (N,n,table e (index q) xs w J) =
+      (N,n+m,table (nextTerm e 7) (index (nextQubit q e))
+        (QuantumOrderedThird.outputSites xs w) (QuantumOrderedThird.outputWord xs w)
+        (QuantumOrderedThird.outputCoefficient J N)) := by
+  apply congrArg (Prod.mk N)
+  exact value_table q e xs w J N _ _ _ _
+    (thirdBlock_tag (index q) (fun a => n+(e.symm a).val) xs w hlen hx)
+
+omit [Fintype ι] in
+theorem yy_table (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (w : κ → ι → Fin 4) (J : κ → ℚ)
+    (hx : ∀ a, (xs a).Nodup) (N : ℕ) :
+    QuantumOrderedLabelPipeline.yyStep (N,n,table e (index q) xs w J) =
+      (N,n+m,table (nextTerm e 4) (index (nextQubit q e))
+        (QuantumOrderedYY.outputSites xs) (QuantumOrderedYY.outputWord xs w)
+        (QuantumOrderedYY.outputCoefficient J N)) := by
+  apply congrArg (Prod.mk N)
+  exact value_table q e xs w J N _ _ _ _
+    (yyBlock_tag (index q) (fun a => n+(e.symm a).val) xs w hx)
+
+omit [Fintype ι] in
+theorem private_table (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (w : κ → ι → Fin 4) (J : κ → ℚ) (N : ℕ) :
+    QuantumOrderedLabelPipeline.privateStep (N,n,table e (index q) xs w J) =
+      (N,n+m,table (nextTerm e 4) (index (nextQubit q e))
+        (QuantumOrderedPrivate.outputSites xs) (QuantumOrderedPrivate.outputWord xs w)
+        (QuantumOrderedPrivate.outputCoefficient J N)) := by
+  apply congrArg (Prod.mk N)
+  exact value_table q e xs w J N _ _ _ _
+    (privateBlock_tag (index q) (fun a => n+(e.symm a).val) xs w)
+
+end ContinuumCoulomb.QuantumOrderedLabelTable
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedLabelData.lean

@@ -0,0 +1,107 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedRawPacking
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedThirdSites
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedYYReduction
+
+namespace OAI
+
+/-! Ordered sparse site/letter arrays.  Every word carries the already
+proved support list; the bounded gadget operations inspect at most six
+letters, and retain the original order even for identity letters. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedLabelData
+open scoped BigOperators Classical
+
+abbrev Letter := QuantumOrderedRawPacking.Letter
+
+def tag {ι : Type} (index : ι → ℕ) (xs : List ι) (w : ι → Fin 4) : List Letter :=
+  xs.map (fun i => (index i,(w i).val))
+
+def partition (xs : List Letter) : List Letter × List Letter :=
+  match xs with
+  | [a,b,c] => if a.2=2 then
+      if b.2=2 then ([a,b],[c]) else ([a,c],[b])
+    else ([b,c],[a])
+  | _ => (xs,[])
+
+def yCount (xs : List Letter) : ℕ := (xs.filter (fun a => a.2=2)).length
+
+def axis (xs : List Letter) : ℕ := if Odd (yCount xs) then 2 else 1
+
+theorem tag_length {ι : Type} (index : ι → ℕ) (xs : List ι) (w : ι → Fin 4) :
+    (tag index xs w).length=xs.length := List.length_map _
+
+theorem tag_take {ι : Type} (index : ι → ℕ) (xs : List ι) (w : ι → Fin 4) (d : ℕ) :
+    tag index (xs.take d) w = (tag index xs w).take d := by
+  simp only [tag,List.map_take]
+
+theorem tag_drop {ι : Type} (index : ι → ℕ) (xs : List ι) (w : ι → Fin 4) (d : ℕ) :
+    tag index (xs.drop d) w = (tag index xs w).drop d := by
+  simp only [tag,List.map_drop]
+
+theorem partition_tag {ι : Type} (index : ι → ℕ) (xs : List ι) (w : ι → Fin 4) :
+    partition (tag index xs w) =
+      (tag index (QuantumOrderedTriple.partition xs w).1 w,
+        tag index (QuantumOrderedTriple.partition xs w).2 w) := by
+  cases xs with
+  | nil => rfl
+  | cons a xs =>
+    cases xs with
+    | nil => rfl
+    | cons b xs =>
+      cases xs with
+      | nil => rfl
+      | cons c xs =>
+        cases xs with
+        | cons d xs => rfl
+        | nil =>
+          have ha : (w a).val=2 ↔ w a=2 := by
+            constructor
+            · intro h; exact Fin.ext h
+            · intro h; exact congrArg Fin.val h
+          have hb : (w b).val=2 ↔ w b=2 := by
+            constructor
+            · intro h; exact Fin.ext h
+            · intro h; exact congrArg Fin.val h
+          simp only [tag,List.map_cons,List.map_nil,partition,ha,hb,
+            QuantumOrderedTriple.partition]
+          split_ifs <;> rfl
+
+variable {ι : Type} [Fintype ι] [DecidableEq ι]
+
+theorem yCount_tag (index : ι → ℕ) (xs : List ι) (w : ι → Fin 4)
+    (hx : xs.Nodup) (hw : qmaPauliSupport w ⊆ xs.toFinset) :
+    yCount (tag index xs w)=qmaPauliYCount w := by
+  have hfilter : (xs.filter (fun i => w i=2)).toFinset =
+      Finset.univ.filter (fun i => w i=2) := by
+    ext i
+    simp only [List.mem_toFinset,List.mem_filter,Finset.mem_filter,
+      Finset.mem_univ,true_and,decide_eq_true_eq]
+    constructor
+    · exact fun h => h.2
+    · intro h
+      exact ⟨List.mem_toFinset.mp (hw (by simp [qmaPauliSupport,h])),h⟩
+  have hcount := List.toFinset_card_of_nodup (hx.filter (fun i => w i=2))
+  rw [hfilter] at hcount
+  unfold yCount tag
+  rw [List.filter_map]
+  have hv : (fun i : ι => decide ((w i).val=2)) = (fun i => decide (w i=2)) := by
+    funext i
+    congr 1
+    exact propext ⟨fun h => Fin.ext h,fun h => congrArg Fin.val h⟩
+  simp only [Function.comp_def,hv,List.length_map]
+  exact hcount.symm
+
+omit [Fintype ι] in
+theorem tag_restrict (index : ι → ℕ) (xs : List ι) (w : ι → Fin 4)
+    (ys : List ι) (hys : ∀ i ∈ xs, i ∈ ys) :
+    tag index xs (qmaPauliRestrict ys.toFinset w)=tag index xs w := by
+  apply List.map_congr_left
+  intro i hi
+  simp only [qmaPauliRestrict,List.mem_toFinset.mpr (hys i hi),ite_true]
+
+end ContinuumCoulomb.QuantumOrderedLabelData
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedLabelEnergy.lean

@@ -0,0 +1,84 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelCompile
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedXZEnergy
+
+namespace OAI
+
+/-! Full-space energy guarantee for the emitted raw exchange list, with
+the five early reductions, private-pair subdivision, and four-spin error
+all accounted for. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedLabelCompile
+open QuantumOrderedLabelTable
+open scoped Classical
+
+def outputEnergy (x : Input) : ℝ :=
+  MediatorGraph.normalizedBottom (QuantumRawExchange.rawMatrix (qubitCount x) (output x))
+
+variable {ι κ : Type} [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ]
+variable {m n : ℕ}
+
+def finalEnergy (xs : κ → List ι) (w : κ → ι → Fin 4) (J : κ → ℚ) (N : ℕ) : ℝ :=
+  MediatorGraph.normalizedBottom (qmaPauliFamily (finalWord xs w)
+    (fun p => (finalCoefficient J N p:ℝ)))
+
+theorem compiled_final_error (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (w : κ → ι → Fin 4) (J : κ → ℚ)
+    (hlen : ∀ a, (xs a).length ≤ 6) (hx : ∀ a, (xs a).Nodup)
+    (hcover : ∀ a, qmaPauliSupport (w a) ⊆ (xs a).toFinset)
+    (he : ∀ a, Even (qmaPauliYCount (w a))) (N : ℕ) (hN : 0 < N) :
+    |outputEnergy (N,n,table e (index q) xs w J)-finalEnergy xs w J N| ≤ 2/(N:ℝ) := by
+  let qf := qubits6 q e
+  let ef := terms6 e
+  have hlenF : ∀ p, (finalSites xs w p).length ≤ 2 :=
+    QuantumOrderedPrivate.outputSites_length _ (QuantumOrderedXZ.sites_length xs w hlen)
+  have hxF : ∀ p, (finalSites xs w p).Nodup :=
+    QuantumOrderedPrivate.outputSites_nodup _ (QuantumOrderedXZ.sites_nodup xs w hlen hx)
+  have hsF : ∀ p, qmaPauliSupport (finalWord xs w p) ⊆ (finalSites xs w p).toFinset :=
+    QuantumOrderedPrivate.outputSites_cover _ _
+  have hyF : ∀ p i, finalWord xs w p i ≠ 2 :=
+    QuantumOrderedPrivate.output_noY _ _ (QuantumOrderedXZ.noY xs w hlen hx hcover he)
+  have hpF : ∀ p r, (qmaPauliSupport (finalWord xs w p)).card=2 →
+      qmaPauliSupport (finalWord xs w p)=qmaPauliSupport (finalWord xs w r) → p=r :=
+    QuantumOrderedPrivate.output_private _ _ (QuantumOrderedXZ.sites_nodup xs w hlen hx)
+  have hr := QuantumOrderedRawBlock.output_accuracy N hN
+    (numberedSites qf ef (finalSites xs w)) (numberedWord qf ef (finalWord xs w))
+    (fun i => finalCoefficient J N (ef i))
+    (fun i => (numbered_sites_length qf ef _ i).trans_le (hlenF (ef i)))
+    (numbered_sites_nodup qf ef _ hxF) (numbered_cover qf ef _ _ hsF)
+    (fun i j => hyF (ef i) (qf j)) (numbered_private qf ef _ hpF)
+  have hn : qubitCount (N,n,table e (index q) xs w J)=finalCount n m*4 := by
+    rw [qubitCount_table,finalCount_eq]
+    omega
+  unfold outputEnergy
+  rw [hn,output_table q e xs w J hlen hx N]
+  unfold finalEnergy
+  rw [← numbered_energy qf ef (finalWord xs w) (fun p => (finalCoefficient J N p:ℝ))]
+  exact hr
+
+theorem final_xz_error (xs : κ → List ι) (w : κ → ι → Fin 4) (J : κ → ℚ)
+    (hlen : ∀ a, (xs a).length ≤ 6) (hx : ∀ a, (xs a).Nodup)
+    (N : ℕ) (hN : 0 < N) :
+    |finalEnergy xs w J N-QuantumOrderedXZ.energy xs w J N| ≤ 1/(N:ℝ) :=
+  QuantumOrderedPrivate.output_accuracy _ _ _ (QuantumOrderedXZ.sites_nodup xs w hlen hx)
+    (QuantumOrderedXZ.sites_cover xs w) N (by omega)
+
+theorem output_accuracy (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (w : κ → ι → Fin 4) (J : κ → ℚ)
+    (hlen : ∀ a, (xs a).length ≤ 6) (hx : ∀ a, (xs a).Nodup)
+    (hcover : ∀ a, qmaPauliSupport (w a) ⊆ (xs a).toFinset)
+    (he : ∀ a, Even (qmaPauliYCount (w a))) (N : ℕ) (hN : 0 < N) :
+    |outputEnergy (N,n,table e (index q) xs w J)-
+      MediatorGraph.normalizedBottom (qmaPauliFamily w (fun a => (J a:ℝ)))| ≤ 8/(N:ℝ) := by
+  have h₁ := compiled_final_error q e xs w J hlen hx hcover he N hN
+  have h₂ := final_xz_error xs w J hlen hx N hN
+  have h₃ := QuantumOrderedXZ.accuracy xs w J hlen hx hcover he N (by omega)
+  exact (abs_sub_le _ (finalEnergy xs w J N) _).trans
+    ((add_le_add h₁ ((abs_sub_le _ (QuantumOrderedXZ.energy xs w J N) _).trans
+      (add_le_add h₂ h₃))).trans_eq (by ring))
+
+end ContinuumCoulomb.QuantumOrderedLabelCompile
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedLabelFamily.lean

@@ -0,0 +1,106 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelProgram
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedWeightProgram
+
+namespace OAI
+
+/-! A literal indexed list stage, shared by the six fixed local reductions.
+New mediator indices are the old qubit count plus the input term index.
+Unary counts bound the output size; rational coefficients stay binary. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedLabelFamily
+open ExactQuantumFactoring.BitStackProgram
+open QuantumOrderedLabelData
+
+abbrev Entry := List Letter × ℚ
+abbrev State := ℕ × List Entry
+abbrev Input := ℕ × State
+abbrev BlockInput := (ℕ × ℚ) × Entry
+
+def entryCode : Entry → List Bool := prodCode labelsCode ratCode
+def stateCode : State → List Bool := prodCode unaryCode (listCode entryCode)
+def inputCode : Input → List Bool := prodCode unaryCode stateCode
+def blockCode : BlockInput → List Bool := prodCode (prodCode Nat.bits ratCode) entryCode
+
+def weights (x : Input) : QuantumOrderedWeightProgram.Input := (x.1,x.2.2.map Prod.snd)
+def radius (x : Input) : ℚ := QuantumOrderedWeightProgram.scale (weights x)
+def indexed (x : ℕ × Input) : BlockInput :=
+  ((x.2.2.1+x.1,radius x.2),(x.2.2.2.drop x.1).headD ([],0))
+
+def block (d : ℕ) (f : ℕ → List Letter → Fin d → List Letter)
+    (g : ℚ → ℚ → Fin d → ℚ) (x : BlockInput) : List Entry :=
+  List.ofFn (fun k => (f x.1.1 x.2.1 k,g x.1.2 x.2.2 k))
+
+def family (d : ℕ) (f : ℕ → List Letter → Fin d → List Letter)
+    (g : ℚ → ℚ → Fin d → ℚ) (x : Input) : List Entry :=
+  ((List.range x.2.2.length).map (fun i => block d f g (indexed (i,x)))).flatten
+
+def value (d : ℕ) (f : ℕ → List Letter → Fin d → List Letter)
+    (g : ℚ → ℚ → Fin d → ℚ) (x : Input) : State :=
+  (x.2.1+x.2.2.length,family d f g x)
+
+noncomputable opaque stateProgram : Procedure inputCode stateCode Prod.snd := Procedure.second _ _
+noncomputable opaque precisionProgram : Procedure inputCode unaryCode Prod.fst := Procedure.first _ _
+noncomputable opaque countProgram : Procedure inputCode unaryCode (fun x => x.2.1) :=
+  (Procedure.first _ _).comp stateProgram
+noncomputable opaque entriesProgram : Procedure inputCode (listCode entryCode) (fun x => x.2.2) :=
+  (Procedure.second _ _).comp stateProgram
+noncomputable opaque lengthProgram : Procedure inputCode unaryCode (fun x => x.2.2.length) :=
+  (ExactQuantumFactoring.NativeAIG.Emission.listUnaryLength entryCode ([],0)).comp entriesProgram
+noncomputable opaque weightsProgram : Procedure inputCode QuantumOrderedWeightProgram.inputCode weights :=
+  precisionProgram.pair ((Procedure.listMap ([],0) 0
+    (Procedure.second labelsCode ratCode)).comp entriesProgram)
+noncomputable opaque radiusProgram : Procedure inputCode ratCode radius :=
+  QuantumOrderedWeightProgram.scaleProgram.comp weightsProgram
+
+noncomputable opaque indexedProgram : Procedure (prodCode unaryCode inputCode) blockCode indexed := by
+  let i := Procedure.first unaryCode inputCode
+  let x := Procedure.second unaryCode inputCode
+  let n := (Procedure.unaryToBits.comp countProgram).comp x
+  let j := Procedure.unaryToBits.comp i
+  let selected :=  (Procedure.listGet entryCode ([],0)).comp (j.pair (entriesProgram.comp x))
+  exact ((Procedure.binaryAdd.comp (n.pair j)).pair (radiusProgram.comp x)).pair selected
+
+noncomputable def blockProgram (d : ℕ)
+    (f : ℕ → List Letter → Fin d → List Letter) (g : ℚ → ℚ → Fin d → ℚ)
+    (pf : ∀ k, Procedure QuantumOrderedLabelData.blockCode labelsCode (fun x => f x.1 x.2 k))
+    (pg : ∀ k, Procedure QuantumOrderedWeightProgram.pairCode ratCode (fun x => g x.1 x.2 k)) :
+    Procedure blockCode (listCode entryCode) (block d f g) := by
+  let params := Procedure.first (prodCode Nat.bits ratCode) entryCode
+  let entry := Procedure.second (prodCode Nat.bits ratCode) entryCode
+  let mediator := (Procedure.first Nat.bits ratCode).comp params
+  let scale := (Procedure.second Nat.bits ratCode).comp params
+  let labels := (Procedure.first labelsCode ratCode).comp entry
+  let coefficient := (Procedure.second labelsCode ratCode).comp entry
+  exact QuantumRawExchange.fixedListProgram blockCode entryCode d _
+    (fun k => ((pf k).comp (mediator.pair labels)).pair
+      ((pg k).comp (scale.pair coefficient)))
+
+noncomputable def familyProgram (d : ℕ)
+    (f : ℕ → List Letter → Fin d → List Letter) (g : ℚ → ℚ → Fin d → ℚ)
+    (p : Procedure blockCode (listCode entryCode) (block d f g)) :
+    Procedure inputCode (listCode entryCode) (family d f g) := by
+  let tab := Procedure.tabulate (f := fun x i => block d f g (indexed (i,x))) []
+    (p.comp indexedProgram)
+  exact (QuantumRawExchange.flattenProgram entryCode ([],0)).comp
+    (tab.comp (lengthProgram.pair (Procedure.identity inputCode)))
+
+noncomputable def valueProgram (d : ℕ)
+    (f : ℕ → List Letter → Fin d → List Letter) (g : ℚ → ℚ → Fin d → ℚ)
+    (p : Procedure blockCode (listCode entryCode) (block d f g)) :
+    Procedure inputCode stateCode (value d f g) :=
+  (Procedure.unaryAdd.comp (countProgram.pair lengthProgram)).pair (familyProgram d f g p)
+
+theorem family_length (d : ℕ)
+    (f : ℕ → List Letter → Fin d → List Letter) (g : ℚ → ℚ → Fin d → ℚ)
+    (x : Input) : (family d f g x).length=x.2.2.length*d := by
+  unfold family
+  rw [List.length_flatten,List.map_map]
+  simp only [Function.comp_def,block,List.length_ofFn]
+  simp
+
+end ContinuumCoulomb.QuantumOrderedLabelFamily
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedLabelOutput.lean

@@ -0,0 +1,93 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelCorrectness
+
+namespace OAI
+
+/-! The complete literal sparse-label compiler equals the actual ordered
+six-to-four-to-three-to-two-to-XZ construction and private-pair stage. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedLabelTable
+open scoped Classical
+
+variable {ι κ : Type} {m n : ℕ}
+
+def terms1 (e : Fin m ≃ κ) := nextTerm e 4
+def terms2 (e : Fin m ≃ κ) := nextTerm (terms1 e) 4
+def terms3 (e : Fin m ≃ κ) := nextTerm (terms2 e) 7
+def terms4 (e : Fin m ≃ κ) := nextTerm (terms3 e) 4
+def terms5 (e : Fin m ≃ κ) := nextTerm (terms4 e) 7
+def terms6 (e : Fin m ≃ κ) := nextTerm (terms5 e) 4
+
+def qubits1 (q : Fin n ≃ ι) (e : Fin m ≃ κ) := nextQubit q e
+def qubits2 (q : Fin n ≃ ι) (e : Fin m ≃ κ) := nextQubit (qubits1 q e) (terms1 e)
+def qubits3 (q : Fin n ≃ ι) (e : Fin m ≃ κ) := nextQubit (qubits2 q e) (terms2 e)
+def qubits4 (q : Fin n ≃ ι) (e : Fin m ≃ κ) := nextQubit (qubits3 q e) (terms3 e)
+def qubits5 (q : Fin n ≃ ι) (e : Fin m ≃ κ) := nextQubit (qubits4 q e) (terms4 e)
+def qubits6 (q : Fin n ≃ ι) (e : Fin m ≃ κ) := nextQubit (qubits5 q e) (terms5 e)
+
+def finalCount (n m : ℕ) : ℕ :=
+  n+m+m*4+m*4*4+m*4*4*7+m*4*4*7*4+m*4*4*7*4*7
+
+theorem finalCount_eq (n m : ℕ) : finalCount n m=n+3717*m := by
+  unfold finalCount
+  omega
+
+variable [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ]
+
+theorem output_table (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (w : κ → ι → Fin 4) (J : κ → ℚ)
+    (hlen : ∀ a, (xs a).length ≤ 6) (hx : ∀ a, (xs a).Nodup) (N : ℕ) :
+    QuantumOrderedLabelPipeline.output (N,n,table e (index q) xs w J) =
+      (finalCount n m,table (terms6 e) (index (qubits6 q e))
+        (QuantumOrderedPrivate.outputSites (QuantumOrderedXZ.sites xs w))
+        (QuantumOrderedPrivate.outputWord (QuantumOrderedXZ.sites xs w)
+          (QuantumOrderedXZ.word xs w))
+        (QuantumOrderedPrivate.outputCoefficient (QuantumOrderedXZ.coefficient J N) N)) := by
+  have h1 := subdivision_table q e xs w J hx N 3
+  have h2 := subdivision_table (qubits1 q e) (terms1 e)
+    (QuantumOrderedSubdivision.outputSites xs 3)
+    (QuantumOrderedSubdivision.outputWord xs 3 w)
+    (QuantumOrderedSubdivision.outputCoefficient J N)
+    (QuantumOrderedSubdivision.outputSites_nodup xs 3 hx) N 2
+  have h3 := third_table (qubits2 q e) (terms2 e)
+    (QuantumOrderedXZ.threeSites xs) (QuantumOrderedXZ.threeWord xs w)
+    (QuantumOrderedXZ.threeCoefficient J N)
+    (QuantumOrderedXZ.threeSites_length xs hlen) (QuantumOrderedXZ.threeSites_nodup xs hx) N
+  have h4 := yy_table (qubits3 q e) (terms3 e)
+    (QuantumOrderedXZ.twoSites xs w) (QuantumOrderedXZ.twoWord xs w)
+    (QuantumOrderedXZ.twoCoefficient J N)
+    (QuantumOrderedXZ.twoSites_nodup xs w hlen hx) N
+  have h5 := third_table (qubits4 q e) (terms4 e)
+    (QuantumOrderedXZ.xzThreeSites xs w) (QuantumOrderedXZ.xzThreeWord xs w)
+    (QuantumOrderedXZ.xzThreeCoefficient J N)
+    (QuantumOrderedXZ.xzThreeSites_length xs w hlen)
+    (QuantumOrderedXZ.xzThreeSites_nodup xs w hlen hx) N
+  have h6 := private_table (qubits5 q e) (terms5 e)
+    (QuantumOrderedXZ.sites xs w) (QuantumOrderedXZ.word xs w)
+    (QuantumOrderedXZ.coefficient J N) N
+  change _ = (N,n+m,table (terms1 e) (index (qubits1 q e))
+    (QuantumOrderedSubdivision.outputSites xs 3)
+    (QuantumOrderedSubdivision.outputWord xs 3 w)
+    (QuantumOrderedSubdivision.outputCoefficient J N)) at h1
+  change _ = (N,n+m+m*4,table (terms2 e) (index (qubits2 q e))
+    (QuantumOrderedXZ.threeSites xs) (QuantumOrderedXZ.threeWord xs w)
+    (QuantumOrderedXZ.threeCoefficient J N)) at h2
+  change _ = (N,n+m+m*4+m*4*4,table (terms3 e) (index (qubits3 q e))
+    (QuantumOrderedXZ.twoSites xs w) (QuantumOrderedXZ.twoWord xs w)
+    (QuantumOrderedXZ.twoCoefficient J N)) at h3
+  change _ = (N,n+m+m*4+m*4*4+m*4*4*7,table (terms4 e) (index (qubits4 q e))
+    (QuantumOrderedXZ.xzThreeSites xs w) (QuantumOrderedXZ.xzThreeWord xs w)
+    (QuantumOrderedXZ.xzThreeCoefficient J N)) at h4
+  change _ = (N,n+m+m*4+m*4*4+m*4*4*7+m*4*4*7*4,
+    table (terms5 e) (index (qubits5 q e))
+    (QuantumOrderedXZ.sites xs w) (QuantumOrderedXZ.word xs w)
+    (QuantumOrderedXZ.coefficient J N)) at h5
+  unfold QuantumOrderedLabelPipeline.output
+  rw [h1,h2,h3,h4,h5,h6]
+  rfl
+
+end ContinuumCoulomb.QuantumOrderedLabelTable
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedLabelPacking.lean

@@ -0,0 +1,106 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelOutput
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedRawBlock
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumSpatialReindex
+
+namespace OAI
+
+/-! Conversion of the actual ordered sparse labels into the literal raw
+X/Z instructions, including the explicit finite relabeling of their energy. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedLabelTable
+open scoped BigOperators Classical
+
+variable {ι κ : Type} {n m : ℕ}
+
+def numberedSites (q : Fin n ≃ ι) (e : Fin m ≃ κ) (xs : κ → List ι) :
+    Fin m → List (Fin n) := fun a => (xs (e a)).map q.symm
+
+def numberedWord (q : Fin n ≃ ι) (e : Fin m ≃ κ) (w : κ → ι → Fin 4) :
+    Fin m → Fin n → Fin 4 := fun a i => w (e a) (q i)
+
+private theorem tag_numbered (q : Fin n ≃ ι) (xs : List ι) (w : ι → Fin 4) :
+    QuantumOrderedLabelData.tag (index q) xs w =
+      ((xs.map q.symm).map (fun i => (i.val,(w (q i)).val))) := by
+  simp only [QuantumOrderedLabelData.tag,List.map_map,Function.comp_def,
+    Equiv.apply_symm_apply,index]
+
+theorem packed_table (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (w : κ → ι → Fin 4) (J : κ → ℚ) :
+    (table e (index q) xs w J).map QuantumOrderedRawPacking.value =
+      QuantumRawExchange.packed (QuantumOrderedRawBlock.terms
+        (numberedSites q e xs) (numberedWord q e w)) (fun i => J (e i)) := by
+  simp only [table,List.map_ofFn,Function.comp_def,QuantumRawExchange.packed]
+  apply congrArg List.ofFn
+  funext i
+  rw [tag_numbered]
+  exact QuantumOrderedRawPacking.value_pack _ _ _
+
+variable [Fintype ι] [DecidableEq ι] [Fintype κ]
+
+omit [Fintype ι] [DecidableEq ι] [Fintype κ] in
+theorem numbered_sites_length (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (i : Fin m) :
+    (numberedSites q e xs i).length=(xs (e i)).length := List.length_map _
+
+omit [Fintype ι] [DecidableEq ι] [Fintype κ] in
+theorem numbered_sites_nodup (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (hx : ∀ a, (xs a).Nodup) (i : Fin m) :
+    (numberedSites q e xs i).Nodup := (hx (e i)).map q.symm.injective
+
+omit [DecidableEq ι] [Fintype κ] in
+theorem numbered_support (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (w : κ → ι → Fin 4) (i : Fin m) :
+    qmaPauliSupport (numberedWord q e w i)=
+      (qmaPauliSupport (w (e i))).map q.symm.toEmbedding :=
+  qmaPauliSupport_relabel q.symm (w (e i))
+
+omit [Fintype κ] in
+theorem numbered_cover (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (xs : κ → List ι) (w : κ → ι → Fin 4)
+    (hs : ∀ a, qmaPauliSupport (w a) ⊆ (xs a).toFinset) (i : Fin m) :
+    qmaPauliSupport (numberedWord q e w i) ⊆ (numberedSites q e xs i).toFinset := by
+  rw [numbered_support]
+  intro j hj
+  obtain ⟨a,ha,rfl⟩ := Finset.mem_map.mp hj
+  exact List.mem_toFinset.mpr (List.mem_map.mpr
+    ⟨a,List.mem_toFinset.mp (hs (e i) ha),rfl⟩)
+
+omit [DecidableEq ι] [Fintype κ] in
+theorem numbered_private (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (w : κ → ι → Fin 4)
+    (hp : ∀ a b, (qmaPauliSupport (w a)).card=2 →
+      qmaPauliSupport (w a)=qmaPauliSupport (w b) → a=b)
+    (i j : Fin m) (hi : (qmaPauliSupport (numberedWord q e w i)).card=2)
+    (hij : qmaPauliSupport (numberedWord q e w i)=
+      qmaPauliSupport (numberedWord q e w j)) : i=j := by
+  apply e.injective
+  apply hp (e i) (e j)
+  · simpa only [numbered_support,Finset.card_map] using hi
+  · rw [numbered_support,numbered_support] at hij
+    exact (Finset.map_injective q.symm.toEmbedding) hij
+
+theorem numbered_energy (q : Fin n ≃ ι) (e : Fin m ≃ κ)
+    (w : κ → ι → Fin 4) (J : κ → ℝ) :
+    MediatorGraph.normalizedBottom (qmaPauliFamily (numberedWord q e w) (fun i => J (e i))) =
+      MediatorGraph.normalizedBottom (qmaPauliFamily w J) := by
+  have hw (i : Fin m) : qmaPauliWord (numberedWord q e w i) =
+      (qmaPauliWord (w (e i))).submatrix
+        (qmaQubitBasisEquiv q.symm) (qmaQubitBasisEquiv q.symm) :=
+    qmaPauliWord_relabel q.symm (w (e i))
+  have hm : qmaPauliFamily (numberedWord q e w) (fun i => J (e i)) =
+      (qmaPauliFamily w J).submatrix
+        (qmaQubitBasisEquiv q.symm) (qmaQubitBasisEquiv q.symm) := by
+    ext s t
+    simp only [qmaPauliFamily,Matrix.sum_apply,Matrix.smul_apply,
+      Matrix.submatrix_apply,hw,smul_eq_mul]
+    exact e.sum_comp (fun a => (J a:ℂ)*
+      qmaPauliWord (w a) (qmaQubitBasisEquiv q.symm s) (qmaQubitBasisEquiv q.symm t))
+  rw [hm]
+  exact MediatorGraph.normalizedBottom_reindex (qmaQubitBasisEquiv q.symm) _
+
+end ContinuumCoulomb.QuantumOrderedLabelTable
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedLabelPipeline.lean

@@ -0,0 +1,61 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelBlocks
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelFamily
+
+namespace OAI
+
+/-! A fixed six-stage literal sparse-word compiler. The final stage assigns
+a private mediator to every two-local term before the four-spin encoding. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedLabelPipeline
+open ExactQuantumFactoring.BitStackProgram
+open QuantumOrderedLabelData QuantumOrderedLabelFamily
+
+abbrev Input := QuantumOrderedLabelFamily.Input
+abbrev State := QuantumOrderedLabelFamily.State
+
+def fourWeight (r j : ℚ) := QuantumPolarizedSubdivision.weight r j
+def sevenWeight (r j : ℚ) := QuantumPolarizedThird.weight r j
+
+def subdivisionStep (d : ℕ) (x : Input) : Input :=
+  (x.1,value 4 (fun n xs => subdivision n d xs) fourWeight x)
+def thirdStep (x : Input) : Input := (x.1,value 7 thirdBlock sevenWeight x)
+def yyStep (x : Input) : Input := (x.1,value 4 yyBlock fourWeight x)
+def privateStep (x : Input) : Input := (x.1,value 4 privateBlock fourWeight x)
+def output (x : Input) : State :=
+  (privateStep (thirdStep (yyStep (thirdStep (subdivisionStep 2 (subdivisionStep 3 x)))))).2
+
+noncomputable opaque subdivisionStepProgram (d : ℕ) : Procedure inputCode inputCode
+    (subdivisionStep d) :=
+  precisionProgram.pair (valueProgram 4 _ fourWeight
+    (blockProgram 4 _ fourWeight (subdivisionProgram d) QuantumOrderedWeightProgram.fourProgram))
+noncomputable opaque thirdStepProgram : Procedure inputCode inputCode thirdStep :=
+  precisionProgram.pair (valueProgram 7 thirdBlock sevenWeight
+    (blockProgram 7 thirdBlock sevenWeight thirdBlockProgram QuantumOrderedWeightProgram.sevenProgram))
+noncomputable opaque yyStepProgram : Procedure inputCode inputCode yyStep :=
+  precisionProgram.pair (valueProgram 4 yyBlock fourWeight
+    (blockProgram 4 yyBlock fourWeight yyBlockProgram QuantumOrderedWeightProgram.fourProgram))
+noncomputable opaque privateStepProgram : Procedure inputCode inputCode privateStep :=
+  precisionProgram.pair (valueProgram 4 privateBlock fourWeight
+    (blockProgram 4 privateBlock fourWeight privateBlockProgram QuantumOrderedWeightProgram.fourProgram))
+noncomputable opaque outputProgram : Procedure inputCode stateCode output :=
+  (Procedure.second unaryCode stateCode).comp (privateStepProgram.comp
+    (thirdStepProgram.comp (yyStepProgram.comp (thirdStepProgram.comp
+      ((subdivisionStepProgram 2).comp (subdivisionStepProgram 3))))))
+
+noncomputable def certificate : Turing.TM2ComputableInPolyTime inputCode stateCode output :=
+  outputProgram.toTM2
+
+theorem output_length (x : Input) : (output x).2.length=12544*x.2.2.length := by
+  simp only [output,privateStep,thirdStep,yyStep,subdivisionStep,value,family_length]
+  omega
+
+theorem output_qubits (x : Input) : (output x).1=x.2.1+3717*x.2.2.length := by
+  simp only [output,privateStep,thirdStep,yyStep,subdivisionStep,value,family_length]
+  omega
+
+end ContinuumCoulomb.QuantumOrderedLabelPipeline
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedLabelProgram.lean

@@ -0,0 +1,117 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelSubdivision
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedRawPackingProgram
+
+namespace OAI
+
+/-! Polynomial list programs for the literal support-label operations.
+Only constant-length prefixes are split in the early gadget compiler. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedLabelData
+open ExactQuantumFactoring.BitStackProgram
+
+abbrev labelCode := QuantumOrderedRawPacking.letterCode
+abbrev labelsCode := listCode labelCode
+
+noncomputable def takeProgram (d : ℕ) : Procedure labelsCode labelsCode
+    (fun xs => xs.take d) := by
+  induction d with
+  | zero => exact (Procedure.constant labelsCode labelsCode []).congrFun (by intro xs; rfl)
+  | succ d ih =>
+    let cons := (Procedure.listCons labelCode).comp
+      ((Procedure.listHead labelCode (0,0)).pair (ih.comp (Procedure.listTail labelCode)))
+    exact (Procedure.conditional (Procedure.listEmpty labelCode)
+      (Procedure.constant labelsCode labelsCode []) cons).congrFun (by
+        intro xs
+        cases xs <;> rfl)
+
+noncomputable def dropProgram (d : ℕ) : Procedure labelsCode labelsCode
+    (fun xs => xs.drop d) :=
+  (Procedure.listDrop labelCode).comp
+    ((Procedure.constant labelsCode Nat.bits d).pair (Procedure.identity labelsCode))
+
+def oddLetters (xs : List Letter) : Bool :=
+  xs.foldr (fun a b => xor (decide (a.2=2)) b) false
+
+private theorem oddLetters_eq (xs : List Letter) :
+    oddLetters xs=decide (Odd (yCount xs)) := by
+  induction xs with
+  | nil => rfl
+  | cons a xs ih =>
+    change xor (decide (a.2=2)) (oddLetters xs)=_
+    rw [ih]
+    by_cases ha : a.2=2
+    · have hc : yCount (a::xs)=yCount xs+1 := by simp [yCount,ha]
+      simp only [hc,Nat.odd_add_one,ha,decide_true,Bool.true_xor,decide_not]
+    · have hc : yCount (a::xs)=yCount xs := by simp [yCount,ha]
+      rw [hc]
+      simp [ha]
+
+private theorem fold_oddLetters (xs : List Letter) (b : Bool) :
+    xs.foldl (fun b a => xor (decide (a.2=2)) b) b=xor (oddLetters xs) b := by
+  induction xs generalizing b with
+  | nil => simp [oddLetters]
+  | cons a xs ih =>
+    rw [List.foldl_cons,ih]
+    change xor (oddLetters xs) (xor (decide (a.2=2)) b)=
+      xor (xor (decide (a.2=2)) (oddLetters xs)) b
+    cases b <;> cases ha : decide (a.2=2) <;> cases hx : oddLetters xs <;> rfl
+
+noncomputable opaque oddProgram : Procedure labelsCode Procedure.boolCode
+    (fun xs => decide (Odd (yCount xs))) := by
+  let head := Procedure.first labelCode Procedure.boolCode
+  let letter := (Procedure.second Nat.bits Nat.bits).comp head
+  let test := Procedure.binaryEq.comp
+    (letter.pair (Procedure.constant (prodCode labelCode Procedure.boolCode) Nat.bits 2))
+  let state := Procedure.second labelCode Procedure.boolCode
+  let step := Procedure.boolXor.comp (test.pair state)
+  let fold := Procedure.foldList (0,0) step (Polynomial.C 1) (by
+    intro xs b i
+    simp only [Procedure.boolCode,List.length_singleton,Polynomial.eval_C]
+    exact le_rfl)
+  exact (fold.comp ((Procedure.identity labelsCode).pair
+    (Procedure.constant labelsCode Procedure.boolCode false))).congrFun (by
+      intro xs
+      simp only [Function.comp_apply,id_eq,fold_oddLetters,Bool.xor_false,oddLetters_eq])
+
+noncomputable opaque axisProgram : Procedure labelsCode Nat.bits axis :=
+  (Procedure.conditional oddProgram (Procedure.constant labelsCode Nat.bits 2)
+    (Procedure.constant labelsCode Nat.bits 1)).congrFun (by
+      intro xs
+      simp only [axis,decide_eq_true_eq])
+
+abbrev BlockInput := ℕ × List Letter
+abbrev blockCode := prodCode Nat.bits labelsCode
+noncomputable opaque mediatorProgram : Procedure blockCode Nat.bits Prod.fst := Procedure.first _ _
+noncomputable opaque labelsProgram : Procedure blockCode labelsCode Prod.snd := Procedure.second _ _
+noncomputable opaque prefixProgram (d : ℕ) : Procedure blockCode labelsCode
+    (fun x => x.2.take d) := (takeProgram d).comp labelsProgram
+noncomputable opaque suffixProgram (d : ℕ) : Procedure blockCode labelsCode
+    (fun x => x.2.drop d) := (dropProgram d).comp labelsProgram
+noncomputable opaque mediatorLabelProgram (d : ℕ) : Procedure blockCode labelCode
+    (fun x => (x.1,axis (x.2.take d))) :=
+  mediatorProgram.pair (axisProgram.comp (prefixProgram d))
+noncomputable def singletonProgram {α : Type} {ea : α → List Bool}
+    (f : α → Letter) (p : Procedure ea labelCode f) :
+    Procedure ea labelsCode (fun x => [f x]) :=
+  (Procedure.listCons labelCode).comp (p.pair (Procedure.constant ea labelsCode []))
+
+noncomputable opaque subdivisionProgram (d : ℕ) (k : Fin 4) :
+    Procedure blockCode labelsCode (fun x => subdivision x.1 d x.2 k) := by
+  refine Fin.cases ?_ (fun k => ?_) k
+  · exact Procedure.constant blockCode labelsCode []
+  · refine Fin.cases ?_ (fun k => ?_) k
+    · exact singletonProgram (fun x : BlockInput => (x.1,3))
+        (mediatorProgram.pair (Procedure.constant blockCode Nat.bits 3))
+    · refine Fin.cases ?_ (fun k => ?_) k
+      · exact (Procedure.listAppend labelCode (0,0)).comp
+          ((prefixProgram d).pair (singletonProgram _ (mediatorLabelProgram d)))
+      · refine Fin.cases ?_ (fun k => Fin.elim0 k) k
+        exact (Procedure.listAppend labelCode (0,0)).comp
+          ((suffixProgram d).pair (singletonProgram _ (mediatorLabelProgram d)))
+
+end ContinuumCoulomb.QuantumOrderedLabelData
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedLabelSubdivision.lean

@@ -0,0 +1,94 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelData
+
+namespace OAI
+
+/-! Literal bounded arrays for polarized subdivision.  The exact array
+identity below keeps the supplied site order and the matching mediator. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedLabelData
+open scoped Classical
+
+variable {ι κ : Type} [Fintype ι] [DecidableEq ι] [Fintype κ] [DecidableEq κ]
+
+def subdivision (mediator d : ℕ) (xs : List Letter) : Fin 4 → List Letter :=
+  ![[],[(mediator,3)],xs.take d++[(mediator,axis (xs.take d))],
+    xs.drop d++[(mediator,axis (xs.take d))]]
+
+omit [Fintype ι] [Fintype κ] [DecidableEq ι] [DecidableEq κ] in
+theorem tag_lift (index : ι → ℕ) (slot : κ → ℕ) (xs : List ι)
+    (w : ι → Fin 4) (v : κ → Fin 4) :
+    tag (Sum.elim index slot) (xs.map Sum.inl) (Sum.elim w v) =tag index xs w := by
+  simp only [tag,List.map_map,Function.comp_def,Sum.elim_inl]
+
+omit [Fintype ι] [Fintype κ] [DecidableEq ι] in
+theorem tag_appendMediator (index : ι → ℕ) (slot : κ → ℕ) (xs : List ι)
+    (w : ι → Fin 4) (e : κ) (a : Fin 4) :
+    tag (Sum.elim index slot) (QuantumOrderedSubdivision.appendMediator xs e)
+      (Sum.elim w (qmaSinglePauliWord e a)) =tag index xs w++[(slot e,a.val)] := by
+  simp only [QuantumOrderedSubdivision.appendMediator,tag,List.map_append,List.map_map,
+    Function.comp_def,Sum.elim_inl,List.map_cons,List.map_nil,Sum.elim_inr,
+    qmaSinglePauliWord,ite_true]
+
+omit [Fintype ι] [Fintype κ] [DecidableEq κ] in
+theorem first_tag (index : ι → ℕ) (xs : List ι) (w : ι → Fin 4) (d : ℕ) :
+    tag index (xs.take d) (QuantumOrderedSplit.firstWord xs d w) =
+      (tag index xs w).take d := by
+  rw [QuantumOrderedSplit.firstWord,QuantumOrderedSplit.left,
+    tag_restrict index (xs.take d) w (xs.take d) (fun _ h => h),tag_take]
+
+omit [Fintype ι] [Fintype κ] [DecidableEq κ] in
+theorem second_tag (index : ι → ℕ) (xs : List ι) (w : ι → Fin 4) (d : ℕ) :
+    tag index (xs.drop d) (QuantumOrderedSplit.secondWord xs d w) =
+      (tag index xs w).drop d := by
+  rw [QuantumOrderedSplit.secondWord,QuantumOrderedSplit.right,
+    tag_restrict index (xs.drop d) w (xs.drop d) (fun _ h => h),tag_drop]
+
+omit [Fintype κ] [DecidableEq κ] in
+theorem first_axis (index : ι → ℕ) (xs : List ι) (w : ι → Fin 4)
+    (hx : xs.Nodup) (d : ℕ) :
+    axis ((tag index xs w).take d) =
+      (QuantumPolarizedSubdivision.axis
+        (decide (Odd (qmaPauliYCount (QuantumOrderedSplit.firstWord xs d w))))).val := by
+  have hc := yCount_tag index (xs.take d) (QuantumOrderedSplit.firstWord xs d w)
+    (hx.sublist (List.take_sublist d xs)) (qmaPauliRestrict_support _ _)
+  rw [first_tag] at hc
+  simp only [axis,hc,QuantumPolarizedSubdivision.axis,decide_eq_true_eq]
+  split_ifs <;> rfl
+
+omit [Fintype κ] in
+theorem subdivision_tag (index : ι → ℕ) (slot : κ → ℕ)
+    (xs : κ → List ι) (w : κ → ι → Fin 4)
+    (hx : ∀ e, (xs e).Nodup) (d : ℕ) (p : κ × Fin 4) :
+    tag (Sum.elim index slot) (QuantumOrderedSubdivision.outputSites xs d p)
+      (QuantumOrderedSubdivision.outputWord xs d w p) =
+      subdivision (slot p.1) d (tag index (xs p.1) (w p.1)) p.2 := by
+  rcases p with ⟨e,k⟩
+  fin_cases k
+  · rfl
+  · change tag (Sum.elim index slot) [Sum.inr e]
+      (Sum.elim (fun _ : ι => 0) (qmaSinglePauliWord e 3)) = [(slot e,3)]
+    simp only [tag,List.map_cons,List.map_nil,Sum.elim_inr,qmaSinglePauliWord,ite_true]
+    rfl
+  · change tag (Sum.elim index slot) (QuantumOrderedSubdivision.appendMediator ((xs e).take d) e)
+      (Sum.elim (QuantumOrderedSplit.firstWord (xs e) d (w e))
+        (qmaSinglePauliWord e (QuantumPolarizedSubdivision.axis
+          (QuantumOrderedSubdivision.phase xs d w e)))) =
+        (tag index (xs e) (w e)).take d ++
+          [(slot e,axis ((tag index (xs e) (w e)).take d))]
+    rw [tag_appendMediator,first_tag,first_axis index (xs e) (w e) (hx e)]
+    rfl
+  · change tag (Sum.elim index slot) (QuantumOrderedSubdivision.appendMediator ((xs e).drop d) e)
+      (Sum.elim (QuantumOrderedSplit.secondWord (xs e) d (w e))
+        (qmaSinglePauliWord e (QuantumPolarizedSubdivision.axis
+          (QuantumOrderedSubdivision.phase xs d w e)))) =
+        (tag index (xs e) (w e)).drop d ++
+          [(slot e,axis ((tag index (xs e) (w e)).take d))]
+    rw [tag_appendMediator,second_tag,first_axis index (xs e) (w e) (hx e)]
+    rfl
+
+end ContinuumCoulomb.QuantumOrderedLabelData
+
+end
+
+end OAI

lean/OAI/MathematicalPhysics/ContinuumCoulomb/Quantum/QuantumOrderedLabelTable.lean

@@ -0,0 +1,103 @@
+import OAI.MathematicalPhysics.ContinuumCoulomb.Quantum.QuantumOrderedLabelFamily
+
+namespace OAI
+
+/-! Ordered finite tables and their literal product enumeration. These
+identities compare the computed lists with the actual finite Pauli family. -/
+
+noncomputable section
+namespace ContinuumCoulomb.QuantumOrderedLabelTable
+open QuantumOrderedLabelData QuantumOrderedLabelFamily
+open scoped BigOperators Classical
+
+variable {ι κ : Type} {m n d : ℕ}
+
+def table (e : Fin m ≃ κ) (index : ι → ℕ) (xs : κ → List ι)
+    (w : κ → ι → Fin 4) (J : κ → ℚ) : List Entry :=
+  List.ofFn (fun i => (tag index (xs (e i)) (w (e i)),J (e i)))
+
+def nextTerm (e : Fin m ≃ κ) (d : ℕ) : Fin (m*d) ≃ κ × Fin d :=
+  finProdFinEquiv.symm.trans (Equiv.prodCongr e (Equiv.refl _))
+
+def index (q : Fin n ≃ ι) (i : ι) : ℕ := (q.symm i).val
+
+def nextQubit (q : Fin n ≃ ι) (e : Fin m ≃ κ) : Fin (n+m) ≃ ι ⊕ κ :=
+  finSumFinEquiv.symm.trans (Equiv.sumCongr q e)
+
+theorem nextQubit_index (q : Fin n ≃ ι) (e : Fin m ≃ κ) :
+    index (nextQubit q e) = Sum.elim (index q) (fun a => n+(e.symm a).val) := by
+  funext a
+  cases a <;> simp [index,nextQubit]
+
+private theorem lookup_ofFn {α : Type} (v : Fin m → α) (fallback : α) (i : Fin m) :
+    ((List.ofFn v).drop i.val).headD fallback=v i := by
+  rw [List.drop_eq_getElem_cons (by simpa only [List.length_ofFn] using i.isLt)]
+  simp only [List.headD_cons,List.getElem_ofFn]
+
+theorem product_table {α : Type} (v : Fin m × Fin d → α) :
+    List.ofFn (fun i => v (finProdFinEquiv.symm i)) =
+      (List.ofFn (fun a => List.ofFn (fun b => v (a,b)))).flatten := by
+  rw [List.ofFn_mul]
+  apply congrArg List.flatten
+  apply congrArg List.ofFn
+  funext a
+  apply congrArg List.ofFn
+  funext b
+  have h : finProdFinEquiv (a,b) =
+      (⟨a.val*d+b.val,by nlinarith [a.isLt,b.isLt]⟩ : Fin (m*d)) := by
+    apply Fin.ext
+    change b.val+d*a.val=a.val*d+b.val
+    ac_rfl
+  rw [← h,Equiv.symm_apply_apply]
+
+variable [Fintype κ]
+
+theorem radius_table (e : Fin m ≃ κ) (ix : ι → ℕ) (xs : κ → List ι)
+    (w : κ → ι → Fin 4) (J : κ → ℚ) (N n : ℕ) :
+    radius (N,n,table e ix xs w J)=QuantumOrderedSubdivision.scale J N := by
+  simp only [radius,weights,table,List.map_ofFn,Function.comp_def,List.sum_ofFn,
+    QuantumOrderedWeightProgram.scale,QuantumOrderedSubdivision.scale,
+    QuantumOrderedSubdivision.budget]
+  rw [e.sum_comp (fun a => (1+|J a|)^2)]
+
+/-- A literal stage is the same product-ordered finite table as its supplied
+word and coefficient formulas. The hypotheses are pointwise identities. -/
+theorem family_table (e : Fin m ≃ κ) (ix : ι → ℕ) (xs : κ → List ι)
+    (w : κ → ι → Fin 4) (J : κ → ℚ) (N n : ℕ)
+    (f : ℕ → List Letter → Fin d → List Letter)
+    (g : ℚ → ℚ → Fin d → ℚ) :
+    family d f g (N,n,table e ix xs w J) =
+      List.ofFn (fun i : Fin (m*d) =>
+        let p := nextTerm e d i
+        (f (n+(e.symm p.1).val) (tag ix (xs p.1) (w p.1)) p.2,
+          g (QuantumOrderedSubdivision.scale J N) (J p.1) p.2)) := by
+  let v : Fin m → Entry := fun i => (tag ix (xs (e i)) (w (e i)),J (e i))
+  have hr := radius_table e ix xs w J N n
+  have hrows : (List.range m).map (fun i =>
+      block d f g ((n+i,radius (N,n,table e ix xs w J)),((List.ofFn v).drop i).headD ([],0))) =
+      List.ofFn (fun a : Fin m => block d f g
+        ((n+a.val,QuantumOrderedSubdivision.scale J N),v a)) := by
+    apply List.ext_getElem
+    · simp
+    · intro i hi hj
+      have hi' : i < m := by simpa using hi
+      simp only [List.getElem_map,List.getElem_range,List.getElem_ofFn]
+      rw [hr,lookup_ofFn v ([],0) ⟨i,hi'⟩]
+  change ((List.range (List.ofFn v).length).map (fun i =>
+    block d f g ((n+i,radius (N,n,table e ix xs w J)),((List.ofFn v).drop i).headD ([],0)))).flatten = _
+  rw [List.length_ofFn,hrows]
+  symm
+  convert product_table (fun p : Fin m × Fin d =>
+      (f (n+p.1.val) (v p.1).1 p.2,
+        g (QuantumOrderedSubdivision.scale J N) (v p.1).2 p.2)) using 1
+  · congr 1
+    funext i
+    simp only [nextTerm,Equiv.trans_apply,Equiv.prodCongr_apply,Prod.map_fst,Prod.map_snd,
+      Equiv.refl_apply,Equiv.symm_apply_apply,v]
+  · rfl
+
+end ContinuumCoulomb.QuantumOrderedLabelTable
+
+end
+
+end OAI