/-
Copyright 2026 The Monstrous Moonshine formalization authors.
Released under the Apache License 2.0.

# Final check

This is the default build target of the package.  It imports every module of the formalization and
guards the axiom footprint of everything that is **proved**: each `#guard_msgs` below fails the
build if the printed axiom set is not exactly the three standard axioms, so a passing build is the
axiom verification for those declarations.

## What is deliberately not guarded

`MM.MoonshineModule.moonshine_conjecture` is the standing goal of the repository and is marked `sorry` (see its
docstring, and the `sorry` table in `README.md`).  It is **not** guarded here — guarding it would
either fail the build or require weakening the invariant everywhere else.  The point of separating
it out is that `sorry` marks exactly what is not proved: the assertion that a module with the
required properties *exists*.  Everything around it — the uniqueness of the normalized Hauptmodul
and the constructions of `Y443` and of the monster — is proved and guarded below.

The same goes for three of the four `thetaCoeff_*` coefficients in `Definitions/MMLevelTwo.lean`
(`_one`, `_two`, `_three`): they are `sorry` too, but they are *delivery debt* rather than an open
question — the values have been verified independently and the counts are settled; only the
combinatorial discharge is outstanding.  `MM.thetaCoeff_zero` is **proved** since task D-d2 and is
guarded below.  All four are listed in the `sorry` map of `README.md`.

## Per-batch `sorry`: the same convention, generalized (owner's standing instruction, 2026-09-22)

A batch may deliver a **statement whose proof is still open** with a registered `sorry`: it must be
listed in the `sorry` map of `README.md` and tied to the open task/residual it belongs to in
`ROADMAP.md` or `HANDOVER.md`.  Such declarations are *imported* here but **not guarded**, so that
`sorryAx` stays visible in their own in-file guards rather than being hidden behind this build; the
declarations that merely *consume* such a hole are guarded with `sorryAx` printed explicitly.  The
first two are the statement-only deliveries of batch 229-A: FLM Theorem 8.6.1
(`Definitions/MMFLM810Theorem861Stated.lean`, hole = residual #1) and FLM Theorem 8.8.9 + Remark
8.8.11 (`Definitions/MMFLM88Theorem889Stated.lean`, hole = residual #2).  "No `sorry` anywhere" is
the completion criterion of the whole project, not of a batch.
-/

import Definitions.MMBasic
import Definitions.MMModular
import Definitions.MMGenusZeroArith
import Definitions.MMGenusZeroRefute
import Definitions.MMHauptmodulAnalyticRefute
import Definitions.MNHauptmodulUniqueness
import Definitions.MMQExpansionGap
import Definitions.MMGolay
import Definitions.MMLeech
import Definitions.MMLeechForm
import Definitions.MMLeechIndex
import Definitions.MMLeechKissing
import Definitions.MMLevelOneHauptmodul
import Definitions.MMLevelOneDiscUnit
import Definitions.MMLevelOneCusp
import Definitions.MMLogCoeff
import Definitions.MMQExpansionTwoSided
import Definitions.MMQExpansionTwoSidedLevelOne
import Definitions.MMHauptmodulTwoSided
import Definitions.MMLevelOneLaurentIntegral
import Definitions.MMGenusZeroGroup
import Definitions.MMDenominatorIdentity
import Definitions.MMRootMultiplicityArith
import Definitions.MMRootMultiplicity
import Definitions.MMMonsterMoonshine
import Definitions.MMReplicationRecursion
import Definitions.MMReplicationFormulas
import Definitions.MMReplicationFormulasOdd
import Definitions.MMReplicationPThree
import Definitions.MMReplicationFormulaTargets
import Definitions.MME8Theta
import Definitions.MME8ThetaModular
import Definitions.MME8ThetaS
import Definitions.MME8ThetaSCombination
import Definitions.MME8ThetaModularForm
import Definitions.MME8ThetaAnalytic
import Definitions.MME8ThetaLevelOne
import Definitions.MME8ThetaLattice
import Definitions.MME8ThetaCoeffCount
import Definitions.MME8ThetaCoeffSum
import Definitions.MME8ThetaCoeffFinal
import Definitions.MMLevelOneIntegrality
import Definitions.MMLevelOneDiscProduct
import Definitions.MMLevelOneJCoeffs
import Definitions.MMLevelOneHq
import Definitions.MMGenusZeroStatement
import Definitions.MMLevelOneGenusZero
import Definitions.MMLeechLattice
import Definitions.MMLeechMinNorm
import Definitions.MMLeechEven
import Definitions.MMLeechUnimodular
import Definitions.MMLatticeDoubleCover
import VirasoroProject
import VirasoroProject.Gamma0GL
import Definitions.MMMoonshine
import Definitions.MMCoxeter
import Definitions.MMMonster
import Definitions.MMMonsterOrder
import Definitions.MMPowerSeries
import Definitions.ZZCond
import Definitions.MMLevelTwoBasic
import Definitions.MMLevelTwo
import Definitions.MMGeomSeries
import Definitions.MMExpLog
import Definitions.MMQBinomial
import Definitions.MMJacobiTripleProduct
import Definitions.MMHeisenbergFockBasic
import Definitions.MMGaussBinom
import Definitions.MMJacobiTripleProductProof
import Definitions.MMHeisenbergOscillator
import Definitions.MMLevelOneOrbitSeparation
import Definitions.MMHeisenbergOscillatorComm
import Definitions.MMJacobiTripleProductMain
import Definitions.MMLevelOneOrbitSeparationProof
import Definitions.MMLemma111
import Definitions.MMLevelOneOrbitSeparationDone
import Definitions.MMThetaEtaProduct
import Definitions.MMLevelOneOrbitSeparationFinal
import Definitions.MMThetaEtaProductTwo
import Definitions.MMLemma111Proof
import Definitions.MMLevelOneOrbitSeparationComplete
import Definitions.MMLemma111Final
import Definitions.MMFockPartition
import Definitions.MMFockSmallWeights
import Definitions.MMFockCharacter
import Definitions.MMFockCharacterRankN
import Definitions.MMFockVirasoro
import Definitions.MMLatticeVOA
import Definitions.MMLeechIntegralLattice
import Definitions.MMLatticeVOAGrading
import Definitions.MMLatticeVOACharacter
import Definitions.MMLatticeVOACocycle
import Definitions.MMLatticeVOAOscillatorField
import Definitions.MMThetaDuplication
import Definitions.MME8ThetaTransport
import Definitions.MME8ThetaBridge
import Definitions.MMLevelNOrbitSeparation
import Definitions.MMLatticeVOATwoVarLocality
import Definitions.MMLatticeVOALocalityVendor
import Definitions.MMLatticeVOAExponential
import Definitions.MMLatticeVOAShiftedVertex
import Definitions.MMLatticeVOATensorGrading
import Definitions.MMLatticeVOAInstance
import Definitions.MMLatticeVOAExponentialField
import Definitions.MMFockSpan
import Definitions.MMLatticeVOATwoSided
import Definitions.MMLatticeVOAStateField
import Definitions.MMLatticeVOABorcherds
import Definitions.MMLatticeVOAVertexAlgebra
import Definitions.MMLatticeVOATranslation
import Definitions.MMLatticeVOACovariantBorcherds
import Definitions.MMLatticeVOAIncompatibility
import Definitions.MMLatticeVOACompatBorcherds
import Definitions.MMLatticeVOAReductionCovariant
import Definitions.MMLatticeVOALeftUnit
import Definitions.MMLatticeVOALeftUnitField
import Definitions.MMLatticeVOAThreeProperty
import Definitions.MMLatticeVOAColumnFreedom
import Definitions.MMLatticeVOAThreePropertyIdentity
import Definitions.MMLatticeVOAOrderGeneral
import Definitions.MMLatticeVOAShortcut
import Definitions.MMLatticeVOASkewSymmetry
import Definitions.MMLatticeVOAReductionClosed
import Definitions.MMLatticeVOASignedIdentity
import Definitions.MMLatticeVOAParityAudit
import Definitions.MMMoonshineReduction
import Definitions.MMMoonshineGap
import Definitions.MMFLM81Basic
import Definitions.MMFLM81
import Definitions.MMFLM81Module
import Definitions.MMFLM82Derivations
import Definitions.MMFLM82Flow
import Definitions.MMFLM84Delta
import Definitions.MMFLM84NormalOrder
import Definitions.MMFLM84Commutator
import Definitions.MMFLM84Product
import Definitions.MMFLM84ProductOp
import Definitions.MMFLM84FlatMul
import Definitions.MMFLM84ShiftMul
import Definitions.MMFLM84DerivId
import Definitions.MMFLM84Diag
import Definitions.MMFLM85Components
import Definitions.MMFLM85Brackets
import Definitions.MMFLMFock
import Definitions.MMFLMY87
import Definitions.MMFLMLatticeModule
import Definitions.MMFLM85Extension
import Definitions.MMFLM85Iterate
import Definitions.MMFLMLocalization
import Definitions.MMFLM84Theorem
import Definitions.MMFLM84Taylor
import Definitions.MMFLM85Extraction
import Definitions.MMFLM85Corollary
import Definitions.MMFLM85ProductForm
import Definitions.MMFLMLatticeState
import Definitions.MMFLM84Subst
import Definitions.MMFLM8512Done
import Definitions.MMFLM85Compat
import Definitions.MMFLM8512Heis
import Definitions.MMFLM85Unique
import Definitions.MMFLM88Jacobi
import Definitions.MMFLM85Action
import Definitions.MMFLM85Uniqueness
import Definitions.MMFLM85Hrel
import Definitions.MMFLM85HrelClose
import Definitions.MMFLM810Axioms
import Definitions.MMFLM85ActionSwap
import Definitions.MMFLM810Creation
import Definitions.MMFLM810Truncation
import Definitions.MMFLM85ActionExtension
import Definitions.MMFLM85ActionRelations
import Definitions.MMFLM85TrueAction
import Definitions.MMFLM85ActionTruncation
import Definitions.MMFLM810ActionFields
import Definitions.MMFLM810Fields
import Definitions.MMFLM81SlmulAssoc
import Definitions.MMFLM85ActionAlgebra
import Definitions.MMFLM85ActionPerm
import Definitions.MMFLM85LabelLinearity
import Definitions.MMFLM85TrueActionVacuum
import Definitions.MMFLM85ActionTruncationTA
import Definitions.MMFLM810ActionFieldsTA
import Definitions.MMFLM85RelSpanning
import Definitions.MMFLM85RelationCalculus
import Definitions.MMFLM85BasisReduction
import Definitions.MMFLM85MonomialBasis
import Definitions.MMFLM85PermSpanning
import Definitions.MMFLM810CorrectedAssembly
import Definitions.MMFLM810RemainingReduction
import Definitions.MMFLM810ConformalVector
import Definitions.MMFLM810FormNondegenerate
import Definitions.MMFLM85ZeroModeField
import Definitions.MMFLM810ZeroModeL0
import Definitions.MMFLM810ZeroModeL0Eigen
import Definitions.MMFLM810ZeroModeExchange
import Definitions.MMFLM85ZeroPrescription
import Definitions.MMFLM85ZeroPrescriptionUnique
import Definitions.MMFLM85ZeroPrescriptionSpanning
import Definitions.MMFLM810ZeroModeL0Uncond
import Definitions.MMFLM810ZeroModeTwoFactor
import Definitions.MMFLM810ZeroModeFockDegree
import Definitions.MMFLM810ZeroModeSummed
import Definitions.MMFLM810ZeroModeL0General
import Definitions.MMFLM810FockHalf
import Definitions.MMFLM810L0General
import Definitions.MMFLM86Theorem
import Definitions.MMFLM86OperatorDelta
import Definitions.MMFLM86Corollaries
import Definitions.MMFLM86Machinery
import Definitions.MMFLM86Coefficient
import Definitions.MMFLM810TranslationPowerMinusOne
import Definitions.MMFLM810TranslationStateObstruction
import Definitions.MMFLM810TranslationTail
import Definitions.MMFLM810Product843Honest
import Definitions.MMFLM810TranslationCorrected
import Definitions.MMFLM810TranslationVacuum
import Definitions.MMFLM810IotaTarget
import Definitions.MMFLM810Iota
import Definitions.MMFLM810Theta
import Definitions.MMFLM810Tower
import Definitions.MMFLM810ThetaZero
import Definitions.MMFLM810ThetaKer
import Definitions.MMFLM810Supp
import Definitions.MMFLM810ADSupp
import Definitions.MMFLM810ADDeg
import Definitions.MMFLM810ADAntiDiag
import Definitions.MMFLM810ADInv
import Definitions.MMFLM810ADMain
import Definitions.MMFLM810BridgeCore
import Definitions.MMFLM810BridgeClosure
import Definitions.MMFLM810BridgeIndex
import Definitions.MMFLM810BridgeProduct
import Definitions.MMFLM810RationalityModel
import Definitions.MMFLM810IotaEqCommon
import Definitions.MMFLM810IotaEq
import Definitions.MMFLM85ModeComm
import Definitions.MMFLM810TailOscillator
import Definitions.MMFLM810TailTwoFactor
import Definitions.MMFLM810TranslationOscillator
import Definitions.MMFLM810TranslationDerivationFold
import Definitions.MMFLM810TranslationDerivation
import Definitions.MMFLM810TranslationDerivationState
import Definitions.MMFLM810TranslationDerivationField
import Definitions.MMFLM810WeightResidueVerdict
import Definitions.MMFLM810WeightStepCorrected
import Definitions.MMFLM810HeadLeibniz
import Definitions.MMFLM810VCSharpened
import Definitions.MMFLM810ZeroModeVC3
import Definitions.MMFLM810CentralChargeFold
import Definitions.MMFLM810CentralCharge
import Definitions.MMFLM810CentralChargeProbe
import Definitions.MMFLM810ModesL0
import Definitions.MMFLM810ModesL0Trans
import Definitions.MMFLM810ModesVirasoro
import Definitions.MMFLM810ModesVirasoroBase
import Definitions.MMFLM86ThetaOperatorAux
import Definitions.MMFLM86ThetaOperator
import Definitions.MMFLM87SugawaraConvolution
import Definitions.MMFLM87SugawaraAux
import Definitions.MMFLM810JacobiFaithful
import Definitions.MMFLM810FaithfulModel
import Definitions.MMFLM810JacobiNamedBridge
import Definitions.MMFLM810JacobiNamedBridgeAux
import Definitions.MMFLM810JacobiToBridgeAux
import Definitions.MMFLM810JacobiToBridge
import Definitions.MMFLM86ResidueOperatorAux
import Definitions.MMFLM86ResidueOperator
import Definitions.MMFLM86TaylorOperatorAux
import Definitions.MMFLM86TaylorOperator
import Definitions.MMFLM87SugawaraTransport
import Definitions.MMFLM87SugawaraVacuum
import Definitions.MMFLM87SugawaraIdentity
import Definitions.MMFLM87SugawaraFoldClose
import Definitions.MMFLM87ZeroModeNormalOrder
import Definitions.MMFLM87ZeroModeDecomposition
import Definitions.MMFLM87ZeroModeBracketState
import Definitions.MMFLM87ZeroModeBracket
import Definitions.MMFLM87FockZero
import Definitions.MMFLM87ZeroModeBracketClose
import Definitions.MMFLM87ZeroModeBracketState2
import Definitions.MMFLM87ZeroModeDecompGeneral
import Definitions.MMFLM87ZeroModeDecompGeneralCounter
import Definitions.MMFLM87ZeroModeBracketFinal
import Definitions.MMFLM87ZeroModeBracketAux2
import Definitions.MMFLM87SugawaraGeneral
import Definitions.MMFLM86SpineGap
import Definitions.MMFLM810ScalarJacobi
import Definitions.MMFLM86MultiState
import Definitions.MMFLM86KFold
import Definitions.MMFLM86ShiftedField
import Definitions.MMFLM84OperatorField
import Definitions.MMFLM85NormalOrderState
import Definitions.MMFLM85ConvProduct
import Definitions.MMFLM85StateInterface
import Definitions.MMFLM84VacuumField
import Definitions.MMFLM84AnnihPair
import Definitions.MMFLM85IterateStep
import Definitions.MMFLM85LabelDet
import Definitions.MMFLM84ExpansionFamily
import Definitions.MMFLM84DoubleColon
import Definitions.MMFLM84Contraction
import Definitions.MMFLM85IterateCreated
import Definitions.MMFLM84Completion
import Definitions.MMFLM84DeltaContraction
import Definitions.MMFLM85ConvAdditive
import Definitions.MMFLM84LatticeField
import Definitions.MMFLM84RatioWindow
import Definitions.MMFLM84ContractionNeg
import Definitions.MMFLM85FockSharp
import Definitions.MMFLMLatticeWeightDecomp
import Definitions.MMFLM84RatioWindowClose
import Definitions.MMFLM85FockStrict
import Definitions.MMFLMFockIndep
import Definitions.MMFLMRepairNaming
import Definitions.MMFLM84TwoVarProduct
import Definitions.MMFLM85StepLinear
import Definitions.MMFLMLatticeDirectSum
import Definitions.MMFLM86TwoVarNorm
import Definitions.MMFLM86Extraction
import Definitions.MMFLM86OrdTwo
import Definitions.MMFLM86MixedPair
import Definitions.MMFLM86Slice
import Definitions.MMFLM86WindowDirect
import Definitions.MMFLM86Uniform
import Definitions.MMFLM86InfSupp
import Definitions.MMFLM86OneSided
import Definitions.MMFLM86PerP
import Definitions.MMFLM86LimitStep
import Definitions.MMFLM86Identity8617
import Definitions.MMFLM86ChuVandermonde
import Definitions.MMFLM86Contraction8612
import Definitions.MMFLM86ThetaPerState
import Definitions.MMFLM86Reindex8612
import Definitions.MMFLM86ThetaOperatorPerState
import Definitions.MMFLM86MultiVarSeries
import Definitions.MMFLM86Theorem861K1
import Definitions.MMFLM86CrossContraction
import Definitions.MMFLM86BoundPerState
import Definitions.MMFLM86MixedProduct
import Definitions.MMFLM86PairCoefLaws
import Definitions.MMFLM86Binomial8612
import Definitions.MMFLM86Binomial8612Refute
import Definitions.MMFLM86JointGeneral
import Definitions.MMFLM86IncrementTwoTwo
import Definitions.MMFLM86TheoremDisplay
import Definitions.MMFLM86ProductExpansion
import Definitions.MMFLM86Quadrant8612
import Definitions.MMFLM86Dictionary8612
import Definitions.MMFLM86DiagOrdinaryLink
import Definitions.MMFLM86UniformVanishing
import Definitions.MMFLM86DisplayVOASplit
import Definitions.MMFLM86ExpProduct
import Definitions.MMFLM810CorrectedZeroAssembly
import Definitions.MMFLM86YFamProduct
import Definitions.MMFLM86IterateIota
import Definitions.MMFLM86YzeroIsYFam
import Definitions.MMFLM86TwoVarSwap
import Definitions.MMFLM86CommIota
import Definitions.MMFLMIotaVar
import Definitions.MMFLM86CreatedStep
import Definitions.MMFLM810TranslationBase
import Definitions.MMFLM85BaseFieldAligned
import Definitions.MMFLM84DerivYFam
import Definitions.MMFLM85CanonicalField
import Definitions.MMFLM85SplitPlusAligned
import Definitions.MMFLM84LeibnizTail
import Definitions.MMFLM84TailLeibnizProof
import Definitions.MMFLM810TranslationGeneral
import Definitions.MMFLM87SugawaraStateHalf
import Definitions.MMFLM810StateHalfClose
import Definitions.MMFLM87SugawaraBracketClose
import Definitions.MMFLM810CreationIntertwine
import Definitions.MMFLM87GramSugawara
import Definitions.MMFLM810DFoldAssembly
import Definitions.MMFLM87SugawaraTwoContraction
import Definitions.MMFLM87DoubleCommutator
import Definitions.MMFLM87SugawaraShortRoute
import Definitions.MMFLM810TheoremNoOrth
import Definitions.MMFLM810JacobiZeroFace
import Definitions.MMFLM810CreationCommute
import Definitions.MMFLM810JacobiFull
import Definitions.MMFLM810CurrentFieldComm
import Definitions.MMFLM810TheoremAligned
import Definitions.MMFLM810ThetaKill
import Definitions.MMFLM810RatSubst
import Definitions.MMFLM86ExpProductAligned
import Definitions.MMFLM810Theorem861Aligned
import Definitions.MMFLM86ResidueNegative
import Definitions.MMFLM85CorollaryFock
import Definitions.MMFLM86NegativeChamber
import Definitions.MMFLM85PrescriptionCoeff
import Definitions.MMFLM85PrescriptionCoeffLevel
import Definitions.MMFLM85LevelShift
import Definitions.MMFLM85PrescriptionCoeffLevel2
import Definitions.MMFLM86NegOneCollapse
import Definitions.MMFLM86NegOneCollapseDiag
import Definitions.MMFLM86AntidiagonalAssembly
import Definitions.MMFLM85NonvacuumStep
import Definitions.MMFLM85NonvacuumRefute
import Definitions.MMFLM85OneSidedProduct
import Definitions.MMFLM85OneSidedChain
import Definitions.MMFLM86ExpFieldMul
import Definitions.MMFLM86ExpFieldMulLat
import Definitions.MMFLM86MiddleBlockDiag
import Definitions.MMFLM86MiddleBlockDiagStep4
import Definitions.MMFLM86OPEThird
import Definitions.MMFLM86AssemblyResidualFibers
import Definitions.MMFLM86AssemblyResidualAux
import Definitions.MMFLM86AssemblyResidual
import Definitions.MMFLM86TwoFactorDisplay
import Definitions.MMFLM85PairFiniteDecide
import Definitions.MMFLM86NegTwoResidue
import Definitions.MMFLM86CoherentField
import Definitions.MMFLM86NegTwoDiagonal
import Definitions.MMFLM86NegTwoBlockCollapse
import Definitions.MMFLM86NegTwoBlockCollapseAux
import Definitions.MMFLM86NegTwoWeighted
import Definitions.MMFLM86ModeIntertwine
import Definitions.MMFLM86CoherentCreated
import Definitions.MMFLM86CoherentCreatedStep
import Definitions.MMFLM86NegTwoPOne
import Definitions.MMFLM86FirstDerivLine
import Definitions.MMFLM810TheoremEven
import Definitions.MMFLM86CreationDerivPiece
import Definitions.MMFLM86CreationDerivPieceLine
import Definitions.MMFLM810JacobiNonzeroFaces
import Definitions.MMFLM810NegOneFace
import Definitions.MMFLM86AnnihDerivPiece
import Definitions.MMFLM86AnnihDerivPieceLine
import Definitions.MMFLM810NegOneChambers
import Definitions.MMFLM810NegOneChambersClose
import Definitions.MMFLM86BlockSecondLayer
import Definitions.MMFLM86BlockDerivRegrouped
import Definitions.MMFLM86NegTwoAssembly
import Definitions.MMFLM86DerivDictionary
import Definitions.MMFLM810NegTwoFace
import Definitions.MMFLM810NegTwoChambers
import Definitions.MMFLM86ZOneReassembly
import Definitions.MMFLM86MomentHierarchy
import Definitions.MMFLM810NegThreeFace
import Definitions.MMFLM86TailContraction
import Definitions.MMFLM810NegCFace
import Definitions.MMFLM86FlatReassembly
import Definitions.MMFLM86ZMoments
import Definitions.MMFLM86ZOneFockOne
import Definitions.MMFLM86FockInduction
import Definitions.MMFLM86DescendedAssembly
import Definitions.MMFLM86HarvestAllPairings
import Definitions.MMFLM86HarvestAllPairingsFaces
import Definitions.MMFLM86ZLineInduction
import Definitions.MMFLM86ZLineBaseUpTo
import Definitions.MMFLM86ZLineTwo
import Definitions.MMFLM86FockOneStep
import Definitions.MMFLM86FockOneStepSharp
import Definitions.MMFLM86FockOneStepTwo
import Definitions.MMFLM86ModeLawTwo
import Definitions.MMFLM86GeneratorLineTwoAux
import Definitions.MMFLM86GeneratorLineTwoEval
import Definitions.MMFLM86GeneratorLineTwoComp
import Definitions.MMFLM86GeneratorLineTwo
import Definitions.MMFLM86ZLineTwoClosed
import Definitions.MMFLM86ModeLawAllAux
import Definitions.MMFLM86ModeLawAll
import Definitions.MMFLM86GeneratorLineAllAux
import Definitions.MMFLM86GeneratorLineAll
import Definitions.MMFLM86FockCarrier
import Definitions.MMFLM86FockCarrierAux
import Definitions.MMFLM86FockCarrierSpan
import Definitions.MMFLM86GeneratorLineAllIndAux
import Definitions.MMFLM86GeneratorLineAllInd
import Definitions.MMFLM86ModeLawAllStepAux
import Definitions.MMFLM86ModeLawAllStep
import Definitions.MMFLM86NegThreeBridgeAux
import Definitions.MMFLM86NegThreeBridge
import Definitions.MMFLM86GeneratorLineAllCloseAux
import Definitions.MMFLM86GeneratorLineAllCloseTail
import Definitions.MMFLM86GeneratorLineAllClose
import Definitions.MMFLM810NegCFaceJ
import Definitions.MMFLM810NegCFaceClosed
import Definitions.MMFLM86NegThreeChamberAux
import Definitions.MMFLM86NegThreeChamber
import Definitions.MMFLM86FockDisplaySharp
import Definitions.MMFLM86Corollary851AllStates
import Definitions.MMFLM86NegThreeProveAux
import Definitions.MMFLM86NegThreeProve
import Definitions.MMFLM86FockOneStepProveAux
import Definitions.MMFLM86FockOneStepProve
import Definitions.MMFLM86FockShiftZeroAux
import Definitions.MMFLM86FockShiftZero
import Definitions.MMFLM86Corollary851ModeStepAux
import Definitions.MMFLM86Corollary851ModeStep
import Definitions.MMFLM86CoherentCreatedProveAux
import Definitions.MMFLM86CoherentCreatedProve
import Definitions.MMFLM86CoherentCreatedResidual
import Definitions.MMFLM86Engine86
import Definitions.MMFLM86WeightedAssemblyAux
import Definitions.MMFLM86WeightedAssembly
import Definitions.MMFLM86NestedCauchyAux
import Definitions.MMFLM86NestedCauchy
import Definitions.MMFLM86NestedCauchyTwo
import Definitions.MMFLM86NestedCauchyAxioms
import Definitions.MMFLM86WeightedAssemblyAll
import Definitions.MMFLM86Display866TwoAux
import Definitions.MMFLM86Display866Two
import Definitions.MMFLM86Display866TwoAxioms
import Definitions.MMFLM86CreatedStepNegAux
import Definitions.MMFLM86CreatedStepNeg
import Definitions.MMFLM86CoherentCreatedPosAux
import Definitions.MMFLM86CoherentCreatedPosRankOne
import Definitions.MMFLM86CoherentCreatedPos
import Definitions.MMFLM86CoherentCreatedNonnegAux
import Definitions.MMFLM86CoherentCreatedNonneg
import Definitions.MMFLM810HonestLedger
import Definitions.MMFLM810HonestAudit
import Definitions.MMFLM810BoundaryHonest
import Definitions.MMFLM86ShiftedDerivAux
import Definitions.MMFLM86ShiftedDeriv
import Definitions.MMFLM86ShiftedBootstrap
import Definitions.MMFLM86NormOrderedShiftedAux
import Definitions.MMFLM86NormOrderedShifted
import Definitions.MMFLM86ShiftedDerivationAux
import Definitions.MMFLM86ShiftedDerivation
import Definitions.MMFLM86FockBidegreeAux
import Definitions.MMFLM86FockBidegree
import Definitions.MMFLM86YFamDerivationAux
import Definitions.MMFLM86YFamDerivationBase
import Definitions.MMFLM86YFamDerivation
import Definitions.MMFLM86HWeightSeparationAux
import Definitions.MMFLM86HWeightSeparation
import Definitions.MMFLM86FiberwiseSum
import Definitions.MMFLM86NegPairingFacesAux
import Definitions.MMFLM86NegPairingFaces
import Definitions.MMFLM810BoundaryReduced
import Definitions.MMFLM86NegPairingFinalAux
import Definitions.MMFLM86NegPairingFinal
import Definitions.MMFLM86NegPairingFinalRefute
import Definitions.MMFLM86Display866ThreeAux
import Definitions.MMFLM86Display866ThreeInsert
import Definitions.MMFLM86Display866Three
import Definitions.MMFLM86Corollary851ModeStepProveAux
import Definitions.MMFLM86Corollary851ModeStepProve
import Definitions.MMFLM86Display866SeriesStepAux
import Definitions.MMFLM86Display866SeriesStep
import Definitions.MMFLM86Corollary851ModeStepExistsAux
import Definitions.MMFLM86Corollary851ModeStepExists
import Definitions.MMFLM86NegPairingNonvacAux
import Definitions.MMFLM86NegPairingNonvacAnchor
import Definitions.MMFLM86NegPairingNonvac
import Definitions.MMFLM86ModeFieldCommAux
import Definitions.MMFLM86ModeFieldCommZero
import Definitions.MMFLM86ModeFieldComm
import Definitions.MMFLM86ModeFieldCommAnn
import Definitions.MMFLM86NegPairingBlockProveAux
import Definitions.MMFLM86NegPairingBlockProveAux2
import Definitions.MMFLM86NegPairingBlockProve
import Definitions.MMFLM86ModeFieldCommAnnProveAux
import Definitions.MMFLM86ModeFieldCommAnnProve
import Definitions.MMFLM86NegPairingHonestAux
import Definitions.MMFLM86NegPairingHonestAux2
import Definitions.MMFLM86NegPairingHonest
import Definitions.MMFLM86ResidueInsertion
import Definitions.MMFLM86SpanningLift
import Definitions.MMFLM86NegPairingCoeffGeneralAux
import Definitions.MMFLM86NegPairingCoeffGeneral
import Definitions.MMFLM86FlatBinomial
import Definitions.MMFLM86FlatBinomialApply
import Definitions.MMFLM86Matching8625Aux
import Definitions.MMFLM86Matching8625
import Definitions.MMFLM86NegPairingCoeffAllAux
import Definitions.MMFLM86NegPairingCoeffAll
import Definitions.MMFLM86NegPairingFockStep
import Definitions.MMFLM810BoundaryCorrected
import Definitions.MMFLM86Insertion8625ProveAux
import Definitions.MMFLM86Insertion8625ProveFalsify
import Definitions.MMFLM86Insertion8625Prove
import Definitions.MMFLM810AssemblyAux
import Definitions.MMFLM810Assembly
import Definitions.MMFLM810AssemblySlices
import Definitions.MMFLM810AssemblyGrounded
import Definitions.MMFLM86WindowSync
import Definitions.MMFLM86WindowSyncDelivery
import Definitions.MMFLM86WindowSyncAbsorbed
import Definitions.MMFLM86DisplayPair
import Definitions.MMFLM86SourceBridge
import Definitions.MMFLM810Theorem861Stated
import Definitions.MMFLM88Theorem889Stated
import Challenge

/-! ## Proved: the modular inputs -/

/-- info: 'MM.IsNormalizedHauptmodul.eq_of_qExpansion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IsNormalizedHauptmodul.eq_of_qExpansion

/-- info: 'MM.IsHauptmodul.eq_orbit_of_apply_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IsHauptmodul.eq_orbit_of_apply_eq

/-- info: 'MM.IsHauptmodul.eq_of_qExpansion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IsHauptmodul.eq_of_qExpansion

/-! ### Uniqueness of the normalized Hauptmodul, repaired

`MM.IsNormalizedHauptmodul.eq_of_qExpansion` above takes `IsBoundedAtImInfty f`, which no normalized
Hauptmodul satisfies — the normalization is the `q⁻¹` term, i.e. a pole at `i∞`.
`Definitions/MNHauptmodulUniqueness.lean` supplies the correct statements: the difference of two
functions with the same `q`-expansion is bounded at that cusp because the poles cancel. -/

/-- info: 'MM.eq_of_qExpansion_of_bounded' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.eq_of_qExpansion_of_bounded

/-- info: 'MM.IsAnalyticNormalizedHauptmodul.eq_of_qExpansion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IsAnalyticNormalizedHauptmodul.eq_of_qExpansion

/-- info: 'MM.IsNormalizedHauptmodul.eq_of_qExpansion'' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IsNormalizedHauptmodul.eq_of_qExpansion'

/-- info: 'MM.exists_const_add_of_qExpansion_coeff_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.exists_const_add_of_qExpansion_coeff_eq

/-! ### What `MM.HasQExpansion` cannot see (the residue of D0)

`Definitions/MMQExpansionGap.lean`.  Mathlib's `qExpansion` is a `PowerSeries`, so
`MM.HasQExpansion f a` inspects only the degrees `n : ℕ`.  The consequences are now theorems rather
than an impression: the one-sided condition **does** pin `a.coeff 0` once `f` is periodic and bounded
at the cusp (`MM.coeff_zero_eq_valueAtInfty`), but it can never constrain the negative degrees, so a
series is never determined by it (`MM.not_determined_by_one_sided`) and the `q⁻¹` term of a
normalized series is invisible.  That is why `MM.IsNormalizedHauptmodul` carries no analytic
information about `f`, and why the repairs use `MM.IsAnalyticNormalizedHauptmodul` instead. -/

/-- info: 'MM.coeff_zero_eq_valueAtInfty' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_zero_eq_valueAtInfty

/-- info: 'MM.not_determined_by_one_sided' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.not_determined_by_one_sided

/-! ### The lattice double cover and twisted group ring (the algebraic skeleton of `V_L`)

`Definitions/MMLatticeDoubleCover.lean` builds, for an arbitrary even lattice with an arbitrary
finite ordered basis, the cocycle `ε(x,y) = (-1)^(F(x,y))`, the double cover as a group, and the
twisted group ring on `L →₀ ℤ` with `e^x * e^y = ε(x,y) • e^{x+y}` — proving associativity (the
2-cocycle condition), the commutator relation `ε(x,y)ε(y,x) = (-1)^((x,y))`, and centrality of the
kernel.  `II^{1,1}` is supplied as an instance, with Gram matrix `((0,1),(1,0))`.  This is what the
no-ghost operators `K_i` and the lattice vertex algebra `V_L` are built on. -/

/-- info: 'MM.IntegralLattice.cocycle_cond' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IntegralLattice.cocycle_cond

/-- info: 'MM.IntegralLattice.cocycle_commutator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IntegralLattice.cocycle_commutator

/-- info: 'MM.LatticeDoubleCover.mul_single_single' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeDoubleCover.mul_single_single

/-- info: 'MM.LatticeDoubleCover.basis_mul_comm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeDoubleCover.basis_mul_comm

/-- info: 'MM.II11Gram_det' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.II11Gram_det

/-! ### The extended binary Golay code (Leech milestone M0 + M1a--M1e)

`Definitions/MMGolay.lean` builds the extended binary Golay code from the systematic generator
matrix `[I₁₂ | B]` and proves its finite properties: `4096` words, doubly even, minimum weight `8`,
the weight enumerator `1, 759, 2576, 759, 1`, and self-duality (`G·Gᵀ = 0`, `G.rank = 12`,
`golayCode = dualCode`).  This is the combinatorial input to the Leech lattice construction
`Λ = 2^{-3/2}·A`, where `A` is cut out by integer congruences plus the condition that each mod-4
residue-class word is a Golay codeword.

**The sharp weight statement is `4 ∣ wt`, not `8 ∣ wt`** — the code has `2576` words of weight `12`,
so triple-evenness is false; `golay_doubly_even` is the true divisibility and `golay_weights` records
the exact weight set `{0,8,12,16,24}`.  The twelve generator masks' *provenance* (the length-23
quadratic-residue code plus a parity bit) is not formalized; the properties are re-proved here. -/

/-- info: 'MM.golay_card' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.golay_card

/-- info: 'MM.golay_min_weight' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.golay_min_weight

/-- info: 'MM.golay_weight_enumerator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.golay_weight_enumerator

/-- info: 'MM.golay_self_dual' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.golay_self_dual

/-! ### The Leech carrier and its structure theorem (milestones M2a, M2b, M3)

`Definitions/MMLeech.lean` (carrier and structure theorem) and `Definitions/MMLeechIndex.lean`
(the index).  `MM.IsLeechVec a` is Conway--Sloane's even-coordinate-system condition
on `a : ℤ²⁴` (same parity; `Σa ≡ 4a₀ (mod 8)`; each mod-4 class word a Golay codeword), with a
`Decidable` instance.  The structure theorem classifies membership:

`MM.isLeechVec_iff : IsLeechVec a ↔ IsEvenForm a ∨ IsOddForm a`, where a vector is of even form when
`a = 2·lift d + 4t` with `d` a Golay word and **`Σt` even**, and of odd form when
`a = 1 + 2·lift d + 4t` with **`Σt` odd**.  Together with closure under addition and negation and
`8ℤ²⁴ ⊆ A`, this is what makes `A` a full-rank `ℤ`-submodule.

**The index is proved too (M3b).**  `MM.leech_index : [ℤ²⁴ : A] = 2³⁶`, with `MM.relIndex_sm8_AHat`
(`|A / 8ℤ²⁴| = 2³⁶`), `MM.card_quotient_AHat` (the order of `ℤ²⁴/A`) and `MM.card_image_leech` (the
count: a residue class of `A` mod `8ℤ²⁴` is exactly `key d τ = Στ + 2·lift d + 4τ` with `d` a Golay
codeword and `τ : Idx → ZMod 2`, so there are `4096 · 2²⁴ = 2³⁶` of them).  All four are guarded
below.

**One thing is deliberately still not claimed**: the parity conditions on `Σt` are forced by the
`mod 8` congruence and are **not** in the reconnaissance's recorded shape — its literal form
`x₀ + 2(d + 2t)` with `Σt` even is never in `A`. -/

/-- info: 'MM.isLeechVec_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.isLeechVec_iff

/-- info: 'MM.isLeechVec_add' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.isLeechVec_add

/-- info: 'MM.leech_even_sq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_even_sq

/-- info: 'MM.key_injective_pair' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.key_injective_pair

/-- info: 'MM.card_image_leech' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.card_image_leech

/-- info: 'MM.relIndex_sm8_AHat' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.relIndex_sm8_AHat

/-- info: 'MM.leech_index' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_index

/-! ### The Leech lattice has no roots (milestone M6)

`Definitions/MMLeechMinNorm.lean`: **`MM.leech_min_norm : IsLeechVec a → a ≠ 0 → 32 ≤ ∑ aⱼ²`**,
with `MM.leech_min_norm_attained` exhibiting a witness (`a = x₀ − 4eⱼ`, one coordinate `−3` and the
rest `+1`).  Since the form is `(x,y) = (Σ xᵢyᵢ)/8`, this says `Λ = 2^{-3/2}·A` has **no vector of
norm 1 or 2** and minimum norm `4`: the lattice is rootless.

**This is the arithmetic that forces the moonshine module to use a rootless lattice**: for `V_Λ`
the weight-1 space has dimension `24 + #{λ : λ² = 2}`, and `j − 744 = q⁻¹ + 0 + 196884q + ⋯` has
vanishing `c(0)`, so `#{λ : λ² = 2} = 0`.  The Leech lattice is the unique even unimodular rank-24
lattice with no roots.

Two branches are proved separately: `MM.min_norm_even` and `MM.min_norm_odd`, whose odd branch rests
on the identity `Σb + b·b = 2Z` with `Z := Σⱼ (tⱼ + dⱼ)(1 + 2tⱼ)` — `Z ≥ 0` pointwise because the two
factors always share a sign, and `Z` is odd because `Z ≡ Σt + wt d (mod 2)` with `Σt` odd and
`4 ∣ wt d`. -/

/-- info: 'MM.leech_min_norm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_min_norm

/-- info: 'MM.leech_min_norm_attained' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_min_norm_attained

/-! ### `A` is an integral even lattice with minimum `4` (milestones M4a, M4b)

`Definitions/MMLeechForm.lean`.  `MM.leech_sum_mul_dvd : IsLeechVec a → IsLeechVec b →
8 ∣ ∑ aⱼbⱼ` and `MM.leech_sq_dvd : IsLeechVec a → 8 ∣ ∑ aⱼ²`, with the exact division
`MM.normSq_spec : 8 * normSq a = ∑ aⱼ²`.  So the form `(x,y) = (Σ xᵢyᵢ)/8` is **integral** on `A`,
and with `MM.leech_min_norm` (minimum `32`, i.e. norm `4`) and the index `2³⁶`, `Λ = 2^{-3/2}·A` is
an integral lattice of minimum norm `4` and no roots.

**The input M4a needs is "Golay is doubly even AND closed under addition"** — `4 ∣ wt` applied to
`d`, `e` and `d + e`, the last through `MM.two_dvd_wt_mul`, which supplies "`|c ∩ c'|` even".  `2 ∣ wt`
alone would not suffice, and **neither would M3 without its parity correction**: the two terms
`4·ca·S` and `4·cb·T` are each `4 mod 8` in the odd branch and cancel only via `S ≡ cb`,
`T ≡ ca (mod 2)`.  So integrality independently confirms that the corrected M3 shape is the right
one — an earlier reconnaissance's `x₀ + 2(d + 2t)` with `Σt` even would give `4 mod 8`. -/

/-- info: 'MM.leech_sum_mul_dvd' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_sum_mul_dvd

/-- info: 'MM.leech_sq_dvd' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_sq_dvd

/-- info: 'MM.normSq_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.normSq_spec

/-! ### `A` is unimodular (milestone M5)

`Definitions/MMLeechUnimodular.lean`.  The dual of `A` inside the rational span is
`{x | ∃ y, IsLeechVec y ∧ ∀ j, (y j : ℚ) = 8 * x j}`, i.e. **`A* = (1/8)A`**, equivalently
`MM.isLeechVec_iff_eight_dvd : (∀ a ∈ A, 8 ∣ ∑ aⱼyⱼ) ↔ y ∈ A`.  With `x = y/√8` and `λ = a/√8` one
has `⟨x,λ⟩ = ⟨y,a⟩/8`, so this is **literally `Λ* = Λ`** — `Λ = 2^{-3/2}A` is unimodular.

**The unscaled statement `A* = A` is FALSE**, and the file records why: `x = x₀/4 = (1/4,…,1/4)`
pairs integrally against every `a ∈ A` because `Σⱼ aⱼ ∈ 4ℤ` (it is `0` or `4` mod `8`), yet
`x ∉ A`.  Only the normalization `A* = (1/8)A` is true.  So `8A* = A` is the correct scaling, not a
weakened form of it.

**Not assumed anywhere in this file**: evenness (`16 ∣ ∑ aⱼ²`), which is a separate task; the
docstring says so.  What is landed is integral `+` unimodular `+` rank 24 `+` no roots. -/

/-- info: 'MM.leech_unimodular' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_unimodular

/-- info: 'MM.isLeechVec_iff_eight_dvd' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.isLeechVec_iff_eight_dvd

/-- info: 'MM.leech_dual_eq_eighth' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_dual_eq_eighth

/-! ### `Λ` is an even lattice

`Definitions/MMLeechEven.lean`: `MM.leech_sq_dvd_sixteen : IsLeechVec a → 16 ∣ ∑ aⱼ²` and
`MM.two_dvd_normSq : IsLeechVec a → 2 ∣ normSq a`.  With `normSq a = (∑ aⱼ²)/8` this says every norm
`x·x/8` is an **even** integer — `Λ = 2^{-3/2}·A` is an even lattice, which together with integrality
(M4), unimodularity (M5), rank `24` and no roots (M6) is the Leech lattice.

**Evenness is a consequence of M3's parity correction, not of the Golay code alone.**  The even branch
needs only `4 ∣ wt d`; the odd branch also consumes `Odd (∑t)`.  With `∑t` even one gets
`24 + 8·wt d ≡ 8 (mod 16)`, so `2 ∤ normSq` — witness `a = x₀`, where `∑a² = 24` and `normSq = 3`. -/

/-- info: 'MM.leech_sq_dvd_sixteen' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_sq_dvd_sixteen

/-- info: 'MM.two_dvd_normSq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.two_dvd_normSq

/-! ### The kissing number of the Leech lattice (milestone M7)

`Definitions/MMLeechKissing.lean`: `MM.leech_kissing_number` — the carrier has exactly **`196560`**
vectors of squared length `32`, the minimal ones — together with the classification
`MM.leech_min_iff_shape` and the three family counts `MM.leech_shape44_ncard = 1104`,
`MM.leech_shape28_ncard = 97152`, `MM.leech_shape3_ncard = 98304` (summing to `196560`).

The three families, and the one place the reconnaissance's prose needed correcting:
* `(4,4)`: `1104 = 4·C(24,2)` — the even branch with `wt d = 0`, `a = 4t` with `Σtⱼ² = 2`;
* `(2⁸)`: `97152 = 759·2⁷` — the even branch with `wt d = 8`, `a = 2·1_d − 4·1_u` for `u ⊆ d`, and
  **the `2⁷` is M3's parity condition `Even (Σt)`, i.e. `|u|` even** — not an artefact of subset
  counting.  (An 8-set has `2⁷` even subsets, via `u ↦ u Δ {k₀}`.)
* `(∓3, ±1²³)`: `98304 = 4096·24` — the odd branch, where `a·a = 32 ⟺ Z = 1` for the pointwise
  nonnegative `Z = Σ_k (t_k+d_k)(1+2t_k)`, and the parity hypothesis is **automatic**, so that lemma
  does not assume it.

This is `196560`, the classical Leech kissing number, and it is the **fourth** place M3's parity
correction is load-bearing. -/

/-- info: 'MM.leech_kissing_number' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_kissing_number

/-- info: 'MM.leech_min_iff_shape' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_min_iff_shape

/-! ### The Leech lattice, packaged (milestone M8) — the sequence is closed

`Definitions/MMLeechLattice.lean` assembles M3b--M7 into one object.  The bundle
`MM.LeechLattice` has fields `ASub`, `ASub_eq`, `rank_eq`, `index_eq`, `integral`, `even`, `selfDual`,
`posDef`, `noRoots` — **all five properties filled, none assumed** — and
`MM.leech_lattice_isLeech : MM.LeechLattice` inhabits it.  Also `MM.leech_rank : Module.finrank ℚ
QSpan = 24` (the earlier files had only the index), the pruned enumerator `MM.leechBox` with its
pruning-correctness lemma, and `MM.leechThetaCoeff` with `MM.leechThetaCoeff_zero`.

Two points of honesty, both deliberate:
* **the unimodularity field is `A* = (1/8)A`**, the true form; the docstring states that the unscaled
  `A* = A` is false (`x₀/4`), and no `24 × 24` Gram determinant is computed — `det = 1` is the field
  `index_eq : [ℤ²⁴ : A] = 2³⁶`, since `[ℤ²⁴ : A]² = 8²⁴`.
* **`V_Λ` is not constructed anywhere in this repository**, so the moonshine consequence is stated as
  the arithmetic the future construction consumes — `MM.leechWeightOneDim := 24 + MM.leechCount 2`
  with `MM.leech_weight_one_dim : MM.leechWeightOneDim = 24`, where `MM.leechCount_two : leechCount 2 = 0`
  comes from M6 — and not as a `finrank` of an object that does not exist. -/

/-- info: 'MM.leech_lattice_isLeech' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_lattice_isLeech

/-- info: 'MM.leech_weight_one_dim' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_weight_one_dim

/-- info: 'MM.leech_rank' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leech_rank

/-- info: 'MM.leechCount_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leechCount_two

/-! ### Level one: `j` is invariant and surjective (M1, first increment)

`Definitions/MMLevelOneHauptmodul.lean`.  The paper's own worked example: `j(τ) - 744` is the
normalized Hauptmodul for `SL₂(ℤ)`.  Landed here are two of `MM.IsHauptmodul`'s three conjuncts for
`MM.levelOneJ := E₄³/Δ` on `MM.levelOneGamma := 𝒮ℒ`: **invariance** (`MM.levelOneJ_invariant`) and
**surjectivity** (`MM.levelOneJ_surjective`, inherited from the sibling repository's
`WLight.j_surjective`).

**The third conjunct — orbit separation — is NOT obtained**, and is carried as the explicit
hypothesis `MM.LevelOneOrbitSeparation`; the conditional theorems record exactly what follows from it.
It is the level-one **order-1 valence statement** (`j - c` has exactly one zero on the compactified
quotient), which is in neither Mathlib nor the sibling repository.  **Nothing here should be read as
showing that `SL₂(ℤ)` has genus zero** — `MM.HasGenusZero` is a cardinality condition. -/

/-- info: 'MM.levelOneJ_invariant' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneJ_invariant

/-- info: 'MM.levelOneJ_surjective' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneJ_surjective

/-! ### Level one, second increment: the cusp expansion `j = q⁻¹ + 744 + O(q)` (M1-L1c)

`Definitions/MMLevelOneDiscUnit.lean` and `Definitions/MMLevelOneCusp.lean`.  These discharge the
second hypothesis of the level-one conditional theorems: the coefficient `(qExpansion 1 Δ).coeff 2 =
-24` (with `qExpansion 1 P = MM.levelOneDiscUnit`, where `P` is the Jacobi product `Δ = q·P`), hence
the cusp limit `MM.levelOneJ_cusp_expansion : IsZeroAtImInfty ((j - 744) - q⁻¹)`, i.e. the classical
`j = q⁻¹ + 744 + O(q)`.  The reusable cusp-order lemma
`MM.isBoundedAtImInfty_div_qParam_pow` is guarded too.

**What is still NOT obtained, and is not claimed:** `MM.HasQExpansion ((j-744) - qInv) a` — the
*integrality* of the Fourier coefficients of `j - 744 - q⁻¹`, whose missing Lean step is recorded
verbatim in the footer of `Definitions/MMLevelOneCusp.lean` — and `MM.LevelOneOrbitSeparation`.
The strengthened theorems take both as explicit hypotheses; nothing is weakened and no `sorry` is
hidden. -/

/-- info: 'MM.levelOneDiscUnit_coeff_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneDiscUnit_coeff_one

/-- info: 'MM.qExpansion_discriminant_coeff_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.qExpansion_discriminant_coeff_two

/-- info: 'MM.qExpansion_levelOneDiscTprod' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.qExpansion_levelOneDiscTprod

/-- info: 'MM.isBoundedAtImInfty_div_qParam_pow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.isBoundedAtImInfty_div_qParam_pow

/-- info: 'MM.isBoundedAtImInfty_levelOneCuspNum_div_qParam_sq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.isBoundedAtImInfty_levelOneCuspNum_div_qParam_sq

/-- info: 'MM.levelOneJ_cusp_expansion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneJ_cusp_expansion

/-- info: 'MM.levelOne_hauptmodul_of_orbitSeparation_and_qExpansion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOne_hauptmodul_of_orbitSeparation_and_qExpansion

/-- info: 'MM.levelOne_isAnalyticNormalizedHauptmodul_of_orbitSeparation_and_qExpansion' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOne_isAnalyticNormalizedHauptmodul_of_orbitSeparation_and_qExpansion

/-! ### Level one, third increment: the analytic/formal Jacobi-product comparison (M1-L1f)

`Definitions/MMLevelOneDiscProduct.lean` proves the comparison that the footer of
`Definitions/MMLevelOneCusp.lean` records as the *one* missing step of the level-one story: the
Taylor coefficients at the cusp of the analytic Jacobi product `P = ∏' n, (1 - eta_q n ·)^24` are the
coefficients of the formal product `∏' n, ((1 : ℤ⟦X⟧) - X^(n+1))^24`,
`MM.qExpansion_levelOneDiscTprod_eq_formal`.  Consequently `MM.levelOneDiscUnit_coeff_isInt` gives the
integrality of the unit part of `Δ` (the Δ-side input of `MM.HasQExpansion`), and
`MM.qExpansion_discriminant_eq_X_mul_formal` is the Δ-side statement `qExpansion 1 Δ = X ·(formal
product)`.

This is **integrality of the coefficients of the unit part only**: `MM.HasQExpansion ((j-744) - qInv) a`
is still not obtained, since it also needs the coefficients of `E₄³` and the inversion of `P` as a
unit of `ℤ⟦q⟧`; nothing here is claimed about that.  The route (and a Mathlib fact the brief pointed
at that does not do the job — `PowerSeries.eval₂Hom` needs `IsLinearTopology ℂ ℂ`, which does not
exist) is recorded in the file's header. -/

/-- info: 'MM.qExpansion_levelOneDiscTprod_eq_formal' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.qExpansion_levelOneDiscTprod_eq_formal

/-- info: 'MM.qExpansion_discriminant_eq_X_mul_formal' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.qExpansion_discriminant_eq_X_mul_formal

/-- info: 'MM.iteratedDeriv_discTprodFun' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.iteratedDeriv_discTprodFun

/-- info: 'MM.levelOneDiscUnit_coeff_isInt' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneDiscUnit_coeff_isInt

/-! ### Level one, fourth increment: `hq` is discharged (M1-L1h-CORRECTED)

`Definitions/MMLevelOneJCoeffs.lean` (integral coefficient ladder) and
`Definitions/MMLevelOneHq.lean` (the assembly).  The hypothesis
`hq : MM.HasQExpansion ((j - 744) - q⁻¹) a` of the two theorems at the end of
`Definitions/MMLevelOneCusp.lean` — the **integrality of the Fourier coefficients of
`j - 744 - q⁻¹`** — is now a theorem.

The route is the only one that can work: expand the **analytic** function `(j - 744) - q⁻¹` as a
whole.  Routing through `qExpansion 1 qInv` is impossible, and that is a theorem here rather than an
impression: `cuspFunction 1 qInv` is `q ↦ q⁻¹` only on the punctured neighbourhood of `0`
(`MM.cuspFunction_qInv_eventuallyEq`), the pole has no limit there
(`MM.not_tendsto_inv_nhdsNE_zero`), so the `0`-th coefficient of `qExpansion 1 qInv` is
`Classical.epsilon (fun _ : ℂ => False)` (`MM.qExpansion_qInv_coeff_zero_eq_epsilon`) and
`qExpansion 1 qInv = 0` is **false**, not merely hard.

The coefficients `0`, `196884`, `21493760` (the FLM dimensions `V₀ = 0`, `dim V₁`, `dim V₂`) are
computed from the formal Jacobi product over `ℤ` (`P_Z = 1 - 24q + 252q² - 1472q³ + ⋯`), the
integral `E₄`, and the `invOfUnit` recursion — no enumeration, no analytic input.  The division is
performed in `ℤ⟦q⟧` **before** mapping to `ℂ⟦q⟧`: this pin has no `Inv ℤ⟦X⟧` instance, and
`PowerSeries.inv` returns `0` on a series of vanishing constant term.

`MM.LevelOneOrbitSeparation` is still an explicit hypothesis of the two (T3) theorems below;
nothing here claims level-one orbit separation, and no statement is weakened. -/

/-- info: 'MM.levelOneJCoeffs_coeff_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneJCoeffs_coeff_one

/-- info: 'MM.levelOneJCoeffs_coeff_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneJCoeffs_coeff_two

/-- info: 'MM.qExpansion_levelOneCuspBounded' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.qExpansion_levelOneCuspBounded

/-- info: 'MM.qExpansion_levelOneJ_sub_const_sub_qInv' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.qExpansion_levelOneJ_sub_const_sub_qInv

/-- info: 'MM.levelOneA_coeff_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneA_coeff_one

/-- info: 'MM.levelOneA_coeff_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneA_coeff_two

/-- info: 'MM.levelOneA_isNormalized' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneA_isNormalized

/-- info: 'MM.levelOneA_hasQExpansion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneA_hasQExpansion

/-- info: 'MM.levelOne_hauptmodul_of_orbitSeparation_discharged' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOne_hauptmodul_of_orbitSeparation_discharged

/-- info: 'MM.levelOne_isAnalyticNormalizedHauptmodul_of_orbitSeparation_discharged' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOne_isAnalyticNormalizedHauptmodul_of_orbitSeparation_discharged

/-! ### `Γ₀(N)` as a subgroup of `GL(2, ℝ)`, from the vendored Virasoro tree

`MM` had **no definition of `Γ₀(N)` at all** — it appeared only in prose.  `VirasoroProject.Gamma0GL`
is the image of Mathlib's `CongruenceSubgroup.Gamma0 N ≤ SL(2, ℤ)` under `SL(2, ℤ) → GL(2, ℝ)`.  The
two facts proved about it are the ones the rigidity lemma needs: the translation `T : τ ↦ τ + 1` lies
in it, and therefore **any function invariant under it is `1`-periodic**, which is the hypothesis from
which a `q`-expansion can be read.  This is the missing link between `MM.genusZero_level` (arithmetic
about a definition) and an actual group.

Also guarded here, from the same vendored tree, is the `c = 1` bosonic Sugawara construction: an
arbitrary locally-truncated Heisenberg representation gives a Virasoro representation of central
charge `1` (`sugawaraRepresentation_cgen`), together with the Witt algebra bracket, the Virasoro
2-cocycle and the central-extension property.  **It is central charge `1`, and moonshine needs
`24`** — see the ROADMAP: `c` is pinned to `24` and the only freedom is the rank of the Lorentzian
lattice, so this layer must be tensored up and that tensor layer does not exist. -/

/-- info: 'VirasoroProject.T_mem_Gamma0GL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms VirasoroProject.T_mem_Gamma0GL

/-- info: 'VirasoroProject.periodic_of_invariant_Gamma0GL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms VirasoroProject.periodic_of_invariant_Gamma0GL

/-- info: 'VirasoroProject.sugawaraRepresentation_cgen' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms VirasoroProject.sugawaraRepresentation_cgen

/-- info: 'VirasoroProject.VirasoroAlgebra.lgen_bracket' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms VirasoroProject.VirasoroAlgebra.lgen_bracket

/-! ### Diagnosis: `IsHauptmodul` has no analytic content

`Definitions/MMGenusZeroRefute.lean` proves that the `∃ f` repair of `HasGenusZero` is *equivalent*
to `HasGenusZero` with no hypotheses — `isHauptmodul_comp_orbitMk` is the general form of the
defect, and `not_hasGenusZeroFun_top` shows the predicate is not literally `True`, so the
equivalence says something.  These are guarded so that the *defect* is machine-checked rather than
described; see the README's defect block. -/

/-- info: 'MM.isHauptmodul_comp_orbitMk' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.isHauptmodul_comp_orbitMk

/-- info: 'MM.not_forall_isHauptmodul_comp_orbitMk_injective' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.not_forall_isHauptmodul_comp_orbitMk_injective

/-- info: 'MM.hasGenusZeroFun_iff_hasGenusZero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.hasGenusZeroFun_iff_hasGenusZero

/-- info: 'MM.not_hasGenusZeroFun_top' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.not_hasGenusZeroFun_top

/-! ### The arithmetic genus formula at the Conway--Norton levels

`Definitions/MMGenusZeroArith.lean` evaluates the arithmetic of the genus formula for `X₀(N)` at
the 15 Conway--Norton levels, and at `11`.  **This is arithmetic about a definition**: it does not
assert that `Γ₀(N)` has genus zero, and the identification "this formula = the genus of `X₀(N)`" is
the entire geometric content and is not formalized here.  See the file's docstring. -/

/-- info: 'MM.genusZero_level' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.genusZero_level

/-- info: 'MM.genusFormula_eleven' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.genusFormula_eleven

/-! ### The analytic Hauptmodul predicate, and what it does *not* give

`Definitions/MMHauptmodulAnalytic.lean` supplies the analytic content `MM.IsHauptmodul` lacks, and
`Definitions/MMHauptmodulAnalyticRefute.lean` proves that **neither** analytic predicate implies
surjectivity on its own — so the two positive theorems below are honestly conditional, and the
refutations are guarded alongside them.  In particular `toIsHauptmodul` carries `HasPoleAtCusp` (the
paper's "takes `i∞` to `∞`") and orbit separation as explicit hypotheses; there is no unconditional
implication in this Mathlib. -/

/-- info: 'MM.IsHauptmodulAnalytic.surjective_of_hasPoleAtCusp' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IsHauptmodulAnalytic.surjective_of_hasPoleAtCusp

/-- info: 'MM.IsHauptmodulAnalytic.toIsHauptmodul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IsHauptmodulAnalytic.toIsHauptmodul

/-- info: 'MM.not_forall_isHauptmodulAnalytic_surjective' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.not_forall_isHauptmodulAnalytic_surjective

/-- info: 'MM.not_forall_isHauptmodulAnalyticWeak_surjective' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.not_forall_isHauptmodulAnalyticWeak_surjective

-- Three more from the same file: the pole condition alone is not enough either, and the predicate is
-- neither vacuous nor satisfied by the coordinate function.

/-- info: 'MM.not_forall_hasPoleAtCusp_surjective' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.not_forall_hasPoleAtCusp_surjective

/-- info: 'MM.isHauptmodulAnalytic_bot_exp' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.isHauptmodulAnalytic_bot_exp

/-- info: 'MM.not_isHauptmodulAnalytic_bot_coe' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.not_isHauptmodulAnalytic_bot_coe

/-! ## Proved: the geometric series and the T1b derivative route -/

/-- info: 'MM.GeomSeries.altQ_mul_one_add_X' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.GeomSeries.altQ_mul_one_add_X

/-- info: 'MM.GeomSeries.altQ_eq_inv' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.GeomSeries.altQ_eq_inv

/-- info: 'MM.deriv_log_eq_inv' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.deriv_log_eq_inv

/-- info: 'MM.derivative_logOf_mul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.derivative_logOf_mul

/-- info: 'MM.constantCoeff_expOp_logOf' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.constantCoeff_expOp_logOf

/-- info: 'MM.subst_inv_one_add_X' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.subst_inv_one_add_X

/-! ### T1b is closed: the composition law `exp ∘ logOf f = f`

`MM.expOp_logOf_eq` is the theorem task T1b asked for, and `MM.eq_zero_of_derivative_eq_mul` is the
uniqueness step it rests on.  `MM.expOp_logOf_holds` is the bridge from the `Prop`-valued
`MM.expOp_logOf` of `Definitions/MMPowerSeries.lean` to that theorem, and
`MM.seriesIdentity_of_adamsLogIsLog` is the paper's identity with T1b discharged — it now rests on
`MM.AdamsLogIsLog` (task T2) and the constant-term hypothesis alone.  **That route is now known to be
uninstantiable as recorded**: `Definitions/MMLogCoeff.lean` proves `MM.AdamsLogIsLog` false as a
general identity and identifies the real obstruction — the paper's (8.3) has a **two-sided** `q`-side
(`p·(T_g(p) − T_g(q))` contains `−p·q⁻¹`), while `MM.EulerSeries` is one-sided and truncated.  See
the guards below. -/

/-- info: 'MM.eq_zero_of_derivative_eq_mul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.eq_zero_of_derivative_eq_mul

/-- info: 'MM.expOp_logOf_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.expOp_logOf_eq

/-- info: 'MM.expOp_logOf_holds' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.expOp_logOf_holds

/-- info: 'MM.seriesIdentity_of_adamsLogIsLog' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.seriesIdentity_of_adamsLogIsLog

/-! ### T2 pre-work: `coeff_logOf`, and the refutation of `MM.AdamsLogIsLog`

`Definitions/MMLogCoeff.lean`.  Three things, all proved: the coefficient formula for
`PowerSeries.logOf` that Mathlib lacked (`MM.coeff_logOf`, the decisive step the T2 entry asked
for); the coefficient-level reduction of `MM.AdamsLogIsLog` to an explicit per-degree equality
(`MM.adamsLogIsLog_iff`); and the refutation of that `Prop` as a general identity
(`MM.not_adamsLogIsLog`, at the coefficient of `p²`).

**Scope, recorded because it matters:** the counterexample is *not* `MM.IsReplicable`, so whether
replicability implies the `Prop` is not settled — and, on the primary source, the shape is not
refuted either: (8.3) needs a **two-sided** `q`-series (the same object task D0 records as missing),
not a hypothesis on `c`.  `MM.constantCoeff_one_add_eulerSeries_ne_one` is the separate `m = 0`
artefact of `MM.EulerSeries`. -/

/-- info: 'MM.coeff_logOf' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_logOf

/-- info: 'MM.adamsLogIsLog_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.adamsLogIsLog_iff

/-- info: 'MM.constantCoeff_one_add_eulerSeries_ne_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.constantCoeff_one_add_eulerSeries_ne_one

/-- info: 'MM.adamsLog_counterCoeff_coeff_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.adamsLog_counterCoeff_coeff_two

/-- info: 'MM.logOf_counterCoeff_coeff_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.logOf_counterCoeff_coeff_two

/-- info: 'MM.not_adamsLogIsLog' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.not_adamsLogIsLog

/-! ### D0/T2: the two-sided `q`-expansion, and the level-one instance

`Definitions/MMQExpansionTwoSided.lean` and `Definitions/MMQExpansionTwoSidedLevelOne.lean`.
`MM.HasQExpansion` cannot see negative degrees (`MM.not_determined_by_one_sided`), so the `q⁻¹` term
of a normalized series was invisible; `MM.HasLaurentQExpansion` writes the pole term out as
`f = a.coeff (-1) * qInv + g` with `g` bounded, and then the series is **determined** by `f`
(`MM.HasLaurentQExpansion.eq`) — the repair.  Normalization becomes a property of `f`
(`…isBoundedAtImInfty_sub_qInv`, and conversely `…coeff_neg_one_eq_one_of_isBoundedAtImInfty_sub_qInv`),
and `MM.isNormalizedLaurentSeries_iff` identifies the new normalization with `MM.IsNormalizedSeries`
on integer coefficients.

**THE TWO ITEMS THIS BOX USED TO LEAVE OPEN ARE CLOSED (task D0-iii).**
`Definitions/MMLevelOneLaurentIntegral.lean` proves `MM.levelOneLaurentSeries_eq_map_levelOneA`:
the complex two-sided expansion of `j - 744` **is** the image of the integral series `MM.levelOneA`
under `Int.castRingHom ℂ` — so the coefficients are integers (`q⁻¹ = 1`, `q⁰ = 0`, `q¹ = 196884`,
`q² = 21493760`), and by `MM.HasLaurentQExpansion.eq` that image is the **only** two-sided expansion
of `j - 744`, so the integrality is forced rather than merely witnessed.  The stale footer of
`Definitions/MMLevelOneCusp.lean` saying the step is missing is superseded by
`Definitions/MMLevelOneHq.lean`'s `MM.levelOneA_hasQExpansion`, which is the whole input used.
`Definitions/MMHauptmodulTwoSided.lean` proves the predicate of `MM.MoonshineModule`'s `hauptmodul`
field and the two-sided one **equivalent** — `MM.isAnalyticNormalizedHauptmodul_iff_hasLaurentQExpansion`
(carrier `b.coeff 0 = 0`) and `…_and_cusp` (carrier `IsZeroAtImInfty (f - qInv)`), both taking the
periodicity and holomorphy of `f` that `MM.IsAnalyticNormalizedHauptmodul` itself does not carry.
So the pending rewiring of the field onto the two-sided predicate is a definitional swap, not a
change of statement.

**Still not claimed:** (8.3) itself, which needs the `p`-side comparison of task T2. -/

/-- info: 'MM.not_isBoundedAtImInfty_const_mul_qInv' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.not_isBoundedAtImInfty_const_mul_qInv

/-- info: 'MM.HasLaurentQExpansion.coeff_neg_one_unique' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.HasLaurentQExpansion.coeff_neg_one_unique

/-- info: 'MM.HasLaurentQExpansion.eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.HasLaurentQExpansion.eq

/-- info: 'MM.HasLaurentQExpansion.isBoundedAtImInfty_sub_qInv' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.HasLaurentQExpansion.isBoundedAtImInfty_sub_qInv

/-- info: 'MM.HasLaurentQExpansion.coeff_neg_one_eq_one_of_isBoundedAtImInfty_sub_qInv' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.HasLaurentQExpansion.coeff_neg_one_eq_one_of_isBoundedAtImInfty_sub_qInv

/-- info: 'MM.isNormalizedLaurentSeries_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.isNormalizedLaurentSeries_iff

/-- info: 'MM.HasLaurentQExpansion.hasQExpansion_of_map' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.HasLaurentQExpansion.hasQExpansion_of_map

/-- info: 'MM.levelOneLaurentSeries_isNormalized' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneLaurentSeries_isNormalized

/-- info: 'MM.levelOneLaurentSeries_coeff_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneLaurentSeries_coeff_zero

/-- info: 'MM.levelOneJ_sub_hasLaurentQExpansion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneJ_sub_hasLaurentQExpansion

/-! ### D0-iii: the integrality of the level-one two-sided expansion, and the equivalence of the two
predicates

`Definitions/MMLevelOneLaurentIntegral.lean` (the complex two-sided expansion of `j - 744` **is** the
image of the integral series `MM.levelOneA`) and `Definitions/MMHauptmodulTwoSided.lean` (the
predicate of the `hauptmodul` field and the two-sided predicate are equivalent, given periodicity and
holomorphy of `f`).  Both are new files written by a task agent and rebuilt, re-read and guarded here
by the dispatcher; the guards below are the dispatcher's own probe, not the author's. -/

/-- info: 'MM.levelOneLaurentSeries_eq_map_levelOneA' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneLaurentSeries_eq_map_levelOneA

/-- info: 'MM.levelOneJ_sub_hasLaurentQExpansion_int' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneJ_sub_hasLaurentQExpansion_int

/-- info: 'MM.hasLaurentQExpansion_eq_map_levelOneA' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.hasLaurentQExpansion_eq_map_levelOneA

/-- info: 'MM.levelOneLaurentSeries_coeff_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneLaurentSeries_coeff_one

/-- info: 'MM.levelOneLaurentSeries_coeff_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneLaurentSeries_coeff_two

/-- info: 'MM.HasLaurentQExpansion.isZeroAtImInfty_sub_qInv_of_coeff_zero' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.HasLaurentQExpansion.isZeroAtImInfty_sub_qInv_of_coeff_zero

/-- info: 'MM.HasLaurentQExpansion.coeff_zero_eq_zero_of_isZeroAtImInfty_sub_qInv' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.HasLaurentQExpansion.coeff_zero_eq_zero_of_isZeroAtImInfty_sub_qInv

/-- info: 'MM.IsAnalyticNormalizedHauptmodul.toHasLaurentQExpansion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IsAnalyticNormalizedHauptmodul.toHasLaurentQExpansion

/-- info: 'MM.HasLaurentQExpansion.toIsAnalyticNormalizedHauptmodul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.HasLaurentQExpansion.toIsAnalyticNormalizedHauptmodul

/-- info: 'MM.isAnalyticNormalizedHauptmodul_iff_hasLaurentQExpansion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.isAnalyticNormalizedHauptmodul_iff_hasLaurentQExpansion

/-- info: 'MM.isAnalyticNormalizedHauptmodul_iff_hasLaurentQExpansion_and_cusp' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.isAnalyticNormalizedHauptmodul_iff_hasLaurentQExpansion_and_cusp

/-! ### D0-e/D0-g: the genus-zero hypothesis stated non-vacuously, and the headline re-pointed

`Definitions/MMGenusZeroGroup.lean` (the predicate, task D0-g moved it there so that
`Definitions/MMMoonshine.lean` can import it) and `Definitions/MMGenusZeroStatement.lean` (the
independence theorems and the strengthened conjecture as a `Prop`).  `MM.HasGenusZero Γ` is
`Nonempty (ℍ/Γ ≃ ℂ)` — a cardinality condition — so the moonshine conjecture as phrased did not
require `Γ` to have genus zero.  `MM.IsGenusZeroGroup Γ` adds the **compactness** input
(`MM.HasBoundedInvariantConst Γ`) and an analytic Hauptmodul with a pole at the cusp, keeping the
cardinality conjunct; `MM.MoonshineModule.MoonshineConjectureStatementGenus` is the conjecture in
that form and is now **what the `sorry` marks** (task D0-g), with the pre-repair
`MoonshineConjectureStatement` kept and *proved* to follow from it
(`MM.MoonshineModule.moonshineConjectureStatement_of_genus`), so nothing is lost.
**Neither conjunct is decoration**: `MM.hasGenusZero_not_isGenusZeroGroup_bot` (cardinality holds at
`⊥`, compactness fails there) and `MM.hasBoundedInvariantConst_top` with `MM.not_hasGenusZero_top`.
**The hypothesis is known satisfiable**: `MM.levelOne_isGenusZeroGroup` proves it for `𝒮ℒ` (task
D0-f), which is what unblocked the re-pointing.  **Not claimed:** an inhabitant for any other `Γ`,
or orbit separation. -/

/-- info: 'MM.IsGenusZeroGroup.hasGenusZero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IsGenusZeroGroup.hasGenusZero

/-- info: 'MM.IsGenusZeroGroup.hasBoundedInvariantConst' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IsGenusZeroGroup.hasBoundedInvariantConst

/-- info: 'MM.IsGenusZeroGroup.exists_hauptmodulAnalytic' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IsGenusZeroGroup.exists_hauptmodulAnalytic

/-- info: 'MM.IsGenusZeroGroup.exists_isHauptmodul_of_orbitSeparation' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IsGenusZeroGroup.exists_isHauptmodul_of_orbitSeparation

/-- info: 'MM.moonshineConjectureStatement_of_genus' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.moonshineConjectureStatement_of_genus

/-- info: 'MM.hasGenusZero_bot' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.hasGenusZero_bot

/-- info: 'MM.not_hasBoundedInvariantConst_bot' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.not_hasBoundedInvariantConst_bot

/-- info: 'MM.hasGenusZero_not_isGenusZeroGroup_bot' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.hasGenusZero_not_isGenusZeroGroup_bot

/-- info: 'MM.hasBoundedInvariantConst_top' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.hasBoundedInvariantConst_top

/-- info: 'MM.not_hasGenusZero_top' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.not_hasGenusZero_top

/-! ### D0-f: the first inhabitant of `MM.IsGenusZeroGroup` (level one)

`Definitions/MMLevelOneGenusZero.lean`.  `MM.levelOne_isGenusZeroGroup : IsGenusZeroGroup MM.levelOneGamma`,
so the strengthened hypothesis is known-satisfiable in at least one case.  Each conjunct has real
content: compactness is Mathlib's level-one weight-zero rigidity, applied to a function packaged as a
`ModularForm 𝒮ℒ 0`; the pole at the cusp is an epsilon bound from `MM.levelOneJ_cusp_expansion`; the
analytic Hauptmodul's third conjunct is the constancy argument (not pointwise non-differentiability,
since `(0 : ℂ)⁻¹ = 0`); and `MM.hasGenusZero_levelOneGamma` is a cardinality argument using the
fundamental domain's imaginary axis for the lower bound.  **Not claimed:** nothing about `Γ₀(N)`,
orbit separation for `𝒮ℒ` is still open, and `MM.HasGenusZero` remains a cardinality condition. -/

/-- info: 'MM.levelOne_hasBoundedInvariantConst' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOne_hasBoundedInvariantConst

/-- info: 'MM.levelOne_hasPoleAtCusp' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOne_hasPoleAtCusp

/-- info: 'MM.levelOne_isHauptmodulAnalytic' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOne_isHauptmodulAnalytic

/-- info: 'MM.orbitMk_injective_fdAxis' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.orbitMk_injective_fdAxis

/-- info: 'MM.hasGenusZero_levelOneGamma' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.hasGenusZero_levelOneGamma

/-- info: 'MM.levelOne_isGenusZeroGroup' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOne_isGenusZeroGroup

/-! ## Proved: the moonshine statement for a given module, and its uniqueness half -/

/-- info: 'MM.MoonshineModule.moonshine_uniqueness' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.moonshine_uniqueness

/-- info: 'MM.MoonshineModule.moonshine_existence_for_fixed_module' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.moonshine_existence_for_fixed_module

-- Not guarded: this name is long enough that `#print axioms` wraps its output, which `#guard_msgs`
-- would then have to reproduce line for line.  What it shows is that the goal is non-vacuous.
-- It depends on `sorryAx` only through its hypothesis `MM.MoonshineModule.MoonshineConjectureStatement`.
#print axioms MM.MoonshineModule.MoonshineConjectureStatement.genusZero_exists

/-! ### D0-g: the headline re-pointed at the honest genus-zero hypothesis

`Definitions/MMMoonshine.lean` now assumes `MM.IsGenusZeroGroup Γ` in the structure's `hauptmodul`
field and concludes `MM.MoonshineModule.MoonshineConjectureStatementGenus`, which is what the
standing `sorry` marks.  The pre-repair shape is kept and *proved* to follow
(`MM.MoonshineModule.moonshineConjectureStatement_of_genus`), the two spellings of the strengthened
statement are proved equivalent (`MM.moonshineConjectureStatementGenus_iff`), and the new headline's
non-vacuity is itself a theorem: `…MoonshineConjectureStatementGenus.genusZero_exists` says the goal
yields `IsGenusZeroGroup` — genus zero in the honest sense — for every element, where the pre-repair
statement yielded only the cardinality condition. -/

/-- info: 'MM.MoonshineModule.moonshineConjectureStatement_of_genus' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.moonshineConjectureStatement_of_genus

/-- info: 'MM.moonshineConjectureStatementGenus_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.moonshineConjectureStatementGenus_iff

/-- info: 'MM.MoonshineModule.MoonshineConjectureStatementGenus.genusZero_exists' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.MoonshineConjectureStatementGenus.genusZero_exists

/-! ### T2-ii: the paper's (8.3), faithfully stated, and its coefficient reduction

`Definitions/MMDenominatorIdentity.lean`.  The paper's (8.3) has a **two-sided** `q`-side and its
right-hand side after multiplying through by `p` is `[p⁰] = c(g,-1)`, `[p¹] = c(g,0) − T_g`,
`[p^k] = c(g,k−1)` for `k ≥ 2` — which is what makes the earlier one-sided `MM.AdamsLogIsLog` the
wrong target (refuted in `Definitions/MMLogCoeff.lean`).  `MM.DenominatorIdentity` is the faithful
`Prop`; `MM.DenominatorIdentity.iff_coeff` reduces it to explicit per-degree equalities;
`MM.DenominatorIdentity.coeff_zero` *derives* the normalization `c(g,-1) = 1` from it, and
`MM.DenominatorIdentity.coeff_one` derives `c(g,0) = 0` (the FLM fact `V_0 = 0`).

**Not proved:** `DenominatorIdentity` itself — that is the paper's sections 6--8, i.e. what task T2
now is.  The `p²`/`p⁴` comparisons are the paper's recursion (9.1) = task T3, and the Möbius
inversion (10.4) is a *definition* of `mult`, not a coefficient of (8.3). -/

/-- info: 'MM.coeff_adamsLogTwoSided_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_adamsLogTwoSided_one

/-- info: 'MM.coeff_moonshineRHS_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_moonshineRHS_one

/-- info: 'MM.coeff_expOp_succ' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_expOp_succ

/-- info: 'MM.DenominatorIdentity.coeff_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.DenominatorIdentity.coeff_zero

/-- info: 'MM.DenominatorIdentity.iff_coeff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.DenominatorIdentity.iff_coeff

/-- info: 'MM.DenominatorIdentity.coeff_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.DenominatorIdentity.coeff_one

/-! ### T2a: the Möbius inversion of section 10, proved

`Definitions/MMRootMultiplicity.lean` (+ `Definitions/MMRootMultiplicityArith.lean`).  The paper's
(10.3) ⇒ (10.4) is a theorem now, not the `Prop` the earlier version of the file carried:
`MM.moebiusSum_adamsSum` inverts the `p`-grading — `adamsSum B k = Σ_{i | k} B (k/i)/i` is the
`p^k`-block of (10.3), and its inverse is `B k = Σ_{i | k} (μ i / i) · adamsSum B (k/i)`, the
coefficient form of `mult(m,n) = Σ_{ds | (m,n)} (μ(s)/(ds)) Tr(g^d|V_{mn/d²s²})`.
`MM.moebiusSum_adamsSum_holds` keeps the old name, now a theorem of the same statement.

This is coefficientwise divisor arithmetic (formulation (b) of the task brief): no series occurs,
so nothing here is a claim about `MM.adamsLog`, `MM.EulerSeries` or `MM.DenominatorIdentity`.  The
(10.4) ⇒ (10.5) step is proved too: the block `d * s = k` vanishes unless `k | N` when the trace
depends only on `(d,N) = gcd d N` (`MM.moebiusBlock_eq_zero_of_not_dvd`, the paper's own sentence),
so the range `d * s | (m,n)` may be replaced by `d * s | (m,n,N)` (`MM.multSum_restrict`). -/

/-- info: 'MM.moebiusSum_adamsSum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.moebiusSum_adamsSum

/-- info: 'MM.moebiusSum_adamsSum_holds' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.moebiusSum_adamsSum_holds

/-- info: 'MM.sum_moebius_divisors' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.sum_moebius_divisors

/-- info: 'MM.sum_divisors_filter_dvd_moebius' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.sum_divisors_filter_dvd_moebius

/-- info: 'MM.moebiusBlock_eq_zero_of_not_dvd' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.moebiusBlock_eq_zero_of_not_dvd

/-- info: 'MM.multSum_restrict' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.multSum_restrict

/-! ### S4: the headline can name the monster

`Definitions/MMMonsterMoonshine.lean`.  `MM.MoonshineModule.IsMonsterModule M` is
`Nonempty (M.G ≃* MM.Monster)` — until this existed, nothing in the structure tied the abstract group
`M.G` to the Fischer--Griess group, so the headline said only "there is a group with a module".
`MM.MoonshineModule.reindex` transports a whole `MoonshineModule` along a group isomorphism (graded
pieces, actions, traces, `replication` through `map_pow`), so `IsMonsterModule` is a property of the
**isomorphism class**, and `MM.MoonshineModule.MoonshineConjectureStatementMonster` is the headline in
that form, reducing to the genus statement and thence to the pre-repair one.  **Since task S4b the
standing goal is typed at it**: `MM.MoonshineModule.moonshine_conjecture :
MoonshineConjectureStatementMonster`, so the theorem the repository states is now about
`MM.Monster`.  **Not bought:** no
finiteness, order or non-triviality of `MM.Monster` (task S3), and no formalized identification with
Griess's group — that is the cited Norton--Ivanov theorem. -/

/-- info: 'MM.MoonshineModule.isMonsterModule_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.isMonsterModule_iff

/-- info: 'MM.MoonshineModule.IsMonsterModule.congr' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.IsMonsterModule.congr

/-- info: 'MM.MoonshineModule.isMonsterModule_reindex' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.isMonsterModule_reindex

/-- info: 'MM.MoonshineModule.reindex' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.reindex

/-- info: 'MM.MoonshineModule.moonshineConjectureStatement_of_monster' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.moonshineConjectureStatement_of_monster

/-- info: 'MM.MoonshineModule.moonshineConjectureStatementGenus_of_monster' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.moonshineConjectureStatementGenus_of_monster

/-- info: 'MM.MoonshineModule.MoonshineConjectureStatementMonster.monster_group' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.MoonshineConjectureStatementMonster.monster_group

/-- info: 'MM.MoonshineModule.MoonshineConjectureStatementMonster.exists_module' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.MoonshineConjectureStatementMonster.exists_module

/-- info: 'MM.MoonshineModule.MoonshineConjectureStatementMonster.exists_module_literal' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.MoonshineConjectureStatementMonster.exists_module_literal

/-! ### T3, first step: the `p²` comparison of (8.3)

`Definitions/MMReplicationRecursion.lean`.  `MM.coeff_expOp_two` is the general `p²` coefficient of
`expOp`, and `MM.DenominatorIdentity.pTwo` equates it with `c(g,1)` — the paper's comparison at `p²`,
from which its formulas (9.1) for `c_g(4k)` and `c_g(4k+2)` are read off at `q^{2k}` and `q^{2k+1}`
(the file header records the exact remaining bookkeeping: the `HahnSeries` convolution extraction and
the truncation hypotheses).  **Conditional on `MM.DenominatorIdentity`**, which is not proved — that is
the paper's sections 6--8, i.e. task T2. -/

/-- info: 'MM.coeff_expOp_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_expOp_two

/-- info: 'MM.DenominatorIdentity.pTwo' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.DenominatorIdentity.pTwo

/-- info: 'MM.DenominatorIdentity.pTwo_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.DenominatorIdentity.pTwo_apply

/-! ### T3, second step: the paper's formulas (9.1) for `c_g(4k)` and `c_g(4k+2)`

`Definitions/MMReplicationFormulas.lean`.  **`MM.DenominatorIdentity.cg_four_mul`** and
**`MM.DenominatorIdentity.cg_four_mul_add_two`** are the paper's first and third recursion formulas,
verbatim at its own ranges and its `k ≥ 1`.  The hypotheses the paper leaves implicit are explicit: the
FLM grading `c(g,n) = 0` for `n < −1` (which is *not* derivable from `MM.FiniteSupportCoeff`, and is
what confines the convolution to the paper's finite ranges), `c(g,0) = 0`, and the truncation bound;
`c(g,-1) = 1` is *derived* from (8.3) via `MM.DenominatorIdentity.coeff_zero`, not assumed.  Everything
is conditional on `MM.DenominatorIdentity` (unproved; task T2).  The file header names exactly what is
not there: the `p⁴` comparison (which yields the second and fourth formulas — the alternating sums come
from its cross terms) and the determination theorem. -/

/-- info: 'MM.coeff_adamsLogTwoSided_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_adamsLogTwoSided_two

/-- info: 'MM.coeff_sq_two_mul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_sq_two_mul

/-- info: 'MM.sum_Icc_collapse' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.sum_Icc_collapse

/-- info: 'MM.sum_Icc_pair_even' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.sum_Icc_pair_even

/-- info: 'MM.DenominatorIdentity.cg_four_mul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.DenominatorIdentity.cg_four_mul

/-- info: 'MM.DenominatorIdentity.cg_four_mul_add_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.DenominatorIdentity.cg_four_mul_add_two

/-! ### T3, third step: the `p⁴` comparison, and a correction to the extracted formula 2

`Definitions/MMReplicationFormulasOdd.lean`.  `MM.coeff_expOp_four` is the general `p⁴` coefficient of
the exponential (`f₄ + f₁f₃ + ½f₂² + ½f₁²f₂ + (1/24)f₁⁴` for `constantCoeff f = 0`), `MM.DenominatorIdentity.pFour`
is the comparison at `p⁴` (`−L₄ + L₁L₃ + ½L₂² − ½L₁²L₂ + (1/24)L₁⁴ = single 0 (c g 3)`), with `…pFour_apply`
its coefficientwise form — everything conditional on `MM.DenominatorIdentity`.

**The paper's second formula, as extracted, is false at `k = 1`**: the paper says the recursion
degenerates there (`c_g(5) = c_g(5)`), but the extracted sign gives `c_g(5) + c_g(2)²`.  With
`(cg2(2k) − cg(2k)²)/2` in place of the first square term it degenerates exactly and holds at
`k = 2, 3` against the true `j`-coefficients (checked independently by the dispatcher).  The correction
is **recorded, not applied** — formulas 2 and 4 are not stated here, because the previous round found
that they cannot both come from a coefficient comparison of `exp(−L) = p(T(p) − T(q))` (the alternating
sums `Σ(−1)^j` have no source in such a comparison; they suggest the reciprocal/product form) — and that
provenance must be settled before those formulas are formalized. -/

/-- info: 'MM.coeff_expOp_four' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_expOp_four

/-- info: 'MM.DenominatorIdentity.pFour' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.DenominatorIdentity.pFour

/-- info: 'MM.DenominatorIdentity.pFour_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.DenominatorIdentity.pFour_apply

/-- info: 'MM.coeff_cube_four' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_cube_four

/-! ### T3d/T3e: the `p³` comparison, and the refutation of the route to formulas 2 and 4

`Definitions/MMReplicationPThree.lean` lands the comparison at `p³` (the first in which `c(g,4k+1)` and
`c(g,4k+3)` appear), and `Definitions/MMReplicationFormulaTargets.lean` records the paper's formulas 2
and 4 as **`Prop`-valued targets** — the `MM.AdamsLogIsLog` pattern — rather than as theorems, because
task T3e refuted the derivation: formulas 2 and 4 lie in **no** linear combination of the coefficient
relations of (8.3), not with the reciprocal presentation, not with products of relations, and — tested by
the dispatcher — not with (8.3) adjoined for `g, g², g³, g⁴` nor with the replicability relations.  The
formulas themselves are true (checked at `k = 1…5` against `j` recomputed from `E₄` and `Δ`), and
formula 2 carries the sign correction recorded in `Definitions/MMReplicationFormulasOdd.lean`.  Formulas
1 and 3 remain theorems (`Definitions/MMReplicationFormulas.lean`). -/

/-! ### T3, fourth step: the `p³` comparison, and where formulas 2 and 4 really come from

`Definitions/MMReplicationPThree.lean`.  `MM.coeff_expOp_three` is the general `p³` coefficient of the
exponential and `MM.DenominatorIdentity.pThree` is the comparison there
(`−L₃ + L₁L₂ − (1/6)L₁³ = single 0 (c g 2)`), with `…pThree_apply` its coefficientwise form — everything
conditional on `MM.DenominatorIdentity`.

**The provenance of the paper's four formulas is now settled, by exact symbolic computation rather than
by reading the prose** (task T3d): the `p²` comparison at `q^{2k+1}` is *minus* formula 3, so at odd
degrees it carries no new information; `c(g,4k+1)` and `c(g,4k+3)` do **not** occur in the `p²`
comparison at `q^{4k+1}`, `q^{4k+3}` at all, so formulas 2 and 4 cannot come from `p²` — which is why
the earlier `p⁴` route failed; they **first appear at the `p³` comparison**, i.e. at the paper's `p²`
once the `p⁻¹` shift is accounted for (the trap in its sentence about `p²` and `p⁴`); and **no single
comparison is the formula** — the `p³` comparison carries extra terms (`c(3N)` from `L₃ = E₃ + ⅓ψ³E₁`)
whose elimination by the other formulas is the paper's "elementary algebra", and is where both the
alternating sums and the formula-2 sign correction come from. -/

/-- info: 'MM.coeff_expOp_three' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_expOp_three

/-- info: 'MM.coeff_cube_three' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_cube_three

/-- info: 'MM.DenominatorIdentity.pThree' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.DenominatorIdentity.pThree

/-! ### M1-L1d: the formal Jacobi product over `ℤ` (the first half of the integrality gap)

`Definitions/MMLevelOneIntegrality.lean`.  `MM.formalDiscTprod` is the formal product
`∏' n, (1 - X^(n+1))^24` over `ℤ`, `MM.multipliable_formalDiscPow` proves the family is multipliable in
`ℤ⟦X⟧` (from the geometric-sum factorisation and Mathlib's order criterion), and
`MM.formalDiscTprod_coeff_isInt` gives the integrality `MM.HasQExpansion` consumes, in exactly its shape.

**What is NOT there, and the file says so:** the comparison with the analytic side,
`qExpansion 1 levelOneDiscTprod = PowerSeries.map (Int.castRingHom ℂ) formalDiscTprod` — the half that
would let `hq` be discharged.  It splits into a formal stabilisation lemma (the coefficients of the
tprod equal those of the truncation at `N+1`) and the analytic half (the Taylor coefficients of the
analytic product), the latter being the expensive part; the route for both is in that file's header. -/

/-- info: 'MM.multipliable_formalDiscPow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.multipliable_formalDiscPow

/-- info: 'MM.formalDiscTprod_coeff_isInt' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.formalDiscTprod_coeff_isInt

/-- info: 'MM.coeff_mul_eq_of_coeff_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_mul_eq_of_coeff_eq

/-- info: 'MM.coeff_one_sub_X_pow_pow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_one_sub_X_pow_pow

/-- info: 'MM.coeff_prod_range_tail' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_prod_range_tail

/-- info: 'MM.coeff_formalDiscTprod_eq_partial' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.coeff_formalDiscTprod_eq_partial

/-- info: 'MM.DenominatorIdentity.pThree_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.DenominatorIdentity.pThree_apply

/-! ### M-form, stage 1: the three Jacobi theta functions and the `T`-side of the modularity

`Definitions/MME8Theta.lean`.  `MM.thetaThree` is Mathlib's `jacobiTheta`, `MM.thetaFour = θ₃(·+1)`, and
`MM.thetaTwo = e^{πiτ/4}·jacobiTheta₂(τ/2) τ` — the bridge from the library's **two-variable**
`jacobiTheta₂` (which is *not* the classical `θ₂`) to the classical `Σ q^{(n+1/2)²/2}`, proved as
`MM.thetaTwo_eq_tsum`.  Proved here: the `q`-expansions `MM.thetaFour_eq_tsum`/`MM.thetaTwo_eq_tsum`, the
`T`-shift laws, the multiplier law `θ₂(T·τ) = e^{πi/4}θ₂(τ)`, and
**`MM.thetaCombination_T_invariant`** — `θ₂⁸+θ₃⁸+θ₄⁸` is `T`-invariant although no single term is.  The
`S`-side's engine is identified in the file header: `jacobiTheta₂_functional_equation` (the two-variable
Poisson identity) plus `jacobiTheta_S_smul`.  No enumeration of lattice points appears anywhere. -/

/-- info: 'MM.exp_pi_mul_I_mul_sq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.exp_pi_mul_I_mul_sq
/-- info: 'MM.thetaFour_eq_tsum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaFour_eq_tsum
/-- info: 'MM.thetaTwo_eq_tsum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaTwo_eq_tsum
/-- info: 'MM.thetaThree_add_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaThree_add_one
/-- info: 'MM.thetaFour_add_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaFour_add_one
/-- info: 'MM.thetaTwo_add_one_mul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaTwo_add_one_mul
/-- info: 'MM.thetaTwo_pow_eight_add_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaTwo_pow_eight_add_one
/-- info: 'MM.thetaCombination_T_invariant' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaCombination_T_invariant

/-! ### M-form, stages 2–3 (partial): the half-period lemma and the `θ₂` `S`-law

`Definitions/MME8ThetaModular.lean` and `Definitions/MME8ThetaS.lean`.  The brief named three library
facts as the `S`-side engine; **two exist and the third does not** — there is no
`jacobiTheta₂ (1/2) σ = θ₄(σ)` in Mathlib (`Mathlib/NumberTheory/ModularForms/JacobiTheta/` has only
`jacobiTheta_eq_jacobiTheta₂` at `z = 0`).  It is true and elementary, so it is **proved** here rather
than assumed: `MM.jacobiTheta₂_half`.  On top of it, **`MM.thetaTwo_S_smul`** is the classical
`θ₂(-1/τ) = (-iτ)^{1/2}·θ₄(τ)` — the crux of the `S`-side, derived from
`jacobiTheta₂_functional_equation` at `z = 1/2` with `jacobiTheta₂_neg_left` and a `Complex.cpow_add`
cancellation.  Both files are pure algebra on the theta series: **no `decide`, no `MM.box`, no
enumeration**.  Still open (recorded in the files' headers): `θ₄`'s `S`-law, the combination's
`S`-invariance, the `ModularForm 𝒮ℒ 4` assembly with `½(θ₂⁸+θ₃⁸+θ₄⁸) = E₄`, and stage 3's coset
bijections and three values. -/

/-- info: 'MM.jacobiTheta₂_half' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.jacobiTheta₂_half

/-- info: 'MM.thetaTwo_S_smul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaTwo_S_smul

/-- info: 'MM.exp_pi_mul_I_int' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.exp_pi_mul_I_int

/-- info: 'MM.thetaFour_eq_jacobiTheta₂_half' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaFour_eq_jacobiTheta₂_half

/-! ### M-form, stages 2–3 (second partial): the `S`-half of the modularity, weight 4

`Definitions/MME8ThetaSCombination.lean`.  **`MM.thetaCombination_S_smul`**:
`θ₂⁸(S•τ) + θ₃⁸(S•τ) + θ₄⁸(S•τ) = τ⁴·(θ₂⁸+θ₃⁸+θ₄⁸)(τ)` — the `S`-half of the modularity, with the
`T`-half already on `main` (`MM.thetaCombination_T_invariant`), so the combination now transforms with
weight 4 under both generators.  Supporting: `MM.modular_S_smul_S_smul` (`S` has order two on `ℍ`),
`MM.cpow_half_pow_eight` (`(z^{1/2})⁸ = z⁴`, no branch hypothesis), `MM.neg_I_mul_pow_four`,
`MM.thetaTwo_S_pow_eight`, `MM.thetaThree_S_smul`/`_pow_eight`, `MM.neg_I_S_smul_pow_four`,
`MM.thetaFour_S_smul`/`_pow_eight`.

**A correction to the dispatcher's brief, verified before it was used**: the brief recorded
`θ₄(S•τ) = (A')⁸θ₂⁸(τ)` with `(A')⁸ = τ⁴`; that bookkeeping is inverted.  The law is
`θ₄(S•τ) = B·θ₂(τ)` with `B = (-I(S•τ))^{1/2}`, and `B⁸ = (I/τ)⁴ = (τ⁴)⁻¹`, so the eighth power of the
actual multiplier `B⁻¹` is `τ⁴` — same conclusion, different accounting, and the `B` form avoids the
`cpow` branch.  The three laws do share one multiplier `A(τ) = (-Iτ)^{1/2}` with `A⁸ = τ⁴`.

**Still open** (recorded in the file header and in the ROADMAP): slash-invariance for all
`γ ∈ 𝒮ℒ` by closure induction over `SpecialLinearGroup.SL2Z_generators`; `MDiff` of `θ₂`/`θ₄` and of the
combination; boundedness at the cusp; the `ModularForm 𝒮ℒ 4` assembly with `½(θ₂⁸+θ₃⁸+θ₄⁸) = E₄` by
`ModularForm.levelOne_weight_four_rank_one` + `EisensteinSeries.E_qExpansion_coeff`; and stage 3's coset
bijections with the three values in `MMLevelTwo.lean` as corollaries.  No enumeration anywhere. -/

/-- info: 'MM.thetaCombination_S_smul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaCombination_S_smul

/-- info: 'MM.thetaFour_S_smul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaFour_S_smul

/-- info: 'MM.thetaTwo_S_pow_eight' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaTwo_S_pow_eight

/-- info: 'MM.cpow_half_pow_eight' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.cpow_half_pow_eight

/-! ### M-form, stage 2 (third partial): weight-4 slash-invariance for all of `𝒮ℒ`

`Definitions/MME8ThetaModularForm.lean`.  `MM.thetaCombination := θ₂⁸ + θ₃⁸ + θ₄⁸` is now proved
**slash-invariant of weight 4 for every `γ ∈ 𝒮ℒ`** —
`MM.thetaCombination_slash_invariant {γ} (hγ : γ ∈ 𝒮ℒ) : thetaCombination ∣[(4 : ℤ)] γ = thetaCombination`
— by combining the two generator laws (`MM.thetaCombination_slash_S` from the S-half plus
`ModularGroup.denom_S`, `MM.thetaCombination_slash_T` from the T-half plus `denom T τ = 1`) through a
closure induction over `MM.closure_mapGL_generators : Subgroup.closure {mapGL ℝ S, mapGL ℝ T} = 𝒮ℒ`,
which transports `SpecialLinearGroup.SL2Z_generators` through `MonoidHom.map_closure`.

**Still open** (in the file header): `MDiff thetaCombination`; boundedness at the cusp and the
`ModularForm 𝒮ℒ 4` assembly; `½(θ₂⁸+θ₃⁸+θ₄⁸) = E₄` by `levelOne_weight_four_rank_one` +
`E_qExpansion_coeff`; then stage 3's coset bijections and the three values.  No enumeration anywhere. -/

/-- info: 'MM.thetaCombination_slash_invariant' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaCombination_slash_invariant

/-! ### M-form, steps 3--6: the theta combination is `E₄`, and `thetaCoeff` is its `q`-expansion

`Definitions/MME8ThetaLevelOne.lean` assembles `MM.halfThetaForm : ModularForm 𝒮ℒ 4` from step 1--2's
`MDiff` and cusp behaviour and step 4a's slash-invariance, and identifies it with `E₄`
(`MM.halfThetaForm_eq_E4`) by `ModularForm.levelOne_weight_four_rank_one` plus the constant term;
`Definitions/MME8ThetaLattice.lean`, `…CoeffCount.lean`, `…CoeffSum.lean` and `…CoeffFinal.lean` then
identify `MM.thetaCoeff` with that form's `q`-expansion — parity classification of `ℤ^8` and explicit
bijections/involutions, **no enumeration**.  The payoff is `MM.thetaCoeff_of_ne_zero :
m ≠ 0 → thetaCoeff m = 240 * σ 3 m`, which discharges the last three `sorry`s of
`Definitions/MMLevelTwo.lean`. -/

/-- info: 'MM.halfThetaForm_eq_E4' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.halfThetaForm_eq_E4

/-- info: 'MM.qExpansion_halfThetaCombination_coeff_of_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.qExpansion_halfThetaCombination_coeff_of_ne_zero

/-- info: 'MM.hasSum_thetaCoeff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.hasSum_thetaCoeff

/-- info: 'MM.thetaCoeff_of_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaCoeff_of_ne_zero

/-- info: 'MM.thetaCoeff_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaCoeff_one

/-- info: 'MM.thetaCoeff_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaCoeff_two

/-- info: 'MM.thetaCoeff_three' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaCoeff_three

/-- info: 'MM.closure_mapGL_generators' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.closure_mapGL_generators

/-- info: 'MM.thetaCombination_slash_S' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaCombination_slash_S

/-- info: 'MM.thetaCombination_slash_T' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaCombination_slash_T

/-- info: 'MM.thetaCombination_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaCombination_apply

/-! ## Proved: the `Y₄₄₃` Coxeter group -/

/-- info: 'MM.Y443Matrix_multiset' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Y443Matrix_multiset

/-- info: 'MM.Y443Vertex_card' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Y443Vertex_card

/-! ## Proved: the monster as a quotient -/

/-- info: 'MM.monsterMk_y443Spider' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.monsterMk_y443Spider

/-- info: 'MM.y443Spider_mem_center' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.y443Spider_mem_center

/-- info: 'MM.monsterMk_surjective' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.monsterMk_surjective

/-- info: 'MM.monsterMk_ker' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.monsterMk_ker

/-! ## Proved: what finiteness and the order of the monster need (task S3-D)

`Definitions/MMMonsterOrder.lean`: the S3 gap stated as declarations.  `MM.Monster` is defined by
*presentation*, so `Finite MM.Monster` needs the finiteness of `MM.Y443Quotient` (a normal-form
certificate with `2·|M| ≈ 1.6 × 10^54` entries) — and the completeness of the presentation
(Norton--Ivanov 1990) transports the order question without answering it.  What is proved here is the
free direction (`Finite Y443Quotient → Finite Monster`), the index formula for the centre (and, with
the identification, that the centre is the `C₂`), and the arithmetic of the order: the 54-digit
numeral, its prime-power factorization, its digit count, and the refutation of the 51-digit literal
that once circulated in a dispatching brief.  **No finiteness, no order and no non-triviality of
`MM.Monster` is claimed.**  The guards below are the dispatcher's own probe, rebuilt from source. -/

/-- info: 'MM.finite_monster_of_finite_y443Quotient' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.finite_monster_of_finite_y443Quotient

/-- info: 'MM.card_monster_eq_monsterCenter_index' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.card_monster_eq_monsterCenter_index

/-- info: 'MM.card_monster_mul_card_monsterCenter' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.card_monster_mul_card_monsterCenter

/-- info: 'MM.finite_monster_of_nortonIvanov' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.finite_monster_of_nortonIvanov

/-- info: 'MM.card_monsterCenter_eq_two_of_nortonIvanov' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.card_monsterCenter_eq_two_of_nortonIvanov

/-- info: 'MM.monsterOrder_of_nortonIvanov_and_y443Card' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.monsterOrder_of_nortonIvanov_and_y443Card

/-- info: 'MM.monsterOrder_eq_primePowers' depends on axioms: [propext] -/
#guard_msgs in
#print axioms MM.monsterOrder_eq_primePowers

/-- info: 'MM.monsterOrder_digit_count' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.monsterOrder_digit_count

/-- info: 'MM.monsterOrder_ne_wrongLiteral' depends on axioms: [propext] -/
#guard_msgs in
#print axioms MM.monsterOrder_ne_wrongLiteral

/-! ## Proved: the level-2 half of section 11 (the `E8` lattice and its theta series) -/

/-- info: 'MM.E8.sum_odd_sq_dvd' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.E8.sum_odd_sq_dvd

/-- info: 'MM.E8.normSq_half_integral' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.E8.normSq_half_integral

/-- info: 'MM.E8.isLattice_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.E8.isLattice_iff

/-- info: 'ZZCond.even_sum_iff_even_pair' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms ZZCond.even_sum_iff_even_pair

/-- info: 'ZZCond.even_sufficient' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms ZZCond.even_sufficient

/-! ## Proved: Euler's q-binomial theorem, the Jacobi triple product as a target, and the Heisenberg
Fock space (batch 3)

`Definitions/MMQBinomial.lean` — **Euler's q-binomial theorem, proved**: the coefficient of `z^n` in
`∏_{j≤M}(1+zq^j)`, multiplied by `(q;q)_n`, stabilises at `q^{n(n-1)/2}` as `M` grows, together with
its shifted variant needed by the triple product.  `Definitions/MMJacobiTripleProduct.lean` — the
**Jacobi triple product itself is NOT proved**: the file carries `MM.JacobiTripleProductStatement` and
`MM.GaussDurfeeStatement` as `Prop`s whose docstrings say so, plus the proved fragments
(coefficient `z^0` instances) and a correction of the dispatching brief's exponent
(`k(k+1)/2`, not `k(k-1)/2`).  `Definitions/MMHeisenbergFockBasic.lean` — the Heisenberg Fock space,
its weight grading, the finiteness of each graded piece and the vacuum statements
(`F_0 = R·|0⟩`).

**Not proved, and recorded rather than hidden:** the triple product, the Gauss–Durfee identity, and
(in `Definitions/MMHeisenbergFock.lean`, which is *parked on branch `task/fock-i`*, not on `main`) the
canonical commutation relations — the agent found its own `annihilate` to be an algebra homomorphism
rather than a derivation, so `MM.Osc.canonicalCommutationRelation` is FALSE for that operator.  The
guards below are the dispatcher's own probe, rebuilt from source. -/

/-- info: 'MM.euler_qbinomial' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.euler_qbinomial

/-- info: 'MM.euler_qbinomial_tendsto' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.euler_qbinomial_tendsto

/-- info: 'MM.euler_qbinomial_one_coeff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.euler_qbinomial_one_coeff

/-- info: 'MM.euler_qbinomial_two_coeff_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.euler_qbinomial_two_coeff_one

/-- info: 'MM.euler_qbinomial_shifted' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.euler_qbinomial_shifted

/-- info: 'MM.euler_qbinomial_shifted_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.euler_qbinomial_shifted_one

/-- info: 'MM.jtpProd_coeff_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.jtpProd_coeff_zero

/-- info: 'MM.jtp_coeff_zero_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.jtp_coeff_zero_zero

/-- info: 'MM.jtp_coeff_neg_one_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.jtp_coeff_neg_one_zero

/-- info: 'MM.Heisenberg.finite_weightVec' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.finite_weightVec

/-- info: 'MM.Heisenberg.vacuum_mem' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.vacuum_mem

/-- info: 'MM.Heisenberg.weight_zero_eq_smul_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.weight_zero_eq_smul_vacuum

/-! ## Proved: the Gaussian-binomial route to the triple product, and the FULL Heisenberg
commutation relations (batch 4, runs 2)

`Definitions/MMGaussBinom.lean` (complete) — Gaussian binomials with the inversion normalisation,
`MM.qbin_pascal`, the second-order recurrence `MM.qbin_step`, and the limit
`MM.qbin_limit` / `MM.qbin_limit_coeff` that the finite triple product needs.
`Definitions/MMJacobiTripleProductProof.lean` — the triple product's exact recurrence `MM.jtpC_succ`,
its value at `M = 0` and its symmetry `MM.jtpC_symm`; **the main induction `MM.jtpC_main` is NOT
proved** and is recorded in that file's header (one base case defeated by the `ℤ`-coercions inside
`jtpC_zero`'s `if`-conditions, and one `ring` identity in the inductive step).
`Definitions/MMHeisenbergOscillator.lean` + `MMHeisenbergOscillatorComm.lean` — the creation
operators, the annihilation operator built as a genuine **`Derivation`** (Leibniz rule
`MM.Heisenberg.deriv_mul_apply`), and **all three cases of the canonical commutation relations**
(`MM.Heisenberg.annihilate_comp_annihilate`, `create_comp_create`, `annihilate_comp_create`,
`annihilate_comp_create_sub`, `ccr_ring`).  The graded character is **not** proved: the missing step
(a bijection to `Nat.Partition`, and a basis of a graded piece) is recorded in the file.
The guards below are the dispatcher's own probe, rebuilt from source. -/

/-- info: 'MM.qbin_step' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.qbin_step

/-- info: 'MM.qbin_limit' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.qbin_limit

/-- info: 'MM.qbin_limit_coeff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.qbin_limit_coeff

/-- info: 'MM.jtpC_succ' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.jtpC_succ

/-- info: 'MM.jtpC_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.jtpC_zero

/-- info: 'MM.jtpC_symm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.jtpC_symm

/-- info: 'MM.Heisenberg.create_mem_gradedPart' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.create_mem_gradedPart

/-- info: 'MM.Heisenberg.deriv_mul_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.deriv_mul_apply

/-- info: 'MM.Heisenberg.annihilate_mono' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.annihilate_mono

/-- info: 'MM.Heisenberg.annihilate_comp_create' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.annihilate_comp_create

/-- info: 'MM.Heisenberg.annihilate_comp_create_sub' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.annihilate_comp_create_sub

/-- info: 'MM.Heisenberg.create_comp_create' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.create_comp_create

/-- info: 'MM.Heisenberg.annihilate_comp_annihilate' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.annihilate_comp_annihilate

/-- info: 'MM.Heisenberg.ccr_ring' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.ccr_ring

/-! ## Proved: what `MM.LevelOneOrbitSeparation` is equivalent to (batch 5, M1-FLT)

`Definitions/MMLevelOneOrbitSeparation.lean` does **not** prove the target.  It proves that the target
is equivalent to j inducing a bijection `ℍ/𝒮ℒ → ℂ`, to `MM.IsHauptmodul 𝒮ℒ levelOneJ`, to the
analytic-normalized form, and to injectivity on the **closed** fundamental domain — while the
open-domain form is *not* equivalent.  The owner-directed route through `../fermats-last-theorem` is
blocked by three Mathlib-drift compile errors there (file:line in `ROADMAP.md`'s BATCH 5 block). -/

/-- info: 'MM.levelOneOrbitSeparation_iff_injective' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneOrbitSeparation_iff_injective

/-- info: 'MM.levelOneOrbitSeparation_iff_bijective' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneOrbitSeparation_iff_bijective

/-- info: 'MM.levelOneOrbitSeparation_iff_isHauptmodul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneOrbitSeparation_iff_isHauptmodul

/-- info: 'MM.levelOneOrbitSeparation_iff_fd' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneOrbitSeparation_iff_fd

/-! ## Proved: THE JACOBI TRIPLE PRODUCT (batch 6, JTP run 3) and the level-one valence reduction

`Definitions/MMJacobiTripleProductMain.lean` proves `MM.jtpC_main` and then
**`MM.jacobiTripleProduct : MM.JacobiTripleProductStatement`** — run 1's `Prop` is inhabited, so the
eta-theta bridge that blocked Lemma 11.1 now exists.
`Definitions/MMLevelOneOrbitSeparationProof.lean` re-exports the sibling project's now-compiling
`MM.flt_levelOne_isPrincipal_of_degree_eq_zero_charLOne` and proves the level-one affine reduction
(`MM.levelOne_affine_of_bounded_mul_discriminant`) and the valence-form equivalence;
**`MM.LevelOneOrbitSeparation` itself is still NOT proved.** -/

/-- info: 'MM.jtpC_main' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.jtpC_main

/-- info: 'MM.jacobiTripleProduct' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.jacobiTripleProduct

/-- info: 'MM.jtpProd_coeff_stable' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.jtpProd_coeff_stable

/-- info: 'MM.levelOne_affine_of_bounded_mul_discriminant' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOne_affine_of_bounded_mul_discriminant

/-- info: 'MM.levelOneOrbitSeparation_iff_valenceInput' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneOrbitSeparation_iff_valenceInput

/-- info: 'MM.flt_levelOne_isPrincipal_of_degree_eq_zero_charLOne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.flt_levelOne_isPrincipal_of_degree_eq_zero_charLOne

/-! ## Proved: the paper's own coefficient checks for Lemma 11.1, and the orbit-separation reduction
(batch 7)

`Definitions/MMLemma111.lean` does **not** prove Lemma 11.1: it carries `MM.Lemma11_1Statement` as a
`Prop` and proves the paper's coefficient checks — `MM.ddpDeltaQ_coeff_*` (.tex:2158),
`MM.ddpDeltaQhalf_coeff_*` (.tex:2156), `MM.ddpDeltaNegQhalf_coeff_*` (.tex:2157, the forced branch),
`MM.thetaTwoE8_coeff_four`/`_eight`, the two coset series (.tex:2154/2155) and
`MM.ddpDeltaSum_coeff_eq`, which extends the paper's `q⁰, q^{1/2}, q¹` check to `q^{3/2}, q²`.  The
remaining step is the eta–theta product bridge (the Jacobi triple product at `z = ±1`), which Mathlib
does not package.  `Definitions/MMLevelOneOrbitSeparationDone.lean` reduces
`MM.LevelOneOrbitSeparation` to the two named `def`s `MM.PlaceOrbitSeparation` and `MM.OrderBridge`
(neither proved) and proves the level-one group identification `MM.gamma0_one_eq_top`.  The dispatcher
had to rename two declarations of `MMLemma111` that clashed with `MMLevelOneIntegrality` /
`MMLevelOneJCoeffs` before either file could be imported together. -/

/-- info: 'MM.ddpDeltaQ_coeff_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.ddpDeltaQ_coeff_two

/-- info: 'MM.ddpDeltaSum_coeff_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.ddpDeltaSum_coeff_eq

/-- info: 'MM.thetaTwoE8_coeff_four' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaTwoE8_coeff_four

/-- info: 'MM.gamma0_one_eq_top' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.gamma0_one_eq_top

/-- info: 'MM.levelOneOrbitSeparation_of_place_data' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneOrbitSeparation_of_place_data

/-! ## Proved: theta_3's product formula from the triple product, and gap (B1) closed (batch 8)

`Definitions/MMThetaEtaProduct.lean` transports the proved Jacobi triple product to a genuine product
formula for the third theta function (`MM.theta3Prod_eq_tsum`), the first half of the eta–theta bridge
that Lemma 11.1 needs: theta_4, theta_2 and the three eta-quotient evaluations followed in batch 9,
and batches 11--12 closed the two remaining named inputs, so `MM.Lemma11_1Statement` is now proved.
`Definitions/MMLevelOneOrbitSeparationFinal.lean` **closes gap (B1) unconditionally** —
`MM.placeOrbitSeparation_unconditional`, from the sibling project's `ComplexPlaceDictionary.pt_eq_pt_iff`
— and proves that the target now follows from the centre step alone
(`MM.levelOneOrbitSeparation_of_center`); `MM.OrderBridge` is the one gap left.  Both files were
imported here together, which is also the end-to-end check that they introduce no name clash. -/

/-- info: 'MM.theta3Prod_eq_tsum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.theta3Prod_eq_tsum

/-- info: 'MM.theta3Prod_coeff_four' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.theta3Prod_coeff_four

/-- info: 'MM.placeOrbitSeparation_unconditional' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.placeOrbitSeparation_unconditional

/-- info: 'MM.levelOneOrbitSeparation_of_center' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneOrbitSeparation_of_center

/-! ## PROVED UNCONDITIONALLY: level-one orbit separation, the level-one Hauptmodul, and genus zero
(batch 9) — and the second half of the eta-theta bridge

`Definitions/MMLevelOneOrbitSeparationComplete.lean` proves **`MM.levelOneOrbitSeparation_unconditional`**
with no hypotheses: `MM.OrderBridge` (the last named gap), the field identification
`MM.levelOneDictField_eq_levelOneCField`, and the transport `MM.place_eq_of_ord_pos_field_eq` are all
theorems, and with them **`MM.levelOne_isHauptmodul_unconditional : IsHauptmodul levelOneGamma levelOneJ`**
and **`MM.levelOne_hasGenusZero_unconditional`**.  This is the level-one entry of the Conway--Norton
table, and it rests on the sibling project's modular-curve/divisor assets (365/365 modules compiling)
with no sibling axiom leaking.
`Definitions/MMThetaEtaProductTwo.lean` completes the product forms of theta_4 and theta_2, the
even/odd `tprod` split and the three eta-quotient evaluations; `Definitions/MMLemma111Proof.lean`
reduces Lemma 11.1 to exactly two named inputs, and `Definitions/MMThetaDuplication.lean` (**batch 11**)
now **proves the first of them**: `MM.jacobiQuartic : θ₃⁴ − θ₄⁴ = 16·Y·θ₂unit⁴` (classically
`θ₃⁴ = θ₂⁴ + θ₄⁴`) and its `Prop`-valued form `MM.jacobiQuartic_statement : MM.JacobiQuartic`, from the
three duplication identities `S₂² = 2·S₂(Y²)·θ₃(Y²)`, `θ₃(Y)² = θ₃(Y²)² + Y·S₂(Y²)²`,
`θ₄(Y)² = θ₃(Y²)² − Y·S₂(Y²)²` and the product identity `θ₃(Y)·θ₄(Y) = θ₄(Y²)²`, each proved by an
explicit `Finset.card_bij` bijection of lattice-point sets.  `MM.E8ThetaInput` — the second input — was
proved in batch 12 (`MM.E8ThetaBridge.lean`), so **`MM.Lemma11_1Statement` is now a theorem**; see the
batch-12 block below. -/

/-- info: 'MM.levelOneOrbitSeparation_unconditional' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOneOrbitSeparation_unconditional

/-- info: 'MM.levelOne_isHauptmodul_unconditional' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOne_isHauptmodul_unconditional

/-- info: 'MM.levelOne_hasGenusZero_unconditional' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelOne_hasGenusZero_unconditional

/-- info: 'MM.theta3_eta_quotient' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.theta3_eta_quotient

/-- info: 'MM.theta2_eta_quotient' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.theta2_eta_quotient

/-- info: 'MM.lemma11_1_of_inputs' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.lemma11_1_of_inputs

/-! ## Proved: Jacobi's quartic relation (batch 11, task A1b-VI)

`Definitions/MMThetaDuplication.lean` proves **Jacobi's quartic relation** `θ₃⁴ = θ₂⁴ + θ₄⁴` in the
repository's product normalisation `θ₃⁴ − θ₄⁴ = 16·Y·θ₂unit⁴` (`MM.jacobiQuartic`, and its
`Prop`-valued form `MM.jacobiQuartic_statement : MM.JacobiQuartic`, which is the first of the two
named inputs of `MM.Lemma11_1Statement`).  The route is the classical theta duplication identities
together with `θ₃(Y)·θ₄(Y) = θ₄(Y²)²`; every count is an explicit bijection of lattice-point sets, so
no enumeration, `decide` or `native_decide` is involved.  The second input, `MM.E8ThetaInput`, was
proved in the very next batch (`Definitions/MME8ThetaBridge.lean`), so Lemma 11.1 is now unconditional
— see the batch-12 block below. -/

/-- info: 'MM.theta2Trip_eq_two_mul_theta2Prod' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.theta2Trip_eq_two_mul_theta2Prod

/-- info: 'MM.jacobiQuartic' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.jacobiQuartic

/-- info: 'MM.jacobiQuartic_statement' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.jacobiQuartic_statement

/-- info: 'MM.theta2Trip_mul_self' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.theta2Trip_mul_self

/-- info: 'MM.theta3SumN_mul_self' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.theta3SumN_mul_self

/-- info: 'MM.theta4SumN_mul_self' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.theta4SumN_mul_self

/-- info: 'MM.theta3SumN_mul_theta4SumN' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.theta3SumN_mul_theta4SumN

/-- info: 'MM.thetaSum_fourth' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaSum_fourth

/-! ## Proved: `MM.E8ThetaInput`, and with it **`MM.Lemma11_1Statement`** (batch 12, task A1b-VII)

`Definitions/MME8ThetaTransport.lean` supplies the analytic-to-formal transport that was the last
missing input: `EvalsAt f y v` says the power series `f` has value `v` at the nome `y`, with a value
calculus closed under `+`, `*`, rational constants, `Y` and powers; `MM.eq_zero_of_hasSum_eval_eq_zero`
extracts vanishing coefficients from vanishing values on `(0,1)`; the lattice fibre regroupings
`MM.tsum_fiber_sqCount`/`_alt`/`MM.tsum_fiber_triCount` move between the formal `tprod`s and the
lattice sums; and `MM.thetaEightSum_eq_thetaCoeffSeries` identifies
`θ₃⁸ + θ₄⁸ + 2⁸Y²θ₂unit⁸` with `2·∑_m thetaCoeff(m)Y^{2m}`.
`Definitions/MME8ThetaBridge.lean` then proves `MM.nomePow_two_thetaEightSum` (the nome-2 comparison
that turns the duplication identities into the target) and
**`MM.e8ThetaInput : MM.E8ThetaInput`**, hence **`MM.lemma11_1 : MM.Lemma11_1Statement`** —
the paper's Lemma 11.1, unconditionally. -/

/-- info: 'MM.e8ThetaInput' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.e8ThetaInput

/-- info: 'MM.lemma11_1' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.lemma11_1

/-- info: 'MM.thetaEightSum_eq_thetaCoeffSeries' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaEightSum_eq_thetaCoeffSeries

/-- info: 'MM.nomePow_two_thetaEightSum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.nomePow_two_thetaEightSum

/-- info: 'MM.eq_zero_of_hasSum_eval_eq_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.eq_zero_of_hasSum_eval_eq_zero

/-! ## Proved: the rank-1 Fock graded character, and Gauss's identity for theta_2 (batch 10)

`Definitions/MMFockPartition.lean`, `MMFockSmallWeights.lean` and `MMFockCharacter.lean` prove the
**rank-1 Fock graded character**: `MM.Heisenberg.weightVecOneEquivPartition : WeightVec 1 N ≃ Nat.Partition N`,
`MM.Heisenberg.finrank_gradedPart` (the dimension of a graded piece is the number of its weight-`N`
monomials), the rank-1 dimensions `1, 1, 2, 3, 5, ...` and
`MM.Heisenberg.fockCharSeries_one_eq_tprod : ∑_N dim F_N q^N = ∏_{m≥1}(1−q^m)^{-1}`.  **Rank `n ≥ 2` is
proved too** (batch 15, `Definitions/MMFockCharacterRankN.lean`):
**`MM.Heisenberg.fockCharacterStatement (n) : MM.Heisenberg.FockCharacterStatement n`**, i.e.
`∑_N dim F_N q^N = ∏_{m≥1}(1−q^m)^{−n}` for every `n`, with the corollaries
`MM.Heisenberg.finrank_gradedPart_eq_card_colouredPartition` and `dim F_1 = n` at rank `n`.  The route is
the convolution `#(WeightVec (n+1) N) = ∑_{a+b=N} #(WeightVec n a)·#(WeightVec 1 b)`
(`MM.Heisenberg.card_weightVec_succ`), hence `MM.Heisenberg.fockCharSeries_succ`, then the rank-one
Euler product and `Multipliable.tprod_pow`.
`Definitions/MMLemma111Final.lean` proves Gauss's identity for `θ₂` (`MM.two_mul_theta2Prod`), i.e. the
triple product at `z = 1` — `Definitions/MMThetaDuplication.lean` proves `MM.JacobiQuartic` (batch 11)
and `Definitions/MME8ThetaBridge.lean` proves `MM.E8ThetaInput` (batch 12), so **both** named inputs of
Lemma 11.1 are theorems and **`MM.Lemma11_1Statement` is now proved** (`MM.lemma11_1`). -/

/-- info: 'MM.Heisenberg.weightVecOneEquivPartition' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.weightVecOneEquivPartition

/-- info: 'MM.Heisenberg.finrank_gradedPart' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.finrank_gradedPart

/-- info: 'MM.Heisenberg.fockCharSeries_one_eq_tprod' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.fockCharSeries_one_eq_tprod

/-- info: 'MM.Heisenberg.fockCharacterStatement' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.fockCharacterStatement

/-- info: 'MM.Heisenberg.card_weightVec_succ' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.card_weightVec_succ

/-- info: 'MM.Heisenberg.fockCharSeries_succ' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.fockCharSeries_succ

/-- info: 'MM.Heisenberg.finrank_gradedPart_eq_card_colouredPartition' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.finrank_gradedPart_eq_card_colouredPartition

/-! ## Proved: the Virasoro (Sugawara) structure on the Fock space (batches 16--18, task FOCK-VIR)

`Definitions/MMFockVirasoro.lean` builds the `ℤ`-indexed Heisenberg modes `MM.Heisenberg.alpha`
(`alpha i k` is the annihilator for `k > 0`, the creator for `k < 0`, `0` at `k = 0`), proves their
commutation relations in `ℤ`-form (`MM.Heisenberg.alpha_comm`), and defines the **Sugawara operators**
`MM.Heisenberg.L` as `finsum`s whose well-definedness is discharged by an explicit local-finiteness
argument (`MM.Heisenberg.pairNO_apply_mono_eq_zero`, `MM.Heisenberg.hasFiniteSupport_NO`).  Proved here:
* **the Witt action** `MM.Heisenberg.L_commutator_alpha : L_m α_s − α_s L_m = (−s) • α_{m+s}`, i.e. the
  Sugawara operators act as the Witt algebra on the modes;
* the vacuum is annihilated: `MM.Heisenberg.L_apply_one_eq_zero : L_m |0⟩ = 0` for `m ≥ −1`;
* the criterion `MM.Heisenberg.eq_smul_one_of_commutator_alpha_eq_zero`: an operator commuting with
  every mode is a scalar multiple of the identity.
**And, since batch 18, the conformal structure itself**:
* **the Virasoro bracket** `MM.Heisenberg.L_commutator_L :
  `[L_m, L_{m'}] = (m − m')L_{m+m'} + ((n/12)(m³ − m) δ_{m+m',0})·1` — central charge `c = n` (the rank),
  with `m` the first index, via `MM.Heisenberg.bracketDefect`, `MM.Heisenberg.bracketScalar`,
  `MM.Heisenberg.bracketScalar_cocycle` (an operator-level Jacobi cocycle) and the explicit
  `[L_2, L_{−2}]|0⟩ = (n/2)|0⟩` (`MM.Heisenberg.bracketScalar_two_neg_two`);
* **the conformal grading** `MM.Heisenberg.L_zero_apply_of_mem_gradedPart : v ∈ GradedPart n N R →
  L_0 v = N • v` (and its monomial form `MM.Heisenberg.L_zero_apply_mono`), with the product rule
  `MM.Heisenberg.L_mul_modeVec`;
* `L_{−1}` is the translation operator (`MM.Heisenberg.L_neg_one_commutator_alpha`) and annihilates the
  vacuum.
The route deliberately does **not** need the power rule that blocked batches 16--17: the grading peels one
creation operator at a time under strong induction on `monoWeight`. -/

/-- info: 'MM.Heisenberg.L_commutator_alpha' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.L_commutator_alpha

/-- info: 'MM.Heisenberg.alpha_comm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.alpha_comm

/-- info: 'MM.Heisenberg.L_apply_one_eq_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.L_apply_one_eq_zero

/-- info: 'MM.Heisenberg.hasFiniteSupport_NO' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.hasFiniteSupport_NO

/-- info: 'MM.Heisenberg.eq_smul_one_of_commutator_alpha_eq_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.eq_smul_one_of_commutator_alpha_eq_zero

/-- info: 'MM.Heisenberg.L_commutator_L' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.L_commutator_L

/-- info: 'MM.Heisenberg.L_zero_apply_of_mem_gradedPart' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.L_zero_apply_of_mem_gradedPart

/-- info: 'MM.Heisenberg.L_zero_apply_mono' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.L_zero_apply_mono

/-- info: 'MM.Heisenberg.L_mul_modeVec' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.L_mul_modeVec

/-- info: 'MM.Heisenberg.L_neg_one_commutator_alpha' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.L_neg_one_commutator_alpha

/-- info: 'MM.Heisenberg.bracketScalar_two_neg_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.bracketScalar_two_neg_two

/-- info: 'MM.two_mul_theta2Prod' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.two_mul_theta2Prod

/-- info: 'MM.thetaCoeff_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.thetaCoeff_zero

-- Not guarded: `MM.thetaCoeff_one`, `_two` and `_three` are still `sorry` (delivery debt, not an
-- open question: their values are verified and their counts settled).  `MM.thetaCoeff_zero` is
-- proved since task D-d2, by the combinatorial route -- a soundness/completeness/nodup package for
-- `MM.box` plus the classification of the small solutions, with no kernel reduction of the
-- enumeration.  See the `sorry` map in `README.md`.
-- #print axioms MM.thetaCoeff_one

/-! ## Proved: the level-`N` orbit-separation reduction (batch 14, stream M)

`Definitions/MMLevelNOrbitSeparation.lean` generalises the level-one closure's first gap to **every**
level and states the level-2 target as a single named input.  Proved: `MM.levelNGamma`,
`MM.levelTwoGamma`, `MM.twoTau`, `MM.levelTwoJ` (`Δ(τ)/Δ(2τ) + 24`, Conway--Norton's `T_{2B}`),
`MM.levelN_placeOrbitSeparation` (level one's gap (B1) at every level, from the sibling project's
`ComplexPlaceDictionary.pt_eq_pt_iff`, which **is** general in `N`), the reductions
`MM.levelNOrbitSeparation_of_center` / `MM.levelTwoOrbitSeparation_of_center` /
`MM.levelTwoOrbitSeparation_of_exists_center`, and `MM.genusFormula_two : MM.genusFormula 2 = 0`
(one line from `MM.genusZero_level 2`, no sibling import needed).
**Stated only** — the single named input of the level-2 route, and the level-2 targets:
`MM.LevelTwoCenterStep`, `MM.TargetHauptmodul2B`, `MM.TargetHasGenusZero2B`, `MM.TargetIsGenusZeroGroup2B`.
The level-one engine that discharged the centre step there is typed on `modularFunctionFieldC k 1` and
**cannot** be instantiated at `N = 2` (`ℂ(X₀(2))` is degree 3 over `ℂ(j)`), which is why this batch
stops at the reduction; the measured routes are in the file header and in `ROADMAP.md`'s BATCH 13 block. -/

/-- info: 'MM.genusFormula_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.genusFormula_two

/-- info: 'MM.levelN_placeOrbitSeparation' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelN_placeOrbitSeparation

/-- info: 'MM.levelTwoOrbitSeparation_of_exists_center' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelTwoOrbitSeparation_of_exists_center

/-- info: 'MM.levelNOrbitSeparation_of_exists_center' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.levelNOrbitSeparation_of_exists_center

/-! ## Proved: the Heisenberg-module layer of the lattice VOA `V_L` (batch 19, task VLA-1)

`Definitions/MMLatticeVOA.lean` (namespace `MM.LatticeVOA`) builds the first layer of the lattice vertex
algebra `V_L`, generic in `(L : MM.IntegralLattice)` and an explicit Fock rank `r`: the carrier
`MM.LatticeVOA.Carrier L r R := L.L →₀ MM.Heisenberg.FockSpace r R` (Carnahan's `⊕_{λ∈L} π^λ`),
the vacuum `MM.LatticeVOA.vacuum`, the oscillators `MM.LatticeVOA.alphaOp` with the Heisenberg
relations (`MM.LatticeVOA.alphaOp_comm`) and `α^i_k|0⟩ = 0` for `k ≥ 0`
(`MM.LatticeVOA.alphaOp_vacuum`), and the lattice exponentials `MM.LatticeVOA.eOp` with the 2-cocycle
condition (`MM.LatticeVOA.eOp_add`), the sign rule `e^x e^y = (−1)^{(x,y)} e^y e^x`
(`MM.LatticeVOA.eOp_commutator`) and `e^x α^i_k = α^i_k e^x` (`MM.LatticeVOA.eOp_comm_alphaOp`).
The cocycle itself is the landed `Definitions/MMLatticeDoubleCover.lean`.  **Not yet built** (later
batches): the grading, the character `θ_Λ/η^{rank}`, the vertex operators `Y(e^λ,z)` (which need the
`ε(x,x) = (−1)^{(x,y)/2}` normalisation), and any `VertexAlgebra`/`VertexAlgebra.VertexAlgebra1`
instance — the vendored interface has no models upstream. -/

/-- info: 'MM.LatticeVOA.alphaOp_comm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.alphaOp_comm

/-- info: 'MM.LatticeVOA.alphaOp_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.alphaOp_vacuum

/-- info: 'MM.LatticeVOA.eOp_add' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.eOp_add

/-- info: 'MM.LatticeVOA.eOp_commutator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.eOp_commutator

/-- info: 'MM.LatticeVOA.eOp_comm_alphaOp' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.eOp_comm_alphaOp

/-! ## Proved: the Leech lattice as an `MM.IntegralLattice`, and `leechThetaCoeff 4 = 196560` (batch 20)

`Definitions/MMLeechIntegralLattice.lean` supplies what every moonshine instantiation needs and the
repository lacked: `MM.leechIntegralLattice : MM.IntegralLattice` on the Leech carrier `MM.ASub`, with
the normalised form `MM.leechForm` (`8 * (x,y) = MM.dotZ x y`, i.e. `λ·μ` for `λ = 2^{-3/2}x`), its
symmetry (`MM.leechForm_isSymm`), evenness (`MM.leechForm_even`) and minimum
(`MM.leechForm_min_eq_four`).  Also: the two typeclass instances `Module.Finite ℤ ↥MM.ASub` /
`Module.Free ℤ ↥MM.ASub` (`MM.leechASubFinite`, `MM.leechASubFree`), the double cover
`MM.leechDoubleCover : MM.LatticeDoubleCover MM.leechIntegralLattice` (from an abstract basis —
noncomputable, no canonicity claimed), and the theta coefficients
`MM.leechCount_four` / **`MM.leechThetaCoeff_four : MM.leechThetaCoeff 4 = 196560`**. -/

/-- info: 'MM.leechIntegralLattice' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leechIntegralLattice

/-- info: 'MM.leechForm_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leechForm_spec

/-- info: 'MM.leechForm_even' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leechForm_even

/-- info: 'MM.leechDoubleCover' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leechDoubleCover

/-- info: 'MM.leechThetaCoeff_four' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leechThetaCoeff_four

/-- info: 'MM.leechForm_min_eq_four' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leechForm_min_eq_four

/-! ## Proved: the conformal-weight grading on the lattice VOA carrier (batch 21, task VLA-3)

`Definitions/MMLatticeVOAGrading.lean` (namespace `MM.LatticeVOA`) grades the carrier of
`Definitions/MMLatticeVOA.lean` by the conformal weight `h = (λ,λ)/2` plus the Fock level:
`MM.LatticeVOA.halfNorm` (integral by `MM.LatticeVOA.two_dvd_form_self`, with the quadratic refinement
`MM.LatticeVOA.halfNorm_add`), `MM.LatticeVOA.weightMono`, the graded pieces
`MM.LatticeVOA.GradedPart` with `MM.LatticeVOA.vacuum_mem_gradedPart`, the shifts
`MM.LatticeVOA.alphaOp_mem_gradedPart` (`α^i_k` shifts the weight by `−k`),
`MM.LatticeVOA.eOp_mem_gradedPart_of_form_eq_zero` (the honest `e^x` shift: `halfNorm x + (x,y)`, which
is **not** `halfNorm x` unless `x ⊥ L` — Borcherds records exactly this at `.tex:2286`),
`MM.LatticeVOA.eOp_vacuum`, and the carrier-level `L₀` with
`MM.LatticeVOA.L0_apply_of_mem_gradedPart : v ∈ GradedPart L r R N → L₀ v = N • v`. -/

/-- info: 'MM.LatticeVOA.halfNorm_add' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.halfNorm_add

/-- info: 'MM.LatticeVOA.vacuum_mem_gradedPart' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.vacuum_mem_gradedPart

/-- info: 'MM.LatticeVOA.alphaOp_mem_gradedPart' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.alphaOp_mem_gradedPart

/-- info: 'MM.LatticeVOA.eOp_mem_gradedPart_of_form_eq_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.eOp_mem_gradedPart_of_form_eq_zero

/-- info: 'MM.LatticeVOA.eOp_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.eOp_vacuum

/-- info: 'MM.LatticeVOA.L0_apply_of_mem_gradedPart' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.L0_apply_of_mem_gradedPart

/-! ## Proved: the character of `V_Λ` and the first moonshine coefficients (batch 22, task VLA-4)

`Definitions/MMLatticeVOACharacter.lean` proves the graded dimension theory of the Leech-lattice VOA and
**the character identity itself**:
* finiteness of the graded pieces (Leech-specific, since `MM.IntegralLattice` carries no positivity):
  `MM.LatticeVOA.leech_halfNorm_le_finite`, `MM.LatticeVOA.leechGradedPart_finiteDimensional`;
* the dimensions `MM.LatticeVOA.finrank_gradedPart_leech_zero/one/two : 1 / 24 / 196884`, with
  `MM.LatticeVOA.leechGradedDim_two_24 : leechGradedDim 24 2 = 196884` and the paper's decomposition
  `MM.LatticeVOA.leechGradedDim_two_eq_griess_add_one : … = 196883 + leechGradedDim 24 0`;
* **`MM.LatticeVOA.leechCharSeries_eq_theta_mul_fock`**: `Σ_N dim (V_Λ)_N q^N =
  Θ_Λ(q) · MM.Heisenberg.fockCharSeries r ℚ`, in Euler form
  `MM.LatticeVOA.leechCharSeries_eq_theta_mul_eulerProduct_24 : leechCharSeries 24 =
  leechThetaSeries · ∏_m (1 − q^m)^{−24}`, whose only input is the landed rank-`n` Fock character;
* the coefficient checks `(leechCharSeries 24).coeff 0/1/2 = 1 / 24 / 196884`.

**Not built**: `V_Λ = ⊕_N (V_Λ)_N` as an internal direct sum (the Fock monomials are not known to span,
see the VLA-3 header), the vertex operators `Y(a,z)`, the Monster action and `V^♮` itself — the remaining
layers of the moonshine module. -/

/-- info: 'MM.LatticeVOA.leechCharSeries_eq_theta_mul_fock' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.leechCharSeries_eq_theta_mul_fock

/-- info: 'MM.LatticeVOA.leechCharSeries_eq_theta_mul_eulerProduct_24' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.leechCharSeries_eq_theta_mul_eulerProduct_24

/-- info: 'MM.LatticeVOA.leechGradedDim_two_24' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.leechGradedDim_two_24

/-- info: 'MM.LatticeVOA.leechGradedDim_two_eq_griess_add_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.leechGradedDim_two_eq_griess_add_one

/-- info: 'MM.LatticeVOA.finrank_gradedPart_leech_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.finrank_gradedPart_leech_two

/-- info: 'MM.LatticeVOA.leechGradedPart_finiteDimensional' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.leechGradedPart_finiteDimensional

/-! ## Proved: the normalised lattice cocycle for the vertex operators (batch 23, task VLA-5)

`Definitions/MMLatticeVOACocycle.lean` supplies the
normalisation FLM (6.1.28)/(6.2.14) that the exponential vertex operators `Y(e^λ,z)` require, which the
landed basis cocycle satisfies only up to a cochain twist:
* `MM.IntegralLattice.cocycleNorm` with **`MM.IntegralLattice.cocycleNorm_self`**:
  `ε'(x,x) = (−1)^{halfNorm x}`, and `MM.IntegralLattice.cocycleNorm_commutator` (exact), plus the
  associativity and zero laws;
* `MM.IntegralLattice.doubleCoverNorm : MM.LatticeDoubleCover L` — unconditional, so the generic twisted
  ring theorems transfer verbatim (`doubleCoverNorm_mul_assoc`, `doubleCoverNorm_mul_single_single`,
  `doubleCoverNorm_basis_mul_comm`);
* the bridge `MM.IntegralLattice.cocycleNorm_mul_normCochain` (the new cocycle differs from the old by the
  explicit coboundary of the **quadratic** cochain `MM.IntegralLattice.normCochain`, not of a linear
  functional), and the Leech instantiation `MM.leechDoubleCoverNorm` /
  `MM.leechDoubleCoverNorm_eps_self`;
* the named `Prop`s for the missing vertex-operator layer with their reductions:
  `MM.IntegralLattice.ExponentialFieldRelations`, `MM.IntegralLattice.OscillatorFieldRelations` and
  `MM.IntegralLattice.firstVertexOperatorRelations_doubleCoverNorm`, plus FLM (6.2.35)
  `MM.IntegralLattice.eOp_cocycleNorm_neg_self`.
**Not built**: the two-variable formal series, the oscillator fields and locality — specified in the file
header and left to the next batch; no `Prop` is named as if it were proved. -/

/-- info: 'MM.IntegralLattice.cocycleNorm_self' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IntegralLattice.cocycleNorm_self

/-- info: 'MM.IntegralLattice.cocycleNorm_commutator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IntegralLattice.cocycleNorm_commutator

/-- info: 'MM.IntegralLattice.doubleCoverNorm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IntegralLattice.doubleCoverNorm

/-- info: 'MM.IntegralLattice.normCochain_coboundary' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.IntegralLattice.normCochain_coboundary

/-- info: 'MM.leechDoubleCoverNorm_eps_self' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.leechDoubleCoverNorm_eps_self

/-! ## Proved: the oscillator fields, their OPE and the stabilisation of the principal part (batch 24)

`Definitions/MMLatticeVOAOscillatorField.lean` states the oscillator vertex operators in the only form
this repository can currently support, and proves the field-level identity:
* `MM.not_isPWO_univ_int` — the exponent set `ℤ` is **not** well-orderable, so
  `Σ_{m∈ℤ} α^i_m z^{−m−1}` is provably **not** an element of any `HahnSeries`-based series ring here
  (the obstruction is measured, not assumed);
* the OPE in coefficient form (`MM.oscModeComm` and its four specialisations): the commutator of two
  modes is **central** with scalar coefficients supported on `m + s = 0`;
* the two-variable truncations in the nested ring `MM.OscFieldRing L r R := HahnSeries ℤ (HahnSeries ℤ E)`
  (`MM.oscFieldTrunc`, `MM.oscFieldTruncW`, `MM.oscDeltaDerivTrunc`) and the exact identity
  **`MM.oscFieldTrunc_comm`**:
  `[Y_N(i,z), Y_M(j,w)] = δ_{ij} · (truncated ∂_w δ(z−w))`;
* the statements that replace the missing limit: `MM.oscFieldSum_vacuum_coeff_eq_zero_of_neg` (the field
  is `z`-regular on the vacuum), `MM.oscFieldSum_Icc_succ_ne` (symmetric windows never stabilise — a
  correction of the brief), and the stabilisation of the **principal part**
  (`MM.alphaOp_apply_single_mono_eq_zero_of_monoWeight_lt`, `MM.Heisenberg.modeVal_le_monoWeight_of_ne_zero`).
**Not built** (specified in the file header): the localised two-variable ring that untruncated locality
`(z−w)^N[Y,Y] = 0` needs, the exponential fields `Y(e^λ,z)`, the Borcherds identity and any
`VertexAlgebra`/`VertexAlgebra.VertexAlgebra1` instance. -/

/-- info: 'MM.LatticeVOA.oscFieldTrunc_comm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.oscFieldTrunc_comm

/-- info: 'MM.LatticeVOA.oscModeComm_eq_smul_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.oscModeComm_eq_smul_one

/-- info: 'MM.LatticeVOA.oscFieldSum_vacuum_coeff_eq_zero_of_neg' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.oscFieldSum_vacuum_coeff_eq_zero_of_neg

/-- info: 'MM.not_isPWO_univ_int' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.not_isPWO_univ_int

/-! ## Proved: the two-variable localised coefficient layer, and the locality of two oscillator fields (batch 25-A)

`Definitions/MMLatticeVOATwoVarLocality.lean` supplies the layer the batch-24 header specified, in the
form this repository can actually support, and proves the locality statement the summary of this file
recorded as not built:
* the flat two-variable ring `MM.TwoVarExp`, the identification `MM.LatticeVOA.oscFieldRingFlat`, and
  **`MM.delta_not_hahnSeries`** — the delta's index set is *not* partially well ordered, so the
  untruncated `δ(z−w)` is not an element of any `HahnSeries` ring here (measured, not assumed);
* the **coefficientwise locality identity `MM.LatticeVOA.oscLocality`** —
  `oscModePairing α^i α^j k l = oscModePairing α^j α^i l k + deltaCoeff i j k l` — with the four
  specialisations (`_of_ne`, `_of_odd`, `_of_add_eq_zero`, `_of_add_ne_zero`) and the corollaries
  `MM.LatticeVOA.oscModePairing_eq_of_ne` / `_of_add_ne_zero`;
* `MM.LatticeVOA.oscVertexOpOf` and **`MM.LatticeVOA.ncoeff_oscVertexOpOf`**, which put the modes into
  the vendored `VertexOperator` interface (`ncoeff` index `n` ↔ mode `n`).
The vendor's `IsLocalToOrderLeq` is **not** discharged here — that is the next round's statement. -/

/-- info: 'MM.LatticeVOA.oscLocality' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.oscLocality

/-- info: 'MM.LatticeVOA.oscModePairing_eq_of_ne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.oscModePairing_eq_of_ne

/-- info: 'MM.LatticeVOA.oscModePairing_eq_of_add_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.oscModePairing_eq_of_add_ne_zero

/-- info: 'MM.delta_not_hahnSeries' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.delta_not_hahnSeries

/-- info: 'MM.LatticeVOA.ncoeff_oscVertexOpOf' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.ncoeff_oscVertexOpOf

/-! ## Proved: the headline's remaining gap as a named input list (batch 25-B)

`Definitions/MMMoonshineReduction.lean` turns "what does `moonshine_conjecture` still need" into Lean.
It does **not** touch the `sorry`, and it does not weaken the headline: **`MM.MoonshineModule.nonempty_moonshineInputs_iff`**
proves `Nonempty MoonshineInputs ↔ MoonshineConjectureStatementMonster`, so the field list is exactly as
strong as the goal, and `MM.MoonshineModule.moonshine_conjecture_of_inputs` is the assembly.  The
non-vacuity checks are `MM.MoonshineModule.exists_isGenusZeroGroup_family` (the genus-zero family is
inhabited over `MM.Monster`, via the level-one Hauptmodul) and `MM.MoonshineModule.isReplicable_zero`. -/

/-- info: 'MM.MoonshineModule.moonshine_conjecture_of_inputs' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.moonshine_conjecture_of_inputs

/-- info: 'MM.MoonshineModule.nonempty_moonshineInputs_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.nonempty_moonshineInputs_iff

/-- info: 'MM.MoonshineModule.exists_isGenusZeroGroup_family' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.exists_isGenusZeroGroup_family

/-- info: 'MM.MoonshineModule.isReplicable_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.isReplicable_zero

/-- info: 'MM.MoonshineModule.MoonshineInputs.dimC_neg_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.MoonshineInputs.dimC_neg_one

/-! ## Proved: locality of the oscillator fields in the **vendored** predicate (batch 26-A)

`Definitions/MMLatticeVOALocalityVendor.lean` closes the coefficient layer into the interface a
`VertexAlgebra` instance consumes.  Both statements carry Borcherds' condition (1) for the two
oscillators (inherited from the conditional `MM.LatticeVOA.oscVertexOpOf`), and the index convention
`ncoeff A n = A.coeff (−n−1)` is handled through `MM.LatticeVOA.ncoeff_oscVertexOpOf`:

* **`MM.LatticeVOA.isLocalToOrderLeq_oscVertexOpOf_two`** — `(z−w)²[Y(α^i,z), Y(α^j,w)] = 0` for
  **all** `i, j`, the case `i = j` included (`2` is the exact order: the commutator is
  `δ_ij ∂_wδ(z−w)`), through `MM.LatticeVOA.alphaOp_threeTerm` — the mode identity
  `[α^i_{p+2},α^j_q] − 2[α^i_{p+1},α^j_{q+1}] + [α^i_p,α^j_{q+2}] = 0`;
* **`MM.LatticeVOA.isLocalToOrderLeq_oscVertexOpOf_zero_of_ne`** — distinct-index oscillator fields
  commute **exactly**, so they are local at order `0`;
* the propagations `…_of_ne` (order `0` ⟹ every `N`) and `…_add` (order `2` ⟹ every `2 + m`). -/

/-- info: 'MM.LatticeVOA.isLocalToOrderLeq_oscVertexOpOf_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.isLocalToOrderLeq_oscVertexOpOf_two

/-- info: 'MM.LatticeVOA.isLocalToOrderLeq_oscVertexOpOf_zero_of_ne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.isLocalToOrderLeq_oscVertexOpOf_zero_of_ne

/-- info: 'MM.LatticeVOA.alphaOp_threeTerm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.alphaOp_threeTerm

/-! ## Proved: the truncated exponential of the creation half (batch 27)

`Definitions/MMLatticeVOAExponential.lean` lands the **first half of FLM's `exp(Σ_{k>0} α^i_{-k} z^k/k)`**
as a finite object:

* `MM.LatticeVOA.creationSum` — `Σ_{k=1}^{K} (1/k) α^i_{-k}`, a finite sum of linear maps, with
  `MM.LatticeVOA.creationSum_split` and the tail `creationSumAbove`; the coefficients `1/k`, `1/n!` are
  the rational scalars `invNatCast R k = algebraMap ℚ R ((k:ℚ))⁻¹`, since `R` is only a `CommRing`.
* `MM.LatticeVOA.expTrunc` — `Σ_{n=0}^{K} (1/n!) (creationSum i K)^n`, and the two-parameter
  `expTruncWindow`.
* **`MM.LatticeVOA.expTruncWindow_outer_mem`** — the stabilisation law in its provable form: raising the
  outer order with the window fixed changes the value by a vector of weight `≥ M + K + 1`.
* **`MM.LatticeVOA.expTrunc_mem_gradedPartAtLeast`** — the exponential never lowers the conformal
  weight, and `expTrunc_mem_gradedPartAtLeast_of_mem_gradedPart` its `GradedPart` form.

**Parked, with the obstruction measured, in the section marker in that file:** the *two*-parameter
statement (outer order **and** window both raised, i.e. `expTrunc i K'` versus `expTrunc i K`) is not
asserted anywhere, because the available lemma fixes the window and the required middle term is not of
that form.  The honest next step is the symmetric statement (window raised, outer order fixed). -/

/-- info: 'MM.LatticeVOA.expTruncWindow_outer_mem' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.expTruncWindow_outer_mem

/-- info: 'MM.LatticeVOA.expTrunc_mem_gradedPartAtLeast' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.expTrunc_mem_gradedPartAtLeast

/-- info: 'MM.LatticeVOA.creationSum_split' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.creationSum_split

/-! ## Proved: the truncated shifted vertex operator `Y(e^λ,z)`, and the grading shift `z^λ` (batch 28)

Two new files land FLM's vertex operator for a lattice vector in the only form that is honest on this
carrier (both halves truncated), together with the piece of it that acts on the lattice factor.

* `Definitions/MMLatticeVOAShiftedVertex.lean` — **FLM's `Y(e^λ,z) = e^λ · z^λ · exp(...)` as an
  `R`-linear endomorphism of the carrier**, in FLM's own order:
  `MM.LatticeVOA.shiftedVertexTrunc D x i K s = eOp D x ∘ latticeShift x s ∘ expTrunc i K`.
  * `MM.LatticeVOA.latticeShift` — the **`z^λ`** half, realised as the coefficient extraction
    `e^μ ⊗ c ↦ e^μ ⊗ ([z^{(λ,μ)}]s · c)` (no `SMul (ℤ[z^{±1}]) (FockSpace r R)` exists, measured:
    every ring action on the symmetric algebra factors through a `μ`-independent ring hom).  It is
    **not** multiplicative in `s` — Borcherds' `.tex:2286` parenthetical as an operator statement.
  * `MM.LatticeVOA.shiftedVertexTrunc_single_mem` — the **sharp per-summand weight law**:
    the image of `e^μ ⊗ x^f` lies in the filtration piece of weight `≥ weightMono μ f + (λ,λ)/2 + (λ,μ)`,
    with **no** dependence on the truncation order `K` (the creation half only raises the weight).
  * `MM.LatticeVOA.shiftedVertexTrunc_mem_gradedPartAtLeast` — the uniform form (radical case).
  * `MM.LatticeVOA.weightMono_eOp_of_monoWeight_add` — the exact weight identity of one step.
  * `MM.LatticeVOA.latticeShift_comp_eOp` — `z^λ ∘ e^λ = e^λ ∘ (z^λ · z^{-(λ,λ)})`: the cost of
    commuting the two halves, which is the operator form of the non-multiplicativity of the grading.
  * `MM.LatticeVOA.shiftedVertexTrunc_vacuum` and `…_II11_vacuum_ne_zero` — the **non-vacuity
    computation**: `Y(e^λ,z)` applied to the vacuum is `e^λ|0⟩ + e^λ ⊗ α^i_{-1}|0⟩` **with both
    scalars equal to `1`**, and it is nonzero; `…_II11_e2` exhibits the `μ`-dependence (the same
    operator keeps the summand `e^{e_2}` and kills `e^{e_1}`, because `(λ,e_2) = 1 ≠ 0 = (λ,e_1)`).
* `Definitions/MMLatticeVOATensorGrading.lean` — the same `z^λ` as a **standalone operator** with its
  own filtration theorem, by a different route:
  * `MM.LatticeVOA.LaurentPolynomial R := AddMonoidAlgebra R ℤ` (Laurent polynomials; a Laurent
    *series* with exponents unbounded below is not representable here, which is batch 24's
    `MM.not_isPWO_univ_int`) with `MM.LatticeVOA.monomial`, `coeff_monomial`,
    `monomial_mul_monomial`, `coeff_mul_monomial`.
  * `MM.LatticeVOA.shiftDegree x μ = (λ,λ)/2 + (λ,μ)` — the `μ`-dependent `z`-degree, i.e. the
    grading shift of the summand `e^μ ⊗ F`; `MM.LatticeVOA.gradingShift x s` extracts that coefficient
    **and moves the index to `λ + μ`**, so it is FLM's `e^λ z^λ` as one map.
  * **`MM.LatticeVOA.gradingShift_mem_gradedPartAtLeast`** — if every degree `k` of `s` satisfies
    `M ≤ N + k` then `gradingShift x s` maps the weight-`N` piece into the filtration piece of weight
    `≥ M`; the brief's `M + (λ,λ)/2 + N ≤ k` form is a **corollary** with the side condition
    `0 ≤ (λ,λ)/2 + 2N`, and that side condition is *necessary*
    (`gradingShift_mem_gradedPartAtLeast_of_support_le`).
  * `MM.LatticeVOA.monomial_halfNorm_mul` — the twisted group ring's law
    `z^{(λ,λ)/2} · z^{(μ,μ)/2} = z^{((λ+μ,λ+μ)/2) - (λ,μ)}`, i.e. `halfNorm_add` rearranged, and
    Borcherds' "`deg(ab) ≠ deg(a)+deg(b)`" at the ring level.  The *operator* multiplicativity law is
    **false** for both routes and is asserted nowhere.
* **Measured, and recorded in both files:** the truncated exponential's *lower* weight bound does not
  depend on `K`; `K` enters the upper bound (the stabilisation error parked in
  `Definitions/MMLatticeVOAExponential.lean`).  A brief that says `N - M ≤ K` justifies the
  filtration membership is wrong for an indefinite lattice (take `λ = e_1`, `μ = -e_2` in `II^{1,1}`).
  Also corrected: `Finsupp.add_apply` **does** exist in this pin (AGENTS.md said it did not). -/

/-- info: 'MM.LatticeVOA.shiftedVertexTrunc_single_mem' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.shiftedVertexTrunc_single_mem

/-- info: 'MM.LatticeVOA.shiftedVertexTrunc_mem_gradedPartAtLeast' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.shiftedVertexTrunc_mem_gradedPartAtLeast

/-- info: 'MM.LatticeVOA.weightMono_eOp_of_monoWeight_add' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.weightMono_eOp_of_monoWeight_add

/-- info: 'MM.LatticeVOA.latticeShift_comp_eOp' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.latticeShift_comp_eOp

/-- info: 'MM.LatticeVOA.shiftedVertexTrunc_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.shiftedVertexTrunc_vacuum

/-- info: 'MM.LatticeVOA.shiftedVertexTrunc_II11_vacuum_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.shiftedVertexTrunc_II11_vacuum_ne_zero

/-- info: 'MM.LatticeVOA.shiftedVertexTrunc_II11_e2' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.shiftedVertexTrunc_II11_e2

/-- info: 'MM.LatticeVOA.gradingShift_mem_gradedPartAtLeast' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.gradingShift_mem_gradedPartAtLeast

/-- info: 'MM.LatticeVOA.gradingShift_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.gradingShift_apply

/-- info: 'MM.LatticeVOA.monomial_halfNorm_mul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.monomial_halfNorm_mul

/-- info: 'MM.LatticeVOA.gradingShift_mem_gradedPartAtLeast_of_support_le' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.gradingShift_mem_gradedPartAtLeast_of_support_le

/-! ## Proved: the two-parameter stabilisation of the exponential, and the `VertexAlgebra1` obligation
as a named-input reduction (batch 29)

* **The statement batch 27 parked is now a THEOREM.**  `Definitions/MMLatticeVOAExponential.lean`'s
  section marker used to record, correctly, that the *two*-parameter stabilisation (outer order **and**
  window both raised) was not provable by the route available then and that no declaration asserted it.
  Batch 29 proved it:
  * **`MM.LatticeVOA.expTruncWindow_stabilises`** — for `K ≤ K'` and `v` of weight `≥ M`,
    `expTruncWindow i K' K' v − expTruncWindow i K K v` has weight `≥ M + K + 1`: raising both
    truncation parameters changes the value only by terms of order `> K`.
  * `MM.LatticeVOA.expTrunc_stabilises` — the same in the public `expTrunc` form (verbatim, since
    `expTrunc i N` *is* `expTruncWindow i N N`).
  * **The two engines it needed, both reusable:** `MM.LatticeVOA.expTruncWindow_inner_mem` (raise the
    *window* with the outer order fixed — the symmetric law the batch-27 marker named as the honest next
    step), and the general product bound `MM.LatticeVOA.mul_mem_raisesWeight_of_forall` (a product of
    factors, each raising the weight by at least `h i`, raises it by at least the largest of them, for
    nonnegative `h`).  The literal *equality* `expTrunc i K' v = expTrunc i K v` is still **false** (the
    newly opened modes act on the vacuum as the nonzero mode vectors) and is still asserted nowhere.
* **`Definitions/MMLatticeVOAInstance.lean`** — VLA-6, the `VertexAlgebra1` obligation as an honest
  **reduction** rather than a claimed instance:
  * `MM.LatticeVOA.LatticeVOAProvedInputs` with `latticeVOAProvedInputs` — the inputs that are
    **already theorems** (the Heisenberg relations, `α^i_k|0⟩ = 0` for `k ≥ 0`, coefficientwise
    locality, the vacuum/unit conditions, the cocycle twist/sign/diagonal laws, the shifted-vertex
    weight law), all supplied by proofs from the landed files.
  * `MM.LatticeVOA.LatticeVOAAssemblyInputs` with `nonempty_latticeVOAAssemblyInputs_iff` — the inputs
    that are **open** (the oscillator finiteness, the annihilation half's *convergence*, the state
    field, the Borcherds identity), each a precise `Prop` about the landed objects, and **no inhabitant
    is constructed**.  *(The two coefficient-family fields this bullet used to list were proved and
    moved to `LatticeVOAProvedInputs` in batch 30 — see the batch-30 section below.)*
  * `MM.LatticeVOA.VertexAlgebra1AtVacuum`, `coeff_zero_of_pinning`, `order_nonneg_of_pinning` and
    `vertexAlgebra1_atVacuum_of_inputs` — the vendor's four class fields restated with `vacuum` in place
    of `1` (the carrier is a bare `R`-module: this Mathlib pin has no `One (α → 0 M)` instance, and the
    paper's unit *is* the vacuum, `.tex:828--829`), with the two unit clauses **proved** from the
    pinning rather than assumed.
  * **The obstruction, measured and named:** `MM.LatticeVOA.not_isPWO_Iic_int`,
    `no_hahnSeries_of_Iic`, `oscillatorField_not_hahnSeries`, `oscDelta_not_hahnSeries` and
    `pointwiseBddBelow_oscillatorField_iff` (the vendored `of_coeff`'s `BddBelow` is *equivalent* to
    Borcherds' condition (1)), plus the concrete `expTrunc_II11_not_stable`.
* **A vendored name clash, found and repaired.**  `VertexAlg.VertexBasic.Defs` declared a
  root-namespace `poissonKernel`, colliding with Mathlib's `Analysis/Complex/Poisson.lean:55`, so the
  vendored `VertexAlgebra`/`VertexAlgebra1` interface could not be imported from **any** Mathlib-using
  file of this repository, in either order.  The vendored definition is referenced nowhere, so batch 29
  renamed it to `vertexPoissonKernel` (docstring in place); the interface now imports normally, measured
  together with `Mathlib.Analysis.Complex.Poisson` and MM's own locality module in one file.  *The
  first conclusion — "unusable, period" — was a false blocker, and the fix was one name.* -/

/-- info: 'MM.LatticeVOA.expTruncWindow_stabilises' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.expTruncWindow_stabilises

/-- info: 'MM.LatticeVOA.expTruncWindow_inner_mem' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.expTruncWindow_inner_mem

/-- info: 'MM.LatticeVOA.mul_mem_raisesWeight_of_forall' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.mul_mem_raisesWeight_of_forall

/-- info: 'MM.LatticeVOA.expTrunc_stabilises' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.expTrunc_stabilises

/-- info: 'MM.LatticeVOA.latticeVOAProvedInputs' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.latticeVOAProvedInputs

/-- info: 'MM.LatticeVOA.nonempty_latticeVOAAssemblyInputs_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.nonempty_latticeVOAAssemblyInputs_iff

/-- info: 'MM.LatticeVOA.vertexAlgebra1AtVacuum_of_inputs' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.vertexAlgebra1AtVacuum_of_inputs

/-- info: 'MM.LatticeVOA.pointwiseBddBelow_oscillatorField_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.pointwiseBddBelow_oscillatorField_iff

/-- info: 'MM.LatticeVOA.oscillatorField_not_hahnSeries' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.oscillatorField_not_hahnSeries

/-- info: 'MM.LatticeVOA.expTrunc_II11_not_stable' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.expTrunc_II11_not_stable

/-- info: 'MM.LatticeVOA.unit_right_oscillator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.unit_right_oscillator

/-! ## Proved: the two exponential halves as honest objects, and the reduction restated against the
vendored `VertexAlgebra1` (batch 30)

* **`Definitions/MMLatticeVOAExponentialField.lean`** — the coefficient families of FLM's two halves,
  `exp(Σ_{k>0} (1/k) α^i_{−k} z^k)` and `exp(Σ_{k>0} (1/k) α^i_k z^{−k})`, with the recurrences that
  define them (`creationCoeff_zero`/`_succ`, `annihilationCoeff_zero`/`_succ`) and the finiteness that
  makes them honest:
  * `MM.LatticeVOA.creationCoeff_mem_carrierAtMost` — `A_n` raises the **Fock level** by exactly `n`, so
    every coefficient is a finite object (the modes contributing to `z^n` are exactly
    `α^i_{−1}, …, α^i_{−n}`); the level filtration `carrierAtMost` is the tool, since it *is* `⊥` below
    zero, unlike the weight filtration on an indefinite lattice.
  * `MM.LatticeVOA.bddBelow_support_creationMode`, hence **`MM.LatticeVOA.creationField`, an
    UNCONDITIONAL `VertexOperator R (Carrier L r R)`** built with the vendor's `VertexOperator.of_coeff`,
    with `ncoeff_creationField` naming its coefficients — the creation half is no longer a hypothesis.
  * `MM.LatticeVOA.annihilationCoeff_apply_single_mono_eq_zero_of_lt` — the annihilation family is
    locally nilpotent on basis vectors (`n > monoWeight f` kills `e^λ ⊗ x^f`), giving
    `annihilationField` under the named predicate `AnnihilationLocallyNilpotent` for general vectors.
  * **A brief refuted, and it is the interesting kind:** the brief's claim that the *creation*
    coefficients eventually vanish is **FALSE** (`creationCoeff_apply_single_mono_eq_zero_of_lt_refuted`:
    `creationCoeff i (k+1)|0⟩ ≠ 0` for every `k`, since only the diagonal term survives the commutator
    `[α^i_{k+1}, α^i_{−(j+1)}] = (k+1)δ_{j,k}`).  The creation half is a power series with no constant
    input to bound it, which is exactly why the *truncations* never stabilise; the annihilation half
    *does* satisfy the brief's statement.
  * Non-vacuity: `creationField_II11_ne_zero`, `creationCoeff_two` (`(1/2)(α^i_{−1}² + α^i_{−2})`, the
    recurrence's own check), `creationField_vacuum`, `annihilationCoeff_vacuum`.
* **`Definitions/MMLatticeVOAInstance.lean`** now states its reduction against the **vendored**
  `VertexAlgebra.VertexAlgebra1` (the batch-29 transcription of `stateField`, `borcherdsSum1/2/3` and
  `borcherdsId` is **deleted** — the module imports `VertexAlg.VertexBasic.Defs` and `...Borcherds`,
  which import normally now that `poissonKernel` is renamed to `vertexPoissonKernel`), proves the two
  coefficient-family fields itself (`exists_creationHalfCoefficients`,
  `exists_annihilationHalfCoefficients`), moves them into `LatticeVOAProvedInputs` (15 proved fields),
  and adds `vertexAlgebra1AtVacuum_fields` / `vertexAlgebra1_fields_at_unit` /
  `vertexAlgebra1_fields_iff_atVacuum` — the field-level dictionary between the carrier's
  `VertexAlgebra1AtVacuum` (unit = the vacuum, since the carrier has no `One`) and the vendored class.
  **`LatticeVOAAssemblyInputs` is down to four OPEN fields** (from six):
  `oscillatorFiniteness`, `annihilationConverges`, `stateField`, `borcherdsIdentity`. -/

/-- info: 'MM.LatticeVOA.creationField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.creationField

/-- info: 'MM.LatticeVOA.ncoeff_creationField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.ncoeff_creationField

/-- info: 'MM.LatticeVOA.creationCoeff_succ' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.creationCoeff_succ

/-- info: 'MM.LatticeVOA.annihilationCoeff_apply_single_mono_eq_zero_of_lt' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.annihilationCoeff_apply_single_mono_eq_zero_of_lt

/-- info: 'MM.LatticeVOA.creationCoeff_apply_single_mono_eq_zero_of_lt_refuted' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.creationCoeff_apply_single_mono_eq_zero_of_lt_refuted

/-- info: 'MM.LatticeVOA.creationField_II11_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.creationField_II11_ne_zero

/-- info: 'MM.LatticeVOA.creationCoeff_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.creationCoeff_two

/-- info: 'MM.LatticeVOA.creationHalfCoefficients_discharged' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.creationHalfCoefficients_discharged

/-- info: 'MM.LatticeVOA.exists_creationHalfCoefficients' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.exists_creationHalfCoefficients

/-- info: 'MM.LatticeVOA.vertexAlgebra1_fields_iff_atVacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.vertexAlgebra1_fields_iff_atVacuum

/-- info: 'MM.LatticeVOA.latticeVOAProvedInputs' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.latticeVOAProvedInputs

/-! ## Proved: the Fock monomials span, `oscillatorFiniteness`, and the two-sided coefficient family
of `Y(e^λ,z)` (batch 31)

* **`Definitions/MMFockSpan.lean`** — the Fock-space monomial infrastructure that three batches had
  recorded as missing, and the finiteness it buys:
  * **`MM.Heisenberg.MonoSpan`** — `Submodule.span R (Set.range fun f => mono n R f) = ⊤`: the
    monomials *span* the Fock space `Sym(Mode n →₀ R)` as an `R`-module (not merely generate it as an
    algebra, which is what the repository had).  The route is `SymmetricAlgebra.induction`, **not** an
    `adjoin_range_ι` lemma — that name does not exist for `SymmetricAlgebra` in this pin (the brief
    said it did).
    `MM.Heisenberg.exists_mono_decomposition` and the carrier-level
    `MM.Heisenberg.exists_single_mono_decomposition` are its usable forms.
  * **`MM.Heisenberg.alphaOp_apply_eq_zero_of_le`** — **Borcherds' condition (1), `.tex:823`, on an
    ARBITRARY vector of the carrier** (the general form of batch 24's basis-vector statement), and
    **`MM.Heisenberg.oscillatorFiniteness`**, the first of the reduction's open fields, now discharged.
    The predicate `MM.LatticeVOA.OscillatorFiniteness` itself was moved down to
    `Definitions/MMLatticeVOA.lean` in this batch so that it sits above both the file that proves it and
    the file that consumes it (it had lived in the reduction file).
* **`Definitions/MMLatticeVOATwoSided.lean`** — the **two-sided** family of `Y(e^λ,z)`, i.e. FLM's
  `exp(Σ_{k>0}(1/k) α^i_{−k} z^k) · exp(Σ_{k>0}(1/k) α^i_k z^{−k})`:
  * the three commutators of the two truncated sums, with the mixed one **exactly computed**:
    `[annihilationSum i K, creationSum i K'] = (Σ_{k ≤ min K K'} (1/k)) • 1` — the harmonic number
    `H_{min(K,K')}`, checked at `K = K' = 1` against `[α^i_1, α^i_{−1}] = 1`;
  * the finite Weyl step `truncExp_annihilationSum_mul_creationSum` and its order-one case
    `truncExp_one_commutator`: the correction is **additive** (`+ c • 1`), not multiplicative — the
    brief's scaling form `exp(c)·exp(T)exp(S)` is **false** for truncations, and the true finite form
    `Σ_i (cⁱ/i!) • e_{N−i}(T) e_{N−i}(S)` is recorded as unproved with its obstruction;
  * **`MM.LatticeVOA.twoSidedCoeff`** — the coefficient family, well defined for every `n : ℤ`,
    because on `carrierAtMost M` only the finitely many `k ≤ M` contribute
    (`twoSidedCoeff_apply` gives that finite closed form); `bddBelow_support_twoSidedCoeff` discharges
    the vendor's `BddBelow` hypothesis, so **`MM.LatticeVOA.twoSidedField` is an UNCONDITIONAL
    `VertexOperator R (Carrier L r R)`** whose modes are `twoSidedCoeff`
    (`ncoeff_twoSidedField`), with the vacuum checks `twoSidedCoeff_vacuum_of_nonneg` /
    `…_of_neg` / `…_zero_vacuum`.
  * **A brief refuted:** "the coefficient of `z^n` is a finite combination of `B_j A_k` with `j,k` in a
    bounded region" is **FALSE** — `B_{n+k}A_k` has level shift `n` *independent of* `k`, so no level
    bound cuts the sum; what is true (and proved) is local finiteness on each `carrierAtMost M` with
    bound `M + 1`.  And `twoSidedCoeff_not_eventually_zero` shows the mode family does **not** vanish
    for large positive `n` (the asymmetry batch 30 measured on the creation side).

**Net effect on the reduction.**  `LatticeVOAAssemblyInputs` loses `oscillatorFiniteness` (proved
here) and its two coefficient-family fields were already proved in batch 30, so **three** open fields
remain: `annihilationConverges`, `stateField`, `borcherdsIdentity`.  `stateField` is now visibly
within reach: the two-sided family is a genuine `VertexOperator`, so what is missing there is the
*pinning* on the exponential states (`e^x`, `z^λ`), not the modes. -/

/-- info: 'MM.Heisenberg.MonoSpan' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.MonoSpan

/-- info: 'MM.Heisenberg.exists_single_mono_decomposition' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.exists_single_mono_decomposition

/-- info: 'MM.Heisenberg.alphaOp_apply_eq_zero_of_le' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.alphaOp_apply_eq_zero_of_le

/-- info: 'MM.Heisenberg.oscillatorFiniteness' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.Heisenberg.oscillatorFiniteness

/-- info: 'MM.LatticeVOA.annihilationLocallyNilpotent' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.annihilationLocallyNilpotent

/-- info: 'MM.LatticeVOA.annihilationSum_commutator_creationSum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.annihilationSum_commutator_creationSum

/-- info: 'MM.LatticeVOA.twoSidedCoeff_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.twoSidedCoeff_apply

/-- info: 'MM.LatticeVOA.twoSidedField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.twoSidedField

/-- info: 'MM.LatticeVOA.ncoeff_twoSidedField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.ncoeff_twoSidedField

/-- info: 'MM.LatticeVOA.twoSidedCoeff_not_eventually_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.twoSidedCoeff_not_eventually_zero

/-! ## Proved: a genuine `stateField`, and a REFUTED obligation repaired (batch 32)

* **`Definitions/MMLatticeVOAStateField.lean`** — the state-field correspondence's `stateField`
  obligation is now **satisfiable and satisfied**: `MM.LatticeVOA.stateFieldOnCarrier D` is a concrete
  `stateField R (Carrier L r R)`, built as a cheap "creative" term plus two correction terms that pin
  it, and `MM.LatticeVOA.stateFieldObligations` proves the four obligations for it —
  the oscillator pinning (`ncoeff_stateFieldOnCarrier_oscState`, unconditional via batch 31's
  `oscillatorFiniteness`), the exponential pinning at the chosen cover, `order_stateFieldOnCarrier`
  (the `v_n 1 = 0` clause) and `coeff_stateFieldOnCarrier_zero_vacuum` (the `v_{-1} 1 = v` clause).
  Packaged as `MM.LatticeVOA.nonempty_stateFieldObligations` and
  `forall_exists_stateFieldObligations` (a `Y` for **every** cover).
* **A false obligation, found and repaired — the second D0-shaped defect of this project.**
  `StateFieldObligations.pinningExponentials` used to quantify over **all** double covers `D`.  That
  form has **no inhabitant**: `eOp D x |0⟩ = e^x ⊗ |0⟩` is cover-*independent*
  (`MM.LatticeVOA.eOp_vacuum`) while `eOp D x` is not (the twist `ε'(x,y) = ε(x,y)·(-1)^{(x,y)}` is
  again a normalized two-cocycle with the same commutator —
  `MM.LatticeVOA.twistByForm`, `twistByForm_eps_ne`).  Proved:
  `MM.LatticeVOA.eOp_eq_of_pinning` and **`MM.LatticeVOA.not_stateFieldObligations_II11`**; and because
  `stateField` is one of its fields, `LatticeVOAAssemblyInputs` was **empty** at `II^{1,1}` over `ℚ`.
  The structure now carries the **`cover`** as a field (`LatticeVOAAssemblyInputs.cover`), which is what
  FLM's construction actually uses.  The stale emptiness theorem was *removed* rather than kept with a
  weakened proof, and the reason is recorded in its place.
* **`annihilationConverges` is discharged too** (`MM.LatticeVOA.annihilationConverges_holds`, moved down
  to `Definitions/MMLatticeVOAExponentialField.lean` so that the reduction file can consume it without a
  cycle): the Fock-level filtration is `⊥` below zero, so only finitely many annihilation modes act.
* **Net effect: `LatticeVOAAssemblyInputs` has ONE open obligation left, the Borcherds identity**, plus
  the cover as data. -/

/-- info: 'MM.LatticeVOA.stateFieldObligations' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.stateFieldObligations

/-- info: 'MM.LatticeVOA.nonempty_stateFieldObligations' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.nonempty_stateFieldObligations

/-- info: 'MM.LatticeVOA.forall_exists_stateFieldObligations' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.forall_exists_stateFieldObligations

/-- info: 'MM.LatticeVOA.not_stateFieldObligations_II11' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_stateFieldObligations_II11

/-- info: 'MM.LatticeVOA.eOp_eq_of_pinning' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.eOp_eq_of_pinning

/-- info: 'MM.LatticeVOA.annihilationConverges_holds' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.annihilationConverges_holds

/-- info: 'MM.LatticeVOA.oscVertexField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.oscVertexField

/-- info: 'MM.LatticeVOA.twoSidedField_ne_oscVertexField_of_nontrivial' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.twoSidedField_ne_oscVertexField_of_nontrivial

/-- info: 'MM.LatticeVOA.coeff_twoSidedField_zero_oscState' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.coeff_twoSidedField_zero_oscState

/-- info: 'MM.LatticeVOA.nonempty_latticeVOAAssemblyInputs_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.nonempty_latticeVOAAssemblyInputs_iff

/-! ## Proved: the witness, and the BORCHERDS OBLIGATION MEASURED — including a refutation (batch 33)

* **`Definitions/MMLatticeVOAVertexAlgebra.lean`** — the witness file: `MM.LatticeVOA.VertexAlgebra1Witness`
  collects the cover, the concrete field `stateFieldOnCarrier D` and the obligations it satisfies, with
  `MM.LatticeVOA.witness` unconditional (the three provable class fields: the two unit axioms from batch
  32 and the pinning) and `VertexAlgebra1WitnessWithBorcherds` / `witness_of_borcherds` carrying the
  Borcherds obligation as an explicit **open** hypothesis.  `vertexAlgebra1AtVacuum_of_witness` and
  `nonempty_vertexAlgebra1AtVacuum_of_witness` go to the vendored class's shape, and
  `nonempty_atVacuum_iff_fields` records exactly what an inhabitant needs.  No `instance` anywhere.
* **`Definitions/MMLatticeVOABorcherds.lean`** — the last obligation, **measured**, and the result is a
  refutation rather than a proof: **our `stateFieldOnCarrier` does NOT satisfy the Borcherds identity.**
  * `MM.LatticeVOA.borcherdsIdAtVacuum` — the identity at the concrete field, as a named `Prop`.
  * `MM.LatticeVOA.borcherdsSum1/2/3_counterexample` and
    **`MM.LatticeVOA.not_borcherdsIdAtVacuum_vacuum_right`** — at `a = oscState 0`, `b = c = vacuum`,
    `(m,n,q) = (-2,0,-2)` (the smallest case), the three sums are `-2 • α⁰_{-3}|0⟩`, `0`, `0`, so the
    identity fails for **every** `L` and every cover `D` at `r = 1`, `R = ℚ`.
  * **`MM.LatticeVOA.obligationsAt_and_not_borcherdsIdAtVacuum`** — **THE HEADLINE**: there is a field
    satisfying the *entire* batch-32 pinning (`StateFieldObligationsAt`) for which the Borcherds identity
    is FALSE.  Consequence: **the assembly cannot be completed by any further lemma about this field** —
    the field itself has to be corrected on the vacuum tail.
  * The missing input is named: `MM.LatticeVOA.VacuumTranslationRecursion` — the translation covariance
    `[z^m] Y a |0⟩ = D^m a / m!`, which a genuine vertex operator satisfies and an arbitrary linear
    extension does not.  It is **refuted** for `stateFieldOnCarrier` (`not_vacuumTranslationRecursion`),
    and it is *none* of the three obstructions the brief guessed (not commutation, not the order bound —
    which is PROVED here — and not the two-variable `δ(z-w)` ring).
  * Also landed: the order bounds the vendor's `Finset.range` needs
    (`exists_ncoeff_oscField_eq_zero`, `exists_ncoeff_stateFieldOnCarrier_eq_zero`).
* **What this changes for the programme.**  The reduction's last obligation is not "prove the Borcherds
  identity for the pinned field": that statement is false.  What is needed is FLM's actual field
  (translation-covariant, hence built from the untruncated exponential and the two-variable ring), and
  the honest target is the identity for *that* field. -/

/-- info: 'MM.LatticeVOA.witness' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.witness

/-- info: 'MM.LatticeVOA.vertexAlgebra1AtVacuum_of_witness' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.vertexAlgebra1AtVacuum_of_witness

/-- info: 'MM.LatticeVOA.nonempty_vertexAlgebra1AtVacuum_of_witness' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.nonempty_vertexAlgebra1AtVacuum_of_witness

/-- info: 'MM.LatticeVOA.not_borcherdsIdAtVacuum_vacuum_right' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_borcherdsIdAtVacuum_vacuum_right

/-- info: 'MM.LatticeVOA.obligationsAt_and_not_borcherdsIdAtVacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.obligationsAt_and_not_borcherdsIdAtVacuum

/-- info: 'MM.LatticeVOA.borcherdsSum1_counterexample' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsSum1_counterexample

/-- info: 'MM.LatticeVOA.not_vacuumTranslationRecursion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_vacuumTranslationRecursion

/-- info: 'MM.LatticeVOA.exists_ncoeff_stateFieldOnCarrier_eq_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.exists_ncoeff_stateFieldOnCarrier_eq_zero

/-! ## Proved: the last obligation, measured on three candidate fields (batches 34--36)

The reduction's last obligation is the Borcherds identity.  Four batches have now built a candidate
state field, tested the identity on it, and measured what is missing.  The verdicts are all theorems:

| candidate | pinning (batch 32's `StateFieldObligationsAt`) | translation covariance | Borcherds identity |
| --- | --- | --- | --- |
| `MM.LatticeVOA.stateFieldOnCarrier D` (batch 32) | **YES** | **NO** (`not_translationCovariantAt_stateFieldOnCarrier`) | **FAILS** (batch 33) |
| `MM.LatticeVOA.covariantField` (batch 34) | **NO** (`not_pinningOscillators_covariantField`) | **YES** (`translationCovariant_covariantField`) | **FAILS at `(-1,-1,0)`** (batch 35-A) |
| `MM.LatticeVOA.compatField` (batch 35-B) | **YES** | **YES** | **FAILS** (batch 36) |

* `Definitions/MMLatticeVOATranslation.lean` (batch 34) — the translation operator `translate` (the
  carrier `D`, `= MM.Heisenberg.L (-1)`), the named property `TranslationCovariantAt`, the covariant
  coefficient family `covariantCoeff`/`covariantField`, and **`exists_translationCovariant`**: a
  translation-covariant linear state field EXISTS (`[z^m] Y a |0⟩ = D^m a / m!` for every `m ≥ 0`, zero
  below).  Batch 33's `VacuumTranslationRecursion` is *implied* by it
  (`vacuumTranslationRecursion_of_covariant`).  The dispatcher's hypothesis that linearity and
  covariance clash was **refuted** — there is no obstruction at any state.
* `Definitions/MMLatticeVOAIncompatibility.lean` (batch 35-B) — the *first* separating coefficient:
  `covariantField` misses the oscillator pinning already at `n = 1`
  (`ncoeff (covariantField (oscState i)) 1 = 0` while `α^i_1(α^i_{−1}|0⟩) = |0⟩ ≠ 0`), and the brief's
  guessed clash at `n = 3` **does not exist**.  Then the positive result: **`compatField`**, built as an
  oscillator part plus a correction, satisfies the pinning AND the covariance AND `[z^0]·|0⟩ = a` —
  **`exists_pinningAndCovariant`**, so the two desiderata are *not* incompatible.
* `Definitions/MMLatticeVOACovariantBorcherds.lean` (batch 35-A) — the identity on the covariant field:
  it **HOLDS** at batch 33's own counterexample `(-2,0,-2)` and at four other triples (`C(-2,1) = -2`
  cancels `1/2!`), and **FAILS at `(-1,-1,0)`**, where it is equivalent to `a = carrierAug a • |0⟩` for
  every `a` (`borcherdsId_neg_one_neg_one_zero_iff`, `eq_carrierAug_smul_vacuum_of_borcherdsId`).  The
  structural reason: at that triple the identity plus the two unit axioms forces
  `ncoeff (Y |0⟩) (-1) = id`, the **LEFT unit axiom** `Y(1,z) = id` — which no rank-one field supplies.
* `Definitions/MMLatticeVOACompatBorcherds.lean` (batch 36-A) — the same test on `compatField`: it fails
  at the same triple, by the same rank-one argument, **because the oscillator part of `compatField` kills
  the vacuum**; the identity's `b = c = vacuum` case is *equivalent* to the covariant field's at every
  triple (`borcherdsId_vacuum_right_congr`), so nothing there separates the two fields.
* `Definitions/MMLatticeVOAReductionCovariant.lean` (batch 36-B) — the reduction restated at the best
  available field, with **`not_compatBorcherdsIdentity`** (independent proof, from the landed layer:
  the identity plus `coeff_zero_vacuum_compatField` and `unitComm_compatField` forces
  `ncoeff (compatField |0⟩) (-1) = id`, but that mode is the rank-one `carrierAug · • |0⟩`), plus the
  **complementary defects**: `ncoeff (stateFieldOnCarrier D |0⟩) (-1) = LinearMap.id` (so batch 32's
  field HAS the left unit axiom) while `compatField` has the covariance — each field has exactly what
  the other lacks, and `compatField_ne_stateFieldOnCarrier`.  A PROPERTY TABLE is the file's header.

**What is left, in one line.**  Not translation covariance (it exists), not the pinning (it is
satisfiable together with covariance), and not a missing mode lemma: it is the **left unit axiom**
`Y(1,z) = id` together with the identity's `(-1,-1,0)` coefficient — and every field assembled from the
landed pieces fails it, because the correction terms that fix the vacuum column are rank one. -/

/-- info: 'MM.LatticeVOA.exists_translationCovariant' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.exists_translationCovariant

/-- info: 'MM.LatticeVOA.translationCovariant_covariantField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.translationCovariant_covariantField

/-- info: 'MM.LatticeVOA.not_translationCovariantAt_stateFieldOnCarrier' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_translationCovariantAt_stateFieldOnCarrier

/-- info: 'MM.LatticeVOA.exists_pinningAndCovariant' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.exists_pinningAndCovariant

/-- info: 'MM.LatticeVOA.not_pinningOscillators_covariantField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_pinningOscillators_covariantField

/-- info: 'MM.LatticeVOA.eq_carrierAug_smul_vacuum_of_borcherdsId' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.eq_carrierAug_smul_vacuum_of_borcherdsId

/-- info: 'MM.LatticeVOA.not_covariantIdAtVacuum_rank_one_rat' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_covariantIdAtVacuum_rank_one_rat

/-- info: 'MM.LatticeVOA.not_compatBorcherdsIdentity' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_compatBorcherdsIdentity

/-- info: 'MM.LatticeVOA.not_compatField_leftUnit' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_compatField_leftUnit

/-- info: 'MM.LatticeVOA.not_stateFieldObligationsAt_compatField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_stateFieldObligationsAt_compatField

/-- info: 'MM.LatticeVOA.compatField_ne_stateFieldOnCarrier' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.compatField_ne_stateFieldOnCarrier

/-! ## Proved: the input list is EXACT, and a one-column field satisfies the failing coefficient (batch 37)

* `Definitions/MMLatticeVOALeftUnit.lean` (970 lines) -- the left unit axiom `Y(1,z) = id`, named as a
  first-class input of the reduction (`MM.LatticeVOA.LeftUnitAxiom`, an `abbrev` for the batch-35
  statement -- nothing redeclared), with the link the refutations used
  (`LeftUnitImpliesIdentityAt_neg_one_neg_one_zero`), and **the input list made provably exact**:
  * `MM.LatticeVOA.borcherdsIdAt_neg_one_neg_one_zero_vacuum_right_iff_leftUnitAxiom` and
    **`leftUnitAxiom_iff_identityAt_neg_one_neg_one_zero`** -- given the two unit axioms, the left unit
    axiom is *equivalent* to the `(-1,-1,0)` instance of the Borcherds identity.  So it is not a guess
    that the axiom belongs on the list: it is forced;
  * `MM.LatticeVOA.BorcherdsInputsComplete` -- (i) the batch-32 pinning, (ii) the left unit axiom,
    (iii) the identity -- with the reduction `vertexAlgebra1AtVacuum_of_borcherdsInputs`, and
    `not_borcherdsInputsComplete_compatField`;
  * **the table, as theorems**: `stateFieldOnCarrier_profile`, `covariantField_profile`,
    `compatField_profile` and `table_rank_one_rat`, with the one missing cell supplied
    (`not_leftUnitAxiom_covariantField`);
  * `MM.LatticeVOA.exists_leftUnit_not_identity_general_b` -- a field over `ℚ` on `II^{1,1}` carrying the
    left unit axiom and both unit axioms that still fails the identity at `(-1,-1,0)` with **general**
    `b`: the brief's "for every `a`, `b`" was false, and the true statement (proved under the frozen
    name) is the `b = c = vacuum` form.
  * **The correction this batch records**: the batch-32 field *passes* the left unit axiom and the
    pinning and fails only the identity -- and at `(-1,-1,0)` it *satisfies* it
    (`borcherdsId_neg_one_neg_one_zero_stateFieldOnCarrier`); its failure is at `(-2,0,-2)`.  The left
    unit axiom is what `covariantField` and `compatField` lack, not what the batch-32 field lacks.
* `Definitions/MMLatticeVOALeftUnitField.lean` (1142 lines) -- the **one-column family**
  `singleCoeffField` / `idColumnField` (`[z^0] = carrierAug a • id`, every other coefficient `0`):
  * the dispatcher's proposed constant family is **not a state field** and that is a theorem
    (`not_exists_stateField_const_one`: a constant family is not `R`-linear in the state); the repair
    (`hahnSingle (carrierAug a • LinearMap.id)`) is forced;
  * it satisfies the **left unit axiom** (`leftUnitAxiom_idColumnField`) and is **not rank one**
    (`vacuumColumn_idColumnField_not_rankOne`), and it **satisfies the identity at `(-1,-1,0)`**
    (`idColumnIdAtVacuum_vacuum_right`) as well as at the five triples batch 35-A listed and at
    `(-2,-1,1)` -- so the coefficient that killed every previous candidate is satisfiable;
  * **the exact reduction of the whole family**: `borcherdsId_singleCoeffField_iff` collapses each
    Borcherds sum to one term, and at `(-1,-1,0)` the identity is *exactly*
    `S a (T |0⟩) = T (S a |0⟩)` -- **linear in the column `T`** -- which with `unit_right` forces
    `T = id` (unique), while without the unit axioms it has many solutions.  The still-open step is two
    coefficient facts about `Ring.choose` at two-live-sum triples, recorded with their exact shapes;
  * what it still fails: `unit_right`, the oscillator pinning and both covariances
    (`not_unitRight_idColumnField`, `not_pinningOscillators_idColumnField`,
    `not_translationCovariantAt_idColumnField`).

**Where the input list stands.**  Four candidate fields, four different profiles, and no field has all
of (i) pinning, (ii) covariance, (iii) left unit, (iv) the identity.  What is now *provably* exact is
that (iii) is equivalent to the `(-1,-1,0)` coefficient of (iv), so the list cannot be shortened. -/

/-- info: 'MM.LatticeVOA.leftUnitAxiom_iff_identityAt_neg_one_neg_one_zero' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.leftUnitAxiom_iff_identityAt_neg_one_neg_one_zero

/-- info: 'MM.LatticeVOA.LeftUnitImpliesIdentityAt_neg_one_neg_one_zero' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.LeftUnitImpliesIdentityAt_neg_one_neg_one_zero

/-- info: 'MM.LatticeVOA.leftUnitAxiom_stateFieldOnCarrier' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.leftUnitAxiom_stateFieldOnCarrier

/-- info: 'MM.LatticeVOA.not_leftUnitAxiom_covariantField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_leftUnitAxiom_covariantField

/-- info: 'MM.LatticeVOA.exists_leftUnit_not_identity_general_b' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.exists_leftUnit_not_identity_general_b

/-- info: 'MM.LatticeVOA.vertexAlgebra1AtVacuum_of_borcherdsInputs' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.vertexAlgebra1AtVacuum_of_borcherdsInputs

/-- info: 'MM.LatticeVOA.leftUnitAxiom_idColumnField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.leftUnitAxiom_idColumnField

/-- info: 'MM.LatticeVOA.vacuumColumn_idColumnField_not_rankOne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.vacuumColumn_idColumnField_not_rankOne

/-- info: 'MM.LatticeVOA.idColumnIdAtVacuum_vacuum_right' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.idColumnIdAtVacuum_vacuum_right

/-- info: 'MM.LatticeVOA.not_exists_stateField_const_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_exists_stateField_const_one

/-- info: 'MM.LatticeVOA.borcherdsId_singleCoeffField_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsId_singleCoeffField_iff

/-! ## Proved: a field with ALL THREE properties, and the identity holding at the coefficient that killed
the others (batch 38)

`Definitions/MMLatticeVOAThreeProperty.lean` (885 lines) builds `MM.LatticeVOA.threePropertyField` and
proves, in one theorem:

  `MM.LatticeVOA.threeProperty_threePropertyField` —
  `StateFieldObligationsAt L r R D Y ∧ TranslationCovariant L r R Y ∧ LeftUnitAxiom L r R Y`

i.e. for the first time in this thread a single field has the **pinning**, the **translation
covariance** AND the **left unit axiom** at once (and `exists_threeProperty` packages it).  Its vacuum
column is batch 37-B's `idColumnField` column exactly:
`ncoeff (Y |0⟩) t = if t = -1 then 1 else 0` (`ncoeff_threePropertyField_vacuum`), and
`[z^m] Y a |0⟩ = D^m a / m!` for `m ≥ 0`.

**And the identity holds at the three triples computed, including the one that killed `covariantField`
and `compatField`** (all with `b = c = vacuum`, for every `L`, `r` and every `ℚ`-algebra `R`):

| triple | sums | identity |
| --- | --- | --- |
| `(-1,-1,0)` | `0`, `a`, `-a` | **HOLDS** (`borcherdsId_threePropertyField_neg_one_neg_one_zero`) |
| `(-2,0,-2)` | `0`, `0`, `0` | **HOLDS** (`…_neg_two_zero_neg_two`) |
| `(-1,-1,-2)` | `D²a/2`, `D²a/2`, `0` | **HOLDS** (`…_neg_one_neg_one_neg_two`) |

`borcherdsSum3_threePropertyField_ne_covariantField_rank_one` witnesses the structural difference from
`covariantField` at `a = α⁰_{−1}|0⟩` (there `0`, here `-α⁰_{−1}|0⟩ ≠ 0`).

**The dispatcher's prescription for the repair was wrong, and the agent said so.**
It said to fix the vacuum coefficients `[z^m]` for `m ≠ 0`; those are *already* `0` on `|0⟩` because
`D|0⟩ = 0`, so nothing there needed fixing.  The actual defect is the `z^0` coefficient on the
**exponential states** `e^x|0⟩`, and the correction is
`Σ_x fockAug(a x) • (eOp D x - carrierAug · • (e^x ⊗ |0⟩))` on the exponent-`0` coefficient only.  The
only compatibility input is `eOp D 0 = id` (`eOp_zero`), where the pinning at `x = 0` and the left unit
axiom meet.  *A fifth consecutive brief with a wrong headline, and a fifth useful refutation.*

`Definitions/MMLatticeVOAColumnFreedom.lean` lands the standalone coefficient facts that the batch-37
closed form needed (`ring_choose_eq_zero_of_toNat_lt`, `two_live_sum_choose_eq`,
`two_live_sum_negOnePow_eq_neg`, `live_sum1/2/3_choose_eq_zero`, `negOnePow_smul_coeff_add_iff`); its
general-triple closed form is the next increment. -/

/-- info: 'MM.LatticeVOA.threeProperty_threePropertyField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.threeProperty_threePropertyField

/-- info: 'MM.LatticeVOA.borcherdsId_threePropertyField_neg_one_neg_one_zero' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsId_threePropertyField_neg_one_neg_one_zero

/-- info: 'MM.LatticeVOA.borcherdsId_threePropertyField_neg_two_zero_neg_two' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsId_threePropertyField_neg_two_zero_neg_two

/-- info: 'MM.LatticeVOA.borcherdsId_threePropertyField_neg_one_neg_one_neg_two' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsId_threePropertyField_neg_one_neg_one_neg_two

/-- info: 'MM.LatticeVOA.ncoeff_threePropertyField_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.ncoeff_threePropertyField_vacuum

/-- info: 'MM.LatticeVOA.leftUnitAxiom_threePropertyField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.leftUnitAxiom_threePropertyField

/-- info: 'MM.LatticeVOA.translationCovariant_threePropertyField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.translationCovariant_threePropertyField

/-- info: 'MM.LatticeVOA.stateFieldObligationsAt_threePropertyField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.stateFieldObligationsAt_threePropertyField

/-- info: 'MM.LatticeVOA.two_live_sum_choose_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.two_live_sum_choose_eq

/-! ## Proved: the Borcherds identity for `threePropertyField` at `b = c = vacuum`, ALL triples (batch 39)

`Definitions/MMLatticeVOAThreePropertyIdentity.lean` (1012 lines) closes the general case the thread had
been reducing to:

* **`MM.LatticeVOA.borcherdsId_threePropertyField_vacuum_right`** — for **every** state `a` and **every**
  triple `(rr,ss,tt)`, the Borcherds identity holds at `threePropertyField` with `b = c = vacuum`.
  With `K = -rr-ss-tt-2`, `A = -tt-1`, `u = -ss-1` the three sums are computed in closed form
  (`borcherdsSum1/2/3_threePropertyField_closed`):
  `sum1 = [0≤A ∧ 0≤K]·C(-ss-tt-2,A)·(1/K!)·D^K a`,
  `sum2 = [ss≤-1 ∧ 0≤K]·(-1)^u·C(tt,u)·(1/K!)·D^K a`,
  `sum3 = [ss+tt+1≥0 ∧ 0≤K]·(-1)^ss·C(tt,ss+tt+1)·(1/K!)·D^K a`,
  all zero for `K < 0`; the residue is the `ℤ` coincidence `threeProperty_scalar_identity`.  The
  landing also **reproduces batch 38's three triples from the closed form** (the regression check
  `…'`), and the whole family was cross-checked against an independent `Fraction` model over `[-7,7]³`
  (3375 triples, no failures).
* **The named residual**: **`MM.LatticeVOA.ThreePropertyIdentityGeneralStates`** — the identity for
  general `b`, which the agent measured to be **not reachable from the landed layer**: for `b ≠ |0⟩`
  neither `order (Y a) b` nor `ncoeff (Y (ncoeff (Y a) t b)) s c` is computable from the two pinned
  families, so `borcherdsSum1` is not a one-term collapse there (at `(-3,-3,-5)` its range has five live
  terms — a **refutation of the brief's own "one-term collapse" claim**).  Consequently
  `LatticeVOAAssemblyInputs.borcherdsIdentity` — which quantifies over **every** pinned `Y` — is *not*
  discharged by this; what is discharged is the field-level statement, and
  `borcherdsInputsComplete_threePropertyField_iff` records exactly how the two differ.
* `Definitions/MMLatticeVOAColumnFreedom.lean` (200 → 849 lines) now carries the **complete closed form
  for the one-column family**, `MM.LatticeVOA.borcherdsId_singleCoeffField_iff_closed`: the identity
  holds at every triple *except* those with `rr+ss+tt = -2` and two exponents `≤ -1`, where it reduces
  to one of three explicit coefficient conditions.  **A correction of record**: batch 37-B's header said
  the two live terms are always *opposite*; that describes only the region `rr,ss ≤ -1` — the regions
  `ss,tt ≤ -1` and `rr,tt ≤ -1` have **equal** coefficients and their terms **add**, needing two
  `Ring.choose_neg` facts the earlier analysis never identified (both now landed).  Also landed:
  **`vacuumColumn_eq_id_iff_identityAt_neg_one_neg_one_zero`** — with `unit_right`, the vacuum column is
  `id` **iff** the `(-1,-1,0)` instance holds — and the non-vacuity exhibit
  `exists_vacuumColumn_ne_id_and_identityAt_neg_one_neg_one_zero` (the zero column satisfies the bare
  instance while `unit_right` fails). -/

/-- info: 'MM.LatticeVOA.borcherdsId_threePropertyField_vacuum_right' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsId_threePropertyField_vacuum_right

/-- info: 'MM.LatticeVOA.borcherdsSum1_threePropertyField_closed' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsSum1_threePropertyField_closed

/-- info: 'MM.LatticeVOA.borcherdsSum2_threePropertyField_closed' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsSum2_threePropertyField_closed

/-- info: 'MM.LatticeVOA.borcherdsSum3_threePropertyField_closed' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsSum3_threePropertyField_closed

/-- info: 'MM.LatticeVOA.borcherdsId_singleCoeffField_iff_closed' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsId_singleCoeffField_iff_closed

/-- info: 'MM.LatticeVOA.vacuumColumn_eq_id_iff_identityAt_neg_one_neg_one_zero' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.vacuumColumn_eq_id_iff_identityAt_neg_one_neg_one_zero

/-- info: 'MM.LatticeVOA.exists_vacuumColumn_ne_id_and_identityAt_neg_one_neg_one_zero' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.exists_vacuumColumn_ne_id_and_identityAt_neg_one_neg_one_zero

/-- info: 'MM.LatticeVOA.not_pinningOscillators_singleCoeffField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_pinningOscillators_singleCoeffField

/-! ## Proved: the FIRST-state-vacuum case of the identity for ALL states, and the general-\(b\) machinery
(batch 40)

* **`Definitions/MMLatticeVOAShortcut.lean` (975 lines) — the biggest single advance of the thread since
  batch 38.**  With the **first** state the vacuum, the three Borcherds sums for `threePropertyField`
  **all collapse to the same vector** `V = ncoeff (Y b) (rr+ss+tt+1) c`:
  `sum1 = [tt≤-1]·C(rr,-tt-1)•V`, `sum2 = [0≤rr+tt+1]•(-1)^{rr+tt+1}C(tt,rr+tt+1)•V`,
  `sum3 = [rr≤-1]•(-1)^{tt-rr}C(tt,-rr-1)•V`.  The identity is therefore a pure `ℤ`
  `Ring.choose` coincidence, `MM.LatticeVOA.choose_three_term_identity`, proved by four sign cases —
  and hence **`MM.LatticeVOA.borcherdsId_threePropertyField_vacuum_left`: the identity holds with the
  first state the vacuum, for ALL `b`, `c` and ALL triples.**  So the identity is now proved in the two
  "one-state-vacuum" regions, and the residual is the *mixed* region, named exactly as
  `threePropertyIdentityGeneralStates_iff_mixed`.
  * **A refutation of this batch's brief**: the hoped equivalence ("the `b = c = vacuum` case plus the
    two unit axioms gives general `b`") is false in **both** directions —
    `exists_vacuum_identity_not_general_b` exhibits a field where the vacuum case holds and the general
    case fails, strengthening batch 37-A's witness.  The missing input is skew-symmetry at `-1`.
  * `LocalityDiagonalBridge` names the exact implication locality would need; the measured reason it is
    not available is that the vendor's `locality_left/right_eq_borcherdsSum2/3` are *diagonal* sums with
    a truncation `toNat (N+1-order Y b c)`, not the coefficientwise `IsLocalToOrderLeq`.  The pinned
    oscillator pairs *are* local unconditionally (`isLocalToOrderLeq_threePropertyField_oscState_two`).
  * `BorcherdsSumRecursions` names the (vendor-commented-out) sum recursions; a random bilinear `ℚ³`
    model satisfied all three on 567 triples while the identity itself failed 534 of them — so the
    recursions are not vacuous and not sufficient.
* **`Definitions/MMLatticeVOAOrderGeneral.lean` (514 lines) — the bottleneck computed.**  The master
  formula `MM.LatticeVOA.ncoeff_threePropertyField` gives `ncoeff (Y a) t b` in three explicit regions
  (oscillator sum, covariance correction at `t ≤ -1`, and the `t = -1` correction), with no occurrence of
  `Y` at `a` or `b` left in the composite.  Consequences: `ncoeff (Y a) 0 = 0` for **every** state, the
  support is bounded above by the level bound, hence
  **`-1 - max (levelBound b) 0 ≤ order (Y a) b`** for arbitrary pairs, and **all three sums vanish at
  every `(0, ss, 0)` for all `a b c`** — a general-states family disjoint from batch 39's, with the
  batch-39 instance re-derived as the regression test.  The header records what is *not* available:
  the exact `order` (the covariance correction recurs at every `t ≤ -1`), and the `c = vacuum` family's
  residual arithmetic. -/

/-- info: 'MM.LatticeVOA.borcherdsId_threePropertyField_vacuum_left' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsId_threePropertyField_vacuum_left

/-- info: 'MM.LatticeVOA.choose_three_term_identity' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.choose_three_term_identity

/-- info: 'MM.LatticeVOA.exists_vacuum_identity_not_general_b' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.exists_vacuum_identity_not_general_b

/-- info: 'MM.LatticeVOA.borcherdsId_threePropertyField_zero_ss_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsId_threePropertyField_zero_ss_zero

/-- info: 'MM.LatticeVOA.ncoeff_threePropertyField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.ncoeff_threePropertyField

/-- info: 'MM.LatticeVOA.ncoeff_threePropertyField_comp' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.ncoeff_threePropertyField_comp

/-- info: 'MM.LatticeVOA.order_threePropertyField_ge_levelBound' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.order_threePropertyField_ge_levelBound

/-- info: 'MM.LatticeVOA.ncoeff_threePropertyField_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.ncoeff_threePropertyField_zero

/-! ## Refuted: the mixed region of the identity, and the reduction's own obligation (batch 41)

Two fresh agents, verified by the dispatcher compiling from source, wired into `FinalCheck.lean` with
**9 new guards**.  Both results are **refutations**, and both are major.

* **`Definitions/MMLatticeVOASkewSymmetry.lean` (818 lines) — the mixed region is REFUTED.**  Writing
  `S` for the `(-1)`-mode bilinear form (`ncoeff (Y a) (-1) b`), the identity at the mixed triple
  `(-1,-1,0)` is *equivalent* to the **symmetry** of `S`
  (`MM.LatticeVOA.borcherdsId_neg_one_neg_one_zero_iff_S_eq`,
  `…_vacuum_third_iff_S_eq`) — and for an **odd** pair of lattice vectors that symmetry is **false**:
  `S (e^{e_1}) (e^{e_2}) = ε(e_1,e_2) • e^{e_1+e_2}|0⟩` while
  `S (e^{e_2}) (e^{e_1}) = ε(e_2,e_1) • e^{e_1+e_2}|0⟩`, and
  `ε(x,y)ε(y,x) = (-1)^{(x,y)} = -1` (`S_exp_exp`, `not_S_symm_exp`).  Hence, for `L = II^{1,1}`,
  `r = 2`, `R = ℚ` and **every** double cover `D`,
  **`not_borcherdsId_threePropertyField_II11`**: the identity fails at `(-1,-1,0)` with
  `a = e^{e_1}|0⟩`, `b = e^{e_2}|0⟩`, `c = |0⟩` (sums `0`, `S a b`, `-S b a`).  Consequently batch 39's
  `ThreePropertyIdentityGeneralStates` and batch 40's `ThreePropertyIdentityVacuumRightResidual` are
  **false** (`not_threePropertyIdentityGeneralStates_II11`,
  `not_threePropertyIdentityVacuumRightResidual_II11`) — the residual was not missing arithmetic.
  The **oscillator** pair is fine: `borcherdsId_threePropertyField_oscState_neg_one_neg_one_zero` shows
  the identity HOLDS there unconditionally; the failure needs the *exponential* states of an odd pair.
  A brief error of record: the dispatcher's `S` was typed as an endomorphism; it is a **bilinear form**,
  and the property the mixed region needs is its **symmetry**.
* **`Definitions/MMLatticeVOAReductionClosed.lean` (577 lines) — the reduction's own obligation is
  FALSE, not merely unproved.**  `LatticeVOAAssemblyInputs.borcherdsIdentity` quantifies over **every**
  pinned `Y`; `MM.LatticeVOA.reductionClosed_not_forall_pinned_borcherdsId_rank_one_rat` refutes that at
  `r = 1`, `R = ℚ`, for **every** lattice and cover — batch 33's witness
  (`obligationsAt_and_not_borcherdsIdAtVacuum`: a pinned field whose identity fails) is exactly what was
  needed, and the combination had simply never been made.  Hence
  **`reductionClosed_not_nonempty_latticeVOAAssemblyInputs_rank_one_rat :
  ¬ Nonempty (LatticeVOAAssemblyInputs L 1 ℚ)`** — the assembly structure is **empty** at those
  parameters, so `vertexAlgebra1AtVacuum_of_inputs` is **vacuous** there.  The file also lands the honest
  final input list: `SkewSymmetryInput` (`∀ a b, 0 ≤ order Y a b → ncoeff (Y a) (-1) b =
  ncoeff (Y b) (-1) a`, equivalent to the `(-1,-1,0)`-with-vacuum-third-state slice of the identity),
  `VertexAlgebraInputsFinal` (equivalent to `BorcherdsInputsComplete` **both ways**, so the list
  duplicates nothing), and the exact status of each field. -/

/-- info: 'MM.LatticeVOA.not_borcherdsId_threePropertyField_II11' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_borcherdsId_threePropertyField_II11

/-- info: 'MM.LatticeVOA.not_S_symm_exp' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_S_symm_exp

/-- info: 'MM.LatticeVOA.S_exp_exp' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.S_exp_exp

/-- info: 'MM.LatticeVOA.borcherdsId_neg_one_neg_one_zero_iff_S_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsId_neg_one_neg_one_zero_iff_S_eq

/-- info: 'MM.LatticeVOA.borcherdsId_threePropertyField_oscState_neg_one_neg_one_zero' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsId_threePropertyField_oscState_neg_one_neg_one_zero

/-- info: 'MM.LatticeVOA.not_threePropertyIdentityGeneralStates_II11' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_threePropertyIdentityGeneralStates_II11

/-- info: 'MM.LatticeVOA.reductionClosed_not_forall_pinned_borcherdsId_rank_one_rat' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.reductionClosed_not_forall_pinned_borcherdsId_rank_one_rat

/-- info: 'MM.LatticeVOA.reductionClosed_not_nonempty_latticeVOAAssemblyInputs_rank_one_rat' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.reductionClosed_not_nonempty_latticeVOAAssemblyInputs_rank_one_rat

/-- info: 'MM.LatticeVOA.reductionClosed_vertexAlgebraInputsFinal_iff_borcherdsInputsComplete' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.reductionClosed_vertexAlgebraInputsFinal_iff_borcherdsInputsComplete

/-! ## BATCH 42: the parity audit — the dispatcher's sign hypothesis is REFUTED

`Definitions/MMLatticeVOASignedIdentity.lean` and `Definitions/MMLatticeVOAParityAudit.lean` test, and
then refute, the conjecture that the mixed-region obstruction of batches 38--41 is an artefact of the
Borcherds identity being stated UNSIGNED: for a vertex operator superalgebra the third sum should
carry the Koszul sign `(-1)^(p(a)p(b))`.  The criterion is kernel-checked
(`signedBorcherdsIdAt_exp_exp_vacuum_neg_one_neg_one_zero_iff : signed … ↔ koszulSign pa pb =
(L.form x y).negOnePow`), and at batch 41's own pair BOTH states are even (weight `0`), so the signed
identity there IS the unsigned one and fails identically; no parity function repairs it
(`not_exists_parity_signedBorcherdsId_II11`); and at the dispatcher's suggested pair the parity sign
instead DESTROYS an identity that was true (`borcherdsId_exp_exp_II11_sum_diff` holds,
`not_signedBorcherdsIdAt_exp_exp_weightParity_II11_sum_diff` refutes the signed form).  So the five
landed refutations are not sign artefacts and the thread's obstruction is genuine. -/

/-- info: 'MM.LatticeVOA.signedBorcherdsIdAt_exp_exp_vacuum_neg_one_neg_one_zero_iff' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.signedBorcherdsIdAt_exp_exp_vacuum_neg_one_neg_one_zero_iff

/-- info: 'MM.LatticeVOA.signedBorcherdsId_iff_borcherdsId_of_parity_zero' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.signedBorcherdsId_iff_borcherdsId_of_parity_zero

/-- info: 'MM.LatticeVOA.not_exists_parity_signedBorcherdsId_II11' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_exists_parity_signedBorcherdsId_II11

/-- info: 'MM.LatticeVOA.borcherdsId_exp_exp_II11_sum_diff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.borcherdsId_exp_exp_II11_sum_diff

/-- info: 'MM.LatticeVOA.not_signedBorcherdsIdAt_exp_exp_weightParity_II11_sum_diff' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_signedBorcherdsIdAt_exp_exp_weightParity_II11_sum_diff

/-- info: 'MM.LatticeVOA.not_signed_of_not_forall_unsigned' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.not_signed_of_not_forall_unsigned









/-- info: 'MM.LatticeVOA.latticeVOAProvedInputs' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.LatticeVOA.latticeVOAProvedInputs

/-! ## Proved: condition (2) of section 3, as a named `Prop` rather than a docstring claim (batch 26-B)

`Definitions/MMMoonshineGap.lean` repairs the defect batch 25-B measured: `MM.MoonshineModule.charCoeff`'s
docstring claimed condition (2) "is `j(q) − 744`" while nothing in the Lean said so.

* **`MM.MoonshineModule.GradedDimensionIsLevelOneJ`** — the named `Prop` that says it, in the only form
  this repository can state it: the graded-dimension series `MM.MoonshineModule.charSeries` is the
  normalized level-one Hauptmodul.  It is *equivalent* to `charSeries M = MM.levelOneA`
  (`gradedDimensionIsLevelOneJ_iff_charSeries_eq`), i.e. to the coefficients `1, 0, 196884, 21493760, …`.
* **`MM.MoonshineModule.levelOne_realizes_conditionTwo`** — the `Prop` is **non-vacuous**: it holds at
  level one, via the proved `MM.levelOne_isGenusZeroGroup` and `MM.levelOneA_hasQExpansion`.
* **`MM.MoonshineModule.gradedDimensionIsLevelOneJ_iff_hauptmodul_one`** — what the `Prop` buys: it is
  *equivalent* to the `g = 1` conjunct of `MoonshineModule.hauptmodul` being realized by the level-one
  group, so it fixes exactly the case the headline leaves open (the group and series for `g = 1` are
  otherwise unconstrained).
* **`MM.MoonshineModule.MoonshineTheorem11WithConditionTwo`** with the two implications
  `moonshineTheorem11_of_conjecture` and `moonshineConjectureStatementMonster_of_theorem11` — the
  headline together with this `Prop` is the paper's Theorem 1.1 in the group-theoretic form, and the
  `Prop` is what the headline does **not** imply.
* The forced coefficients `MM.MoonshineModule.charCoeff_neg_one` (`c(1,−1) = 1`),
  `charCoeff_of_lt_neg_one` and `charCoeff_zero` (`V_0 = 0`, the FLM fact). -/

/-- info: 'MM.MoonshineModule.levelOne_realizes_conditionTwo' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.levelOne_realizes_conditionTwo

/-- info: 'MM.MoonshineModule.gradedDimensionIsLevelOneJ_iff_hauptmodul_one' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.gradedDimensionIsLevelOneJ_iff_hauptmodul_one

/-- info: 'MM.MoonshineModule.moonshineTheorem11_of_conjecture' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.moonshineTheorem11_of_conjecture

/-- info: 'MM.MoonshineModule.moonshineConjectureStatementMonster_of_theorem11' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.moonshineConjectureStatementMonster_of_theorem11

/-- info: 'MM.MoonshineModule.charCoeff_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.MoonshineModule.charCoeff_zero

/-! ## FLM Chapter 8, Section 8.1: the expansions of zero (batches 45--46)

The route change of record: the moonshine module is now built by transcribing FLM
(Frenkel--Lepowsky--Meurman), *Vertex Operator Algebras and the Monster*, Chapter 8, rather than by
inventing a state field.  The citation index for the chapter is `FLM-CH8-MAP.md` at the repository
root.  `Definitions/MMFLM81Basic.lean` transcribes FLM (8.1.3)--(8.1.7): the two half-bounded rings,
the two canonical embeddings `iotaPlus`/`iotaMinus` (both injective), and `theta`, which lands in
FLM's flat `F[[z,z^{-1}]]`.  `Definitions/MMFLM81.lean` transcribes Remark 8.1.1: the geometric
series in each ring and `theta ((1 - X)^{-1}) = delta(z)`, the constant family.  The two statements
that remain open -- the converse half of `Ker theta = F[z,z^{-1}]` (8.1.8) and the module statement
(8.1.9) -- are named `Prop`s there and are NOT guarded here, so that nothing below claims them. -/

/-- info: 'MM.FLM81.iotaPlus_injective' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM81.iotaPlus_injective

/-- info: 'MM.FLM81.theta_algebraMap' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM81.theta_algebraMap

/-- info: 'MM.FLM81.geomNeg_eq_inv' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM81.geomNeg_eq_inv

/-- info: 'MM.FLM81.theta_one_sub_X_inv' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM81.theta_one_sub_X_inv

/-- info: 'MM.FLM81.theta_eq_zero_of_isLaurentPolynomial' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM81.theta_eq_zero_of_isLaurentPolynomial

/-! ## FLM Chapter 8, Section 8.1 completed, and Sections 8.2--8.3 entered (batch 47)

`Definitions/MMFLM81Module.lean` closes Section 8.1: the converse half of `Ker theta = F[z,z^{-1}]`
(8.1.8) is a theorem now (`theta_eq_zero_iff_isLaurentPolynomial`, so the landed named gap
`KerThetaStatement` is discharged), FLM (8.1.9) is proved (`theta_laurentToRatFunc_mul`, with the
monomial case `theta_algebraMap_mul_zpow`), the shift action of §2.1 is built explicitly
(`laurentShift`, `laurentSmul`, no instance), and (8.1.11) is landed
(`theta_one_sub_algebraMap_mul_X_inv`).  `Definitions/MMFLM82Derivations.lean` transcribes FLM 8.2--8.3:
the exponential of a derivation as a `Q`-algebra map (`expDerivHom`, `expSeries_mul`), the iterated
derivatives (`iterDeriv`, `iterDeriv_mul`), the derivations `ddz`/`pDeriv`/`zDeriv`, and the formal
Taylor theorem `expSeries_ddz_eq_taylor`.  Three general statements of 8.3 remain named `Prop`s there
(`prop8317Statement`, `prop8326Statement`, `rem8311Statement`) and are deliberately NOT guarded here. -/

/-- info: 'MM.FLM81.theta_eq_zero_iff_isLaurentPolynomial' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM81.theta_eq_zero_iff_isLaurentPolynomial

/-- info: 'MM.FLM81.theta_laurentToRatFunc_mul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM81.theta_laurentToRatFunc_mul

/-- info: 'MM.FLM82.expSeries_mul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM82.expSeries_mul

/-- info: 'MM.FLM82.expSeries_ddz_eq_taylor' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM82.expSeries_ddz_eq_taylor

/-! ## FLM Chapter 8, Sections 8.4 and 8.5 (batch 48)

`Definitions/MMFLM84Delta.lean` is the lattice-free half of §8.4: the RESIDUE (8.4.33) as a linear
functional on FLM's flat `F[[z_0,z_0^{-1}]]`, the coefficientwise `d/dz` on that module
(`ddzFlat`, `ddzFlat_deltaFlat`), the two expansion conventions for `(1-z)^{-N-1}` with the theorem
`theta_one_sub_X_zpow_neg` (`Theta((1-z)^{-N-1}) = (1/N!) delta^{(N)}`, FLM (8.4.27)--(8.4.28)), and
the `y^N`-coefficient operators of `e^{-y d/dz_1}` (8.4.29).  `Definitions/MMFLM84NormalOrder.lean`
transcribes §8.4's notation change and NORMAL ORDERING (8.4.7)--(8.4.20), including the split
`a(z) = a(z)^+ + a(z)^-` with the exact support statement (8.4.12) and the normal-ordered product in
FLM's own two variables.  `Definitions/MMFLM85Components.lean` is §8.5's definition layer: the
component operators `v_n` of (8.5.15) with the re-indexing identity, the `(End V){z}` vanishing
condition, the weight bookkeeping of (8.5.22), the creation property (8.5.8) = FLM axiom (8.10.7), and
the renormalised operators `x_u(n)` of (8.5.27)--(8.5.31).  Each of the three files names its open
sub-goals as `Prop`s in place and none of those is guarded here. -/

/-- info: 'MM.FLM84.residue' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84.residue

/-- info: 'MM.FLM84.theta_one_sub_X_zpow_neg' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84.theta_one_sub_X_zpow_neg

/-- info: 'MM.FLM84.support_iterDeriv_splitPlus' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84.support_iterDeriv_splitPlus

/-- info: 'MM.FLM85.VertexOp.vertexOpFam_eq_component' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85.VertexOp.vertexOpFam_eq_component

/-- info: 'MM.FLM85.xCoeff_creationProperty' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85.xCoeff_creationProperty

/-! ## FLM Chapter 8, the concrete construction (batch 49)

`Definitions/MMFLMFock.lean` (`MM.FLMFock`) is FLM (7.1.1)--(7.1.5) over a FIELD of characteristic 0:
the Heisenberg module `M(1) = S(h^_-)` as a symmetric algebra with its vacuum, the modes with
`[alpha(m), beta(n)] = m <alpha,beta> delta_{m+n,0}` PROVED (not assumed, `mode_commutator`), the
vacuum annihilation `annihilation_vacuum`, and the degree operator with `[d, alpha(m)] = m alpha(m)`
in the source's own sign (`flmD_commutator`).  Its named gap is `FockDimensionIdentity` ((1.10.19)),
which needs the linear independence of the degree-`N` monomials.

`Definitions/MMFLMY87.lean` (`MM.FLM87`) is (8.4.17): the vertex operator `Y(a,z)` as coefficient data
in the landed `MM.FLM85` interface.  It defines the exponent `integral (a(z) - a(0) z^{-1})` and its
coefficientwise exponential (`expField`, with the recursion `expField_recursion`), discharges the
existence half of `MM.FLM84.NormalOrderedExponentialStatement`
(`normalOrderedExponentialStatement_expField`), builds `YCoeff`, and proves the source's consequences
for it: (8.4.23) `deriv_YCoeff_eq_normalPair`, (8.4.24) `YCoeff_eq_xMode`, the creation property
(8.5.8)/(8.10.7) (`YCoeff_smul_vacuum`, `creationProperty_component`), the `(End V){z}` vanishing
(8.5.6), and the first case of (8.4.41) (`commutator_eq_zero_of_nonneg`).  Open there, named:
`operatorLevelStatement` (the three-factor product needs a completion) and `corollary854Statement`
(needs (8.5.5) on all of `V_L`). -/

/-- info: 'MM.FLMFock.mode_commutator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMFock.mode_commutator

/-- info: 'MM.FLMFock.flmD_commutator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMFock.flmD_commutator

/-- info: 'MM.FLM87.normalOrderedExponentialStatement_expField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87.normalOrderedExponentialStatement_expField

/-- info: 'MM.FLM87.creationProperty_component' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87.creationProperty_component

/-! ## FLM Chapter 8, the module V_L and the extension of Y to all of it (batch 50)

`Definitions/MMFLMLatticeModule.lean` (`MM.FLMLattice`) is FLM (7.1.6)--(7.1.41) and (7.2.22)--(7.2.26):
the central extension built from (7.1.13)'s structure constants (`Lhat`, unitary, with
`Lhat.sect_mul_kappa` for (7.1.9) and `Lhat.commutator_sect`), the cocycle and its properties, the
induced module `F{L}` with `iota` injective, the operators `h(0)` and `z^h` with (7.1.34)--(7.1.38)
(`zPowH_mul_act`), the tensor product `V_L = M(1) (x) F{L}` with its vacuum, its modes and the weight
pieces of (7.1.40).  Named gaps: `LatticeWeightDecomposition`, `WeightPiecesFinite` (needs the landed
`MM.FLMFock.FockDimensionIdentity`) and `FirstDimensionStatements`.

`Definitions/MMFLM85Extension.lean` (`MM.FLM85Ext`) is FLM (8.5.1)--(8.5.8): the well-definedness step as
a universal property (`extension_existsUnique`, with `Compatible` an explicit hypothesis and
`compatible_of_extension` showing it necessary), the definition of the general vertex operator (8.5.5) by
the normal-ordered product (`normalOrderedProduct`, built on the landed `MM.FLM84` ordering), the
`(End V_L){z}` well-definedness (`familyVanishesBelow_of_spanning`), (8.5.7), and the creation property
(8.5.8) = axiom (8.10.7) for ALL of `V_L` (`creationProperty_of_presentation`).  Stated and not proved,
with the exact missing input named: `normalOrderedWellDefinedStatement`, `iterateStatement`,
`corollary851Statement`, `corollary854Statement` -- all four wait on Theorem 8.4.2. -/

/-- info: 'MM.FLMLattice.Lhat.commutator_sect' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMLattice.Lhat.commutator_sect

/-- info: 'MM.FLMLattice.zPowH_mul_act' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMLattice.zPowH_mul_act

/-- info: 'MM.FLM85Ext.extension_existsUnique' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Ext.extension_existsUnique

/-- info: 'MM.FLM85Ext.creationProperty_of_presentation' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Ext.creationProperty_of_presentation

/-! ## FLM Chapter 8, the commutator path (batch 51)

`Definitions/MMFLM82Flow.lean` (`MM.FLM82Flow`) lands the change of variable that Theorem 8.4.2 needs:
`expSeries_zDeriv_eq_flowSubst` is FLM (8.3.5)--(8.3.6) in full (`e^{y z d/dz} u(z) = u(e^y z)`, proved by
substitution into a unit multiple of `z`, so no completion is required), the flow ODE of (8.3.7)--(8.3.9)
for the three derivations the source uses, the `z^2 d/dz` special case `expSeries_pDeriv_X_sq_X`
(`e^{y z^2 d/dz} z = z/(1-yz)`), the polynomial case of (8.3.16)--(8.3.17) (`eval₂_expSeries`), and the
`p_{k,l}` of Corollary 8.3.5 in the source's own recursion (`pp`, `pk`).  Its most important negative
finding is recorded in the file: `PowerSeries.subst (expSeries T g) f` is NOT FLM's `f(e^{yT}g)`, because
`HasSubst a` requires `IsNilpotent (constantCoeff a)` while `constantCoeff (expSeries T g) = g`; for
`g != 0` the `subst` form returns the documented dummy `0`.  The repository's own older
`prop8317Statement` therefore asserts `e^{yT}(f o g) = 0`, and the faithful replacement is the landed
`flowSubst`/`eval₂_expSeries`.  Named gaps there: `ppValueTableStatement`, `faaDiBrunoSmallCasesGap`,
the general-`f` form, and the `z^2 d/dz` functional equation.

`Definitions/MMFLM84Commutator.lean` (`MM.FLM84C`) is the commutator computation of 8.4 at the coefficient
level, which is what Theorem 8.4.2 is made of: the two-variable carrier with its Cauchy product of
(8.4.36) (`seriesMul`, `seriesMul_apply_zero`), the `(8.4.40)` coefficient family (`Coeff40Zero`,
`Coeff40One`), the commutator coefficient (8.4.26) `commutatorCoeff`, and two of its cases proved:
`commutatorCoeff_eq_zero_of_nonneg` ((8.4.41), first case) and `commutatorCoeff_neg_one` ((8.4.42)).
Theorem 8.4.2 itself is stated as `theorem842Coeff` with the source's hypotheses named, and its second
form as `theorem842Concrete`; neither is claimed proved.  The `z_0^2` and `z_0^3` lines of (8.4.40) are
quoted in docstrings only, because the recursion `P_{n+1} = (n+1)^{-1} sum_{i<=n} P_i (d/dz_2)^{n-i} a(z_2)`
does not go through Lean's structural-recursion checker in the shape the file needs.

`Definitions/MMFLM85Brackets.lean` (`MM.FLM85Br`) is 8.5's bracket layer: the binomial `C(m,i)` for
`m` in `Z` (8.5.37), the finite support of Corollary 8.5.4's sum DERIVED from the landed weight
bookkeeping (`component_eventually_zero`, `bracketTerm_vanishing_of_grading`), Corollary 8.5.4 as the
named statement `ComponentBracket` with `corollary854Statement` beside it, Corollary 8.5.5 PROVED from
8.5.4 (`corollary855_of_componentBracket`), and Corollary 8.5.6 proved EQUIVALENT to 8.5.4
(`corollary856_iff_componentBracket`), with (8.5.46)'s three cases stated and each proved to follow from
Corollary 8.5.6.  Its named gap is `CoefficientExtraction`: the step from Corollary 8.5.1 to 8.5.4 is an
infinite convolution over the middle index, i.e. the same completion problem the repository has named
`MM.FLM87.operatorLevelStatement`. -/

/-- info: 'MM.FLM82Flow.expSeries_zDeriv_eq_flowSubst' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM82Flow.expSeries_zDeriv_eq_flowSubst

/-- info: 'MM.FLM82Flow.expSeries_pDeriv_X_sq_X' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM82Flow.expSeries_pDeriv_X_sq_X

/-- info: 'MM.FLM84C.commutatorCoeff_neg_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84C.commutatorCoeff_neg_one

/-- info: 'MM.FLM85Br.component_eventually_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Br.component_eventually_zero

/-- info: 'MM.FLM85Br.corollary856_iff_componentBracket' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Br.corollary856_iff_componentBracket

/-! ## FLM Chapter 8: the operator product and FLM's several-variable localisation (batch 52)

`Definitions/MMFLM84Product.lean` (`MM.FLM84P`) makes the OPERATOR-LEVEL normal-ordered product a real
object instead of a named gap.  It builds the two-variable coefficient family of (8.4.19)--(8.4.20)
(`openBoxField`, `twoVarProduct`) over an abstract module with a vacuum, proves its bilinearity and its
vanishing below in each variable, connects it to the landed (8.4.17) data
(`latticeProduct_smul_vac` -- the defining property on the vacuum), proves the commutativity (8.4.21)
from the cocycle relation (7.1.21) (`twoVarProduct_comm_of_cocycle`), and **closes the recursion gap of
`MM.FLM84C`**: `expFamily` is the recursion `P_{n+1} = (n+1)^{-1} sum_{i<=n} P_i (d/dz_2)^{n-i} a(z_2)`
defined structurally, and with it the four printed lines of (8.4.40) are theorems (`coeff40_zero`,
`coeff40_one`, `coeff40_two`, `coeff40_three`).  What remains open there, named: the DIAGONAL `z_1 = z_2`
(an infinite convolution in one variable) and `productExpansionStatement` ((8.4.22)/(8.4.25)), whose
missing input is the operator-level expansion of Theorem 8.4.2.

`Definitions/MMFLMLocalization.lean` (`MM.FLMLoc`) builds FLM's several-variable localisation
(8.10.36)--(8.10.42): the multiplicative set `S` generated by the linear forms (`S`, `LocRing`,
`ne_zero_of_mem_S`, `isUnit_algebraMap_of_mem_S`), its universal property (`existsUnique_lift`), the
inclusion into the fraction field (`toFractionRing_injective`), the `n = 1` case identified with the
landed 8.1 embedding (`iotaOne_eq_iotaPlus`, so (8.10.37) IS (8.1.6)), and the `n = 2` pair
`expand12`/`expand21` of (8.10.42) with the difference identity `expand12_sub_expand21` -- the
expansion of zero in the two-variable setting.  Two structural findings are recorded in the file: `S` is
NOT generated by the variables up to units (so `Localization.Away` is the wrong ring and
`Localization (Submonoid.closure linForms)` is used), and the several-variable `iota` is NOT a ring
homomorphism (`no_ringHom_monomial`), so `IsLocalization.lift` cannot produce (8.10.37) -- the recursion
must be an `F`-linear map into the shift module.  Its named gap is `IotaTwoVarGap`. -/

/-- info: 'MM.FLMLoc.iotaOne_eq_iotaPlus' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMLoc.iotaOne_eq_iotaPlus

/-- info: 'MM.FLMLoc.expand12_sub_expand21' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMLoc.expand12_sub_expand21

/-- info: 'MM.FLM84P.coeff40_three' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84P.coeff40_three

/-- info: 'MM.FLM84P.latticeProduct_smul_vac' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84P.latticeProduct_smul_vac

/-- info: 'MM.FLM84P.twoVarProduct_comm_of_cocycle' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84P.twoVarProduct_comm_of_cocycle

/-! ## FLM Chapter 8: the iterate, the extraction, and Theorem 8.4.2 over real objects (batch 53)

`Definitions/MMFLM85Iterate.lean` (`MM.FLM85It`) defines FLM's `iterate` -- the object of (8.5.9)--(8.5.12),
i.e. the coefficient family of `Y(Y(a,z_0) iota(b), z_2)` -- with its bilinearity in both states, its
vanishing below in each variable (from (8.10.5) and the landed graded truncation), the identification
`iterateOf_component` of its coefficients with `(iota(a)_i . iota(b))_j`, and the re-indexings both ways;
the landed named statement `MM.FLM85Ext.iterateStatement` now has a defined left-hand side and is
equivalent to an identity between defined families, with the canonical right-hand side a theorem
(`iterateStatement_rhs_unique`).

`Definitions/MMFLM85Extraction.lean` (`MM.FLM85Ex`) **closes the coefficient extraction** that turns
Corollary 8.5.1 into Corollary 8.5.4: `isExtractionSolution_iff` proves that the solution set of (8.5.24)'s
three exponent equations is exactly `{(i, m+n-i, i, i-m-1) : i in N}`, so the residue is a sum with ONE
free index and no infinite convolution; `coefficientExtraction` is the theorem that the landed
`MM.FLM85Br.CoefficientExtraction` -- previously a hypothesis -- now holds, and the finiteness is DERIVED
twice over (`iterateFamily_eq_of_nat` from `C(m,i) = 0`, `iterateFamily_eq_of_grading` from the landed
weight truncation).  The single remaining input is named `Corollary851Extraction`.

`Definitions/MMFLM84Theorem.lean` (`MM.FLM84T`) states Theorem 8.4.2 over objects that exist: the
right-hand side of (8.4.38)/(8.4.39) is BUILT from landed definitions (`residue842`), the four printed
coefficient lines of (8.4.40) are `coeff40Family_*`, and the cases (8.4.42)--(8.4.45) are all proved
(`residue842_neg_one` through `residue842_neg_four`), including `residue842_neg_two` ((8.4.43)) which
`MM.FLM84C` never stated and `residue842_neg_three`/`_neg_four` ((8.4.44)/(8.4.45)) which that file's
header wrongly called elided -- they are printed in full.  `theorem842Statement` is the theorem over the
landed `LatticeElement` fields, and `commutatorCoeff_nonneg` recovers the landed (8.4.41) as a regression
check.  The file's numbered list of what remains names the one real wall: (8.4.30)--(8.4.31)'s change of
variable `z_1 |-> z_2 + z_0` for the two-variable normal-ordered product, for which `MM.FLM82Flow` is the
engine. -/

/-- info: 'MM.FLM85It.iterateOf_component' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85It.iterateOf_component

/-- info: 'MM.FLM85Ex.isExtractionSolution_iff' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Ex.isExtractionSolution_iff

/-- info: 'MM.FLM85Ex.coefficientExtraction' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Ex.coefficientExtraction

/-- info: 'MM.FLM84T.residue842_neg_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84T.residue842_neg_two

/-- info: 'MM.FLM84T.commutatorCoeff_nonneg' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84T.commutatorCoeff_nonneg

/-! ## FLM Chapter 8: the diagonal resummation, and Corollary 8.5.1 over existing objects (batch 54)

`Definitions/MMFLM84Taylor.lean` (`MM.FLM84Y`) lands the wall's formal-calculus face.
`expNegDdz1Coeff_eq_taylorShift1` identifies the `y^N`-coefficient operator of `e^{-y d/dz_1}` with the
shift `z_1 |-> z_1 - y`, and **`resumCoeff_eq_taylorCoeff` is (8.4.30) = (8.4.31)**: the resummation of a
two-variable family along `z_1 = z_2 + z_0` against the delta equals the same family evaluated at
`z_2 + y`.  Its engine is a finite alternating Vandermonde identity (`binomCoeffAltSum_eq`) plus Pascal
(`binomCoeff_succ_eq`) -- two FINITE sums, no completion, no nonnegativity hypothesis.  The file also
discharges two named Props of the delta layer (`deltaDerivDivStatement_holds`,
`commutatorCoefficientStatement_holds`), and corrects the record: a SYMMETRIC window-independence claim
would be false, and the counterexample is in `resumCoeff_eq_of_window`'s docstring.

`Definitions/MMFLM85Corollary.lean` (`MM.FLM85Co`) states Corollary 8.5.1 over objects that exist: its
right-hand side (`corollary851Residue`) is built from the landed `residue` (8.4.33), the landed delta
family (8.5.25) and the landed `iterate` (8.5.12), with no free mathematical parameter
(`Corollary851`, with the window proved immaterial by `Corollary851.of_cutoff`).  It proves that this
statement IS the landed `MM.FLM85Ext.corollary851Statement` with both parameters replaced by defined
objects (`corollary851_iff_ext`), that it implies Corollary 8.5.4 with the finiteness DERIVED
(`corollary854_of_corollary851`), that Corollaries 8.5.5 and 8.5.6 become unconditional once it holds,
and that **it is equivalent to Theorem 8.4.2 modulo (8.5.12)** (`corollary851_iff_theorem842`).  Its
corrections: the right-hand side of (8.5.13) carries the UNSHIFTED delta -- the pairing sits as
`z_0^{<a,b>}` in (8.4.35), outside the normal-ordered product -- and `FLM-CH8-MAP.md`'s row for (8.5.13)
has the same mis-shape. -/

/-- info: 'MM.FLM84Y.resumCoeff_eq_taylorCoeff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84Y.resumCoeff_eq_taylorCoeff

/-- info: 'MM.FLM84Y.deltaDerivDivStatement_holds' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84Y.deltaDerivDivStatement_holds

/-- info: 'MM.FLM85Co.corollary851_iff_ext' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Co.corollary851_iff_ext

/-- info: 'MM.FLM85Co.corollary854_of_corollary851' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Co.corollary854_of_corollary851

/-- info: 'MM.FLM85Co.corollary851_iff_theorem842' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Co.corollary851_iff_theorem842

/-! ## FLM Chapter 8: the product form, and the one identity left (batch 55)

`Definitions/MMFLM85ProductForm.lean` (`MM.FLM85PF`) proves the source's explicit product form and, with
it, a new bridge in the delta layer: **`expansionA_sub_expansionB_eq_z2InvDeltaFamily`** is the display
`MMFLM84Taylor`'s own docstring had recorded as quoted-but-not-proved -- the difference of the two
conventions of `(z_1 - z_2)^p` IS `z_2^{-1} ((-1)^N/N!) (d/dz_1)^N delta(z_1/z_2)`.  From it:
`commutator_eq_conv_sub` (both product forms against ONE normal-ordered family, so the commutator is that
family against `E - E'`, a single finite index with the landed `diagSum` window), and the cases of
(8.4.41)--(8.4.45) re-derived **in three lines each** (`commutator_eq_zero_of_nonneg`,
`commutator_eq_mulDelta_of_neg_one`, `commutator_eq_diagDelta_of_neg`), independently of the landed
Corollary 8.5.1 route.  `ordField_eq_openBoxField_iff` records the exact content of the product form: it
is EQUIVALENT to the vanishing of the single commutator `[F^+, G]`, i.e. it is data about the concrete
Fock carrier rather than a consequence of a component family.  The file also defines `pfRhs`, the
`z_0^k`-coefficient family of (8.5.12)'s right-hand side, which removes the free parameter from the two
landed formulations, and proves the cases `k <= 3` (`productExpansionDef_apply_zero/one/two/three`).

**The measurement that decides the next batch** (`Probe/FLM_8512_RECON.md`, batch 55:
`MM.FLM85PF`'s sibling reconnaissance): (8.5.12) is proved by (8.4.36), whose proof is the display
**(8.4.32)** on printed 195 -- a FINITE expansion in nonnegative integral powers of `y`, called by the
source "an elaborate form of (8.3.21)".  So the last step does **not** need the several-variable
localisation; what it needs is the mode-level normal-ordering rule of printed 191, i.e. the object the
repository names `MM.FLM87.operatorLevelStatement`.  The reconnaissance also pins the exact blocker: the
landed `MM.FLM84P.openBoxCoeff` is stated over a COMMUTATIVE ring, so it cannot be instantiated at
`M ->_l[F] M`, and the operator-valued right-hand side of (8.5.12) needs it there.  One identity remains,
named (G) in that document: `iterateOf Y a b i j = P (-i-1-pairing) j`, whose two halves are (8.5.11)
(finite, needs `iota(ab)` -- the concrete `MM.FLMLattice` module has the pieces) and (8.4.36) at operator
level. -/

/-- info: 'MM.FLM85PF.expansionA_sub_expansionB_eq_z2InvDeltaFamily' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85PF.expansionA_sub_expansionB_eq_z2InvDeltaFamily

/-- info: 'MM.FLM85PF.commutator_eq_conv_sub' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85PF.commutator_eq_conv_sub

/-- info: 'MM.FLM85PF.ordField_eq_openBoxField_iff' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85PF.ordField_eq_openBoxField_iff

/-- info: 'MM.FLM85PF.productExpansionDef_apply_three' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85PF.productExpansionDef_apply_three

/-! ## FLM Chapter 8: the state identity (8.5.11) and the operator-level product (batch 56)

`Definitions/MMFLMLatticeState.lean` (`MM.FLMLatSt`) is **(8.5.11) on the CONCRETE module**: for a PAIR of
lattice elements it builds the state `Y(a,z_0) iota(b)` as a coefficient family of the landed `V_L` --
the thing the abstract `MM.FLM87.LatticeElement` cannot even state, because it carries one element -- and
proves the display: `latticeState_eq_exp` is

  `Y(a,z_0) iota(b) = exp( sum_{n>=1} a(-n) z_0^n / n ) iota(ab) z_0^{<a,b>}`

coefficientwise, with `anchorVL_eq` (`iota(ab) = eps(a,b) iota(a+b)`, (7.1.20)+(7.1.28)),
`latticeState_eq_zero_of_lt` (the family's support starts at the pairing, so the `z_0 -> 0` limit is a
coefficient), the `n = 1, 2` coefficients, and the case `b = 0` (`latticeState_zero_eq_YCoeff`, all `m`,
recovering the landed (8.4.17)).  It also converts the `stateCoeff` PARAMETER of the landed
`MM.FLM85Co.ProductExpansion` / `MM.FLM85It.iterate` into the defined family
(`stateFamily_eq_latticeState`), and discharges the CONCLUSION of `MM.FLM85Co.StateVanishesBelow` at the
threshold `-<a,b> - 1`.  Named gaps: `StateFamilyStatement` and `StateWeightStatement`.

`Definitions/MMFLM84ProductOp.lean` (`MM.FLM84PO`) lifts the product to **operator level** and corrects
the batch-55 diagnosis of where the `CommRing` restriction bites.  `opOpenBox` is `F^- | Yab + Yab | F^+`
over a `Ring` (NOT a commutative one), with `opOpenBox_eq_openBoxCoeff` recording that at `[CommRing A]` it
IS the landed object; the four printed lines of (8.4.40) are `opCoeff40_zero/one/two/three`, with the
operator-level `exp` reading at `z_0^3` as
`opCoeff40_three_eq_expSeriesThree` and its difference from the recursion's value identified.  The named
Prop is `OperatorLevel8436` (inhabited, with its five consequences), and
`operatorLevelStatement_opOpenBox_iff` shows the repository's `MM.FLM87.operatorLevelStatement` IS
statable at operator level for `opOpenBox`.  **The measured correction**: the ordering rules were already
noncommutative-safe (`normalOrderOp`, `normalPair`, `openBoxField`, `twoVarProduct` are `[Ring A]`); the
`[CommRing A]` on `openBoxCoeff`/`coeff40_*` is a SECTION VARIABLE, and commutativity is used in exactly
one place (`flatMul_comm` inside `expFamily_three`) -- so the lift is one definition plus one named
hypothesis, not a re-derivation.  A non-vacuity witness is landed: over `Module.End Q (Q x Q)`,
`flatMul X (deriv X) != flatMul (deriv X) X`. -/

/-- info: 'MM.FLMLatSt.latticeState_eq_exp' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMLatSt.latticeState_eq_exp

/-- info: 'MM.FLMLatSt.stateFamily_eq_latticeState' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMLatSt.stateFamily_eq_latticeState

/-- info: 'MM.FLM84PO.opCoeff40_three' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84PO.opCoeff40_three

/-- info: 'MM.FLM84PO.operatorLevelStatement_opOpenBox_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84PO.operatorLevelStatement_opOpenBox_iff

/-! ## FLM Chapter 8: the substitution, and (8.5.12) over landed objects (batch 57)

`Definitions/MMFLM84Subst.lean` (`MM.FLM84S`) aligns the landed delta/Taylor resummation with the shifted
family: `resumCoeff_openBoxField_eq_shift` instantiates `MM.FLM84Y.resumCoeff_eq_taylorCoeff`
((8.4.30) = (8.4.31)) at the landed `openBoxField`/`ordField`, which REMOVES a parameter from that
theorem; `shiftSeries_eq_factorial_inv_iterDeriv` identifies `(1/j!)(d/dz)^j X` with the shift-coefficient
the source uses; `expFamily_mul_succ_shiftSeries` shows `expFamily` IS the exponential of
`sum_i shiftSeries X i z_0^{i+1}`; the substitution commutes with the normal ordering (8.4.19) by SUPPORT,
not by same-sign commutation; the interface `SameSignModeComm` is named and given a non-vacuity witness
(`exists_sameSignModeComm`), with `opCoeff40_of_sameSign` deriving all four printed lines of (8.4.40) under
it; and `substProductExpansion_iff_productExpansionDef` shows the substitution form IS the landed
`ProductExpansionDef`.  `Shifted8436` -- (8.4.36) for a general two-variable family -- is NOT proved: its
coefficients `k <= 3` are reached as proved equivalences (`shifted8436_zero/one/two/three_iff`), and the
general case needs the product rule for `flatMul` together with the multiplicativity of the Taylor shift.

`Definitions/MMFLM8512Done.lean` (`MM.FLM8512`) puts (8.5.12) over landed objects:
`productExpansion8512_iff_productExpansion` is `rfl`-equivalent to the landed
`MM.FLM85Co.ProductExpansion` with its `P` parameter replaced by a defined family at the operator ring
(`rhsFam_eq_pfRhs`), `productExpansion8512_iff_iterateStatement` connects it to the landed
`iterateStatement`, `productExpansionDef8512_apply_zero/one/two/three` give the (8.4.40) consequences, and
**the `b = 0` case is PROVED** (`productExpansion8512_zero_right_pairing`, from the landed
`latticeState_zero_eq_YCoeff` with the creation property).  `Theorem842Concrete` states Theorem 8.4.2 over
the concrete objects and `theorem842Concrete_iff_corollary851` links it to the landed equivalence.
Its numbered list of what remains is the dispatcher's road map; the sharpest item is that at NEGATIVE
`z_2`-powers the identity asserts a VANISHING of the iterate (the landed `rhsFam` is zero there), which is
(8.5.8) content and not a formality. -/

/-- info: 'MM.FLM84S.resumCoeff_openBoxField_eq_shift' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84S.resumCoeff_openBoxField_eq_shift

/-- info: 'MM.FLM84S.substProductExpansion_iff_productExpansionDef' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84S.substProductExpansion_iff_productExpansionDef

/-- info: 'MM.FLM8512.productExpansion8512_iff_productExpansion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM8512.productExpansion8512_iff_productExpansion

/-- info: 'MM.FLM8512.productExpansion8512_zero_right_pairing' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM8512.productExpansion8512_zero_right_pairing

/-- info: 'MM.FLM8512.theorem842Concrete_iff_corollary851' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM8512.theorem842Concrete_iff_corollary851

/-! ## FLM Chapter 8: the Compatible hypothesis, and the flatMul engines (batch 58)

`Definitions/MMFLM85Compat.lean` (`MM.FLM85Cp`) discharges what can be discharged of (8.5.1)'s
well-definedness and locates the rest.  `compatible_bot` proves `Compatible` outright for the model's
`F{L}` -- the landed `FL F L = L ->_0 F` IS the quotient by (7.1.23), so that side is vacuous -- and
`compatible_span_kappa_iff` identifies the source's actual check in FLM's own presentation: `Compatible`
iff `Y(kappa iota(a), z) = omega Y(iota(a), z)`, i.e. (7.1.50), the parenthetical of (8.5.1).  It also
lands the (8.5.2)+(8.5.5) instances the route needs on the landed `FiveDatum`
(`zeroDatum_normalOrderedProduct` for `k = 0`, `oscDatum_normalOrderedProduct` for `n_1 = 1`,
`oscDatumN_normalOrderedProduct` for general `n`), and -- the reduction batch 57 asked for --
`productExpansionZeroRightOne_iff_normalOrdered`: **the `z_0^1` line of (8.5.12) at `b = 0` is
EQUIVALENT to the (8.5.5) instance at the oscillator state**, i.e. to the single named statement
`NormalOrderedAtOscillator`, with nothing else in the way.

`Definitions/MMFLM84FlatMul.lean` (`MM.FLM84FM`) lands the first half of the engine `Shifted8436` needs:
`flatMul_natCast` (`(X | Y)_n = sum_{l<=n} X_l Y_{n-l}`, over `[Ring A]`, no commutativity),
`flatMul_sum_right`/`flatMul_sum_left`/`flatMul_ratSmul` (additivity and `Q`-homogeneity of the flat
convolution), and `natChoose_add` ((8.5.37) with Vandermonde, in range form).  Its header states exactly
what is left, and the reconnaissance in the same batch corrected the SHAPE of the missing engine: the
multiplicativity needed is `shiftSeries_flatMul` -- the coefficient form of (8.3.21) -- and it is FALSE at
an arbitrary integer power, so it must be stated at `l = (N : Z)`; `flatMul` ASSOCIATIVITY is a separate
`[Ring A]` statement used only to move the identity onto `opOpenBox`. -/

/-- info: 'MM.FLM85Cp.compatible_span_kappa_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Cp.compatible_span_kappa_iff

/-- info: 'MM.FLM85Cp.oscDatum_normalOrderedProduct' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Cp.oscDatum_normalOrderedProduct

/-- info: 'MM.FLM85Cp.productExpansionZeroRightOne_iff_normalOrdered' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Cp.productExpansionZeroRightOne_iff_normalOrdered

/-- info: 'MM.FLM84FM.natChoose_add' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84FM.natChoose_add

/-! ## FLM Chapter 8: the two engines, and the Heisenberg first factor (batch 59)

`Definitions/MMFLM84ShiftMul.lean` (`MM.FLM84SM`) lands both engines batch 58 measured as missing, and
closes `Shifted8436` at general `k` GIVEN the two source facts it needs.  `flatMul_assoc` is
**unconditional** over `[Ring A] [Algebra Q A]` -- no commutativity, no one-sidedness.  `shiftSeries_flatMul`
is the multiplicativity of the Taylor shift for the flat convolution **at a nonnegative power** (the
finite-sum case; the file states why the arbitrary-integer-power form is false).  With them,
**`shifted8436_of_deriv` closes `MM.FLM84S.Shifted8436` at general `k`** from the two hypotheses the
source supplies -- (8.4.23) in the form `deriv Fam = X | Fam` and the (8.4.32) diagonal collapse -- and
`substProductExpansion_of_deriv` gives the coefficientwise (8.5.12) at every pairing, with
`opCoeff40_shiftSeries` reproducing all four printed lines of (8.4.40) as a regression check.  The file
also records that the two named sub-lemmas of the batch-58 header are not what the induction consumes, and
that one of them as written there is FALSE without the hypothesis `i <= k` (`C(5,1) C(1,3) = 15 != 10 = C(5,3)`).

`Definitions/MMFLM8512Heis.lean` (`MM.FLM8512H`) is the MIS-SHAPE REPAIR: it restates (8.5.12) with the
HEISENBERG first factor of (8.4.7) (`ProductExpansionHeis`, `productFamHeis`, `productRhsHeis`), proves the
bridge to the landed `MM.FLM8512.ProductExpansion8512` under the shift hypothesis
(`productExpansionHeis_iff_productExpansion`), proves the `z_0^0` and `z_0^1` lines at that first factor
(`productFamHeis_zero`, `productFamHeis_one`), and reduces the `b = 0`, `z_0^1` line to the oscillator
normal-ordering statement, composing with the landed `MM.FLM85Cp.oscDatum_normalOrderedProduct`.
**The repair's cost is stated in its header**: a successor must NOT pass `modeFam Y a` (or `baseFam Y a`)
as the first factor -- those are `Y(a,z)` of (8.4.17) -- and the object `expFamily` consumes is
`splitMinus (heisFam a)`, since `expFamily_one` needs a family vanishing at negative powers. -/

/-- info: 'MM.FLM84SM.flatMul_assoc' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84SM.flatMul_assoc

/-- info: 'MM.FLM84SM.shiftSeries_flatMul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84SM.shiftSeries_flatMul

/-- info: 'MM.FLM84SM.shifted8436_of_deriv' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84SM.shifted8436_of_deriv

/-- info: 'MM.FLM8512H.productExpansionHeis_iff_productExpansion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM8512H.productExpansionHeis_iff_productExpansion

/-- info: 'MM.FLM8512H.productFamHeis_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM8512H.productFamHeis_one

/-! ## FLM Chapter 8: (8.4.23) at the operator ring, and the (8.4.32) collapse (batch 60)

`Definitions/MMFLM84DerivId.lean` (`MM.FLM84DI`) proves **(8.4.23) at the operator ring**
(`deriv_YCoeff_eq_opOpenBox_heisFam`) and, more usefully, exhibits a CONCRETE model vertex operator for
which it holds with no hypothesis (`modelOperator`, `derivNormalOrdered_modelOperator`), covering the
vacuum, the lattice states `iota(a)` and the pair states of (8.5.11).  `derivNormalOrdered_iff_modeFam_eq_YCoeff`
is the sharpest statement in the file: given (8.5.8), the predicate holds IFF `modeFam Y a = YCoeff`, i.e.
iff (8.5.2) at the (8.4.17) model -- the repository's `MM.FLM87.operatorLevelStatement`.  It also shows
that (8.4.23) DERIVES the support hypothesis `hX` that the landed (8.4.40) lines carry
(`derivNormalOrdered_eq_zero_of_neg`).

`Definitions/MMFLM84Diag.lean` (`MM.FLM84DG`) lands the (8.4.32) collapse as the named statement
`DiagCollapse` in exactly the shape `MM.FLM84SM.shifted8436_of_deriv` consumes, PROVES it in the vacuum
sector (`diagCollapse_zero_right`, `_zero_left`, `_zero_zero`), proves the product side unconditionally
(`stateFam_eq_eps_smul_modeFam`, from (8.5.11)+(7.1.28)), proves the `z_0^{<a,b>}` line of (8.5.12) from
the landed (8.5.11) alone (`iteratePow_pairing_eq_stateFam`), proves the `z_0^1` line of (8.4.40) at the
operator ring from both source facts (`opOpenBox_deriv_modeFam`), and shows that with `Iterate8436` the
landed `MM.FLM8512H.ProductExpansionHeis` and `MM.FLM8512.ProductExpansion8512` follow
(`productExpansionHeis_of_iterate8436`, `productExpansion8512_of_iterate8436`).

**The structural finding both files report, and it is the important one.**  For a FREE vertex operator `Y`
neither (8.4.23) nor (8.4.32) is provable, and that is not a defect of the layer: both are statements
ABOUT `Y`, and a free parameter cannot satisfy them.  What the repository now has instead is a
characterisation (`derivNormalOrdered_iff_modeFam_eq_YCoeff`), a concrete model where they hold
(`modelOperator`), and the reductions showing that everything downstream follows once they do.  The
honest remaining input is therefore (8.5.1)'s uniqueness half -- that the extension really is pinned by
the lattice values -- which the source asserts and this repository carries as
`MM.FLM85Ext.normalOrderedWellDefinedStatement`. -/

/-- info: 'MM.FLM84DI.deriv_YCoeff_eq_opOpenBox_heisFam' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84DI.deriv_YCoeff_eq_opOpenBox_heisFam

/-- info: 'MM.FLM84DI.derivNormalOrdered_modelOperator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84DI.derivNormalOrdered_modelOperator

/-- info: 'MM.FLM84DG.diagCollapse_zero_right' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84DG.diagCollapse_zero_right

/-- info: 'MM.FLM84DG.opOpenBox_deriv_modeFam' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84DG.opOpenBox_deriv_modeFam

/-- info: 'MM.FLM84DG.productExpansion8512_of_iterate8436' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84DG.productExpansion8512_of_iterate8436

/-! ## FLM Chapter 8: the model's limit, and the Jacobi identity (batch 61)

`Definitions/MMFLM85Unique.lean` (`MM.FLM85Uq`) PROVES that the concrete model of batch 60 CANNOT be the
general vertex operator: `modelOperator_kills_oscillator_and_855_fails` shows (8.5.5) fails at the
oscillator state for it, because the model is the Fock augmentation on the tensor factor and therefore
annihilates every Fock-positive state, while (8.5.5) prescribes the nonzero `alpha(-1)`
(`normalOrderedProduct_oscillator_gen_ne_zero`).  `no_tensorProduct_form_satisfies_855` rules out the
whole shape, not just that instance.  What the file DOES give: (8.5.1)'s uniqueness on the landed model
(`modelFL_unique`), and the identification of the remaining gap -- relating the formal family
`normalOrderedProductOf` to the ACTION of its coefficients on `M(1) (x) F{L}` -- which is exactly (8.5.6).
So the model branch of the route is closed by refutation, and the remaining input is (8.5.6) plus (8.5.1)'s
uniqueness, as before.

`Definitions/MMFLM88Jacobi.lean` (`MM.FLM88`) transcribes **Section 8.8 and Theorem 8.8.9, the Jacobi
identity** -- the first section beyond 8.5.  It lands the cross-bracket objects (8.8.13)/(8.8.21), PROVES
`crossBracket_zero_eq_commutatorFamily` ((8.8.14) collapsing to (8.8.26)), states `JacobiIdentity`
((8.8.41)/(8.8.30)) and `JacobiDelta` ((8.8.29)), and proves the source's own equivalence
`jacobiIdentity_iff_delta` ((8.8.29) iff (8.8.30)), together with `deltaRight_eq_crossIterate`.  It proves
the `Res_{z_0}` face, which is the one the chapter uses, and -- the key structural result --
**`corollary851_iff_jacobiIdentity_zero_face`**: the zero face of the Jacobi identity IS the landed open
`MM.FLM85Co.Corollary851`.  So the chapter's central identity and the commutator formula are the SAME
open statement, and the single remaining input of the whole route is unchanged.  It also proves Corollary
8.8.18 ((8.8.42)) as the `m = 1` face, and lands **(8.4.43)** --
`commutatorFamily_eq_two_terms_of_pairing_neg_two` -- which the earlier commutator file had never stated.

**The correction that matters.**  There is NO "Jacobi iff associativity plus commutativity" in Section 8.8:
printed 234 explicitly DENIES associativity, (8.8.21)--(8.8.28) are definitions, and the source's own
equivalence in that section is (8.8.29) iff (8.8.30) -- which this file proves.  The
commutativity-and-associativity recovery is Section 8.10 (printed 253--254) and needs the localisation
`F[z_1,z_2]_S` and the `iota_{i_1...i_n}` recursion (8.10.36)/(8.10.37), which `MM.FLMLoc` has begun.
Also corrected: the map's Section 8.8 row is off by two -- `[u x_0 v]_{mn} = [u_m, v_n]` is (8.8.17), not
(8.8.19), and (8.8.41)/(8.8.42)/(8.8.43) tag Corollaries 8.8.17/18/19. -/

/-- info: 'MM.FLM85Uq.modelOperator_kills_oscillator_and_855_fails' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Uq.modelOperator_kills_oscillator_and_855_fails

/-- info: 'MM.FLM88.jacobiIdentity_iff_delta' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM88.jacobiIdentity_iff_delta

/-- info: 'MM.FLM88.corollary851_iff_jacobiIdentity_zero_face' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM88.corollary851_iff_jacobiIdentity_zero_face

/-- info: 'MM.FLM88.corollary8818_of_jacobiIdentity' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM88.corollary8818_of_jacobiIdentity

/-- info: 'MM.FLM88.commutatorFamily_eq_two_terms_of_pairing_neg_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM88.commutatorFamily_eq_two_terms_of_pairing_neg_two

/-! ## FLM Chapter 8: the action, and the uniqueness half (batch 62)

`Definitions/MMFLM85Action.lean` (`MM.FLM85Ac`) builds the ACTION of the coefficient families on
`M(1) (x) F{L}` and lands what (8.5.6) is made of.  It proves the annihilation modes are locally
nilpotent (`modeVL_exists_eq_zero`), which is what makes (8.4.16)'s `^+` half an operator without a
completion; builds the factor machinery (`Factor`, `headOp`, `tailOp`, `tailWindow`) with
`actionFamily_apply_eq_zero_of_le` -- the per-vector truncation of the negative powers, UNCONDITIONAL,
which IS the `(End V_L){z}` condition; and identifies the landed formal family with the vacuum matrix
coefficient of the action: **`actionFold_eq_normalOrderedProductOf`**.  The named remainder is
`actionWellDefinedStatement`: that two data of one state give one operator family.

`Definitions/MMFLM85Uniqueness.lean` (`MM.FLM85Un`) does (8.5.1)'s uniqueness half and, importantly,
removes its hypothesis: `spanningStatement` proves that the states of (8.5.4) SPAN `V_L`
(`fockSpanSubmodule_eq_top` from `SymmetricAlgebra.induction`, then (7.1.23)), so
`generalVertexOperator_existsUnique` needs no spanning hypothesis, and `existsUnique_iff_compatible`
gives the clean form of the remaining input.  It also proves the exact logical shape the source asserts:
`compatible_of_satisfies` (a relation module inside the kernel is respected once (8.5.5) is a linear map)
and `exists_extension_of_compatible` (relation-respect implies existence), so the resident
`normalOrderedWellDefinedStatement` is EQUIVALENT to the existence of a function with the (8.5.5) values
-- and is implied by it, never by uniqueness.

**Two findings.**  (i) The repository's landed Fock spanning theorem (`MMFockSpan.MonoSpan`) is UNUSABLE
here: it is about `MM.Heisenberg.FockSpace`, a different symmetric algebra from `MM.FLMFock.M1`, and its
file imports the abandoned `MMLatticeVOA*` layer.  The spanning needed was proved directly.  (ii) The
landed statements `Iterate8436` / `ProductExpansion8512` use the FLAT right-hand side, so an operator-level
(8.5.5) makes them true only on `iota(1)`: off the vacuum the action is `opOpenBox + tailOp`, a
decomposition that is proved while no nonzero `tailOp` value is computed.  That is stated in the file's
header rather than glossed. -/

/-- info: 'MM.FLM85Ac.actionFold_eq_normalOrderedProductOf' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Ac.actionFold_eq_normalOrderedProductOf

/-- info: 'MM.FLM85Ac.actionFamily_apply_eq_zero_of_le' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Ac.actionFamily_apply_eq_zero_of_le

/-- info: 'MM.FLM85Un.spanningStatement' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Un.spanningStatement

/-- info: 'MM.FLM85Un.generalVertexOperator_existsUnique' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Un.generalVertexOperator_existsUnique

/-- info: 'MM.FLM85Un.existsUnique_iff_compatible' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Un.existsUnique_iff_compatible

/-! ## FLM Chapter 8: hrel stated once, and Section 8.10's axioms (batch 63)

`Definitions/MMFLM85Hrel.lean` (`MM.FLM85Hr`) states the single remaining input ONCE, in the form the rest
of the route consumes: **`Hrel`** is exactly the compatibility hypothesis of
`MM.FLM85Un.generalVertexOperator_existsUnique`, with `existsUnique_iff_hrel` and
`generalVertexOperator_existsUnique_of_hrel` making the dependence explicit, plus the action form
`HrelAction` matching `MM.FLM85Ac.actionWellDefinedStatement`.  **The Heisenberg half is DISCHARGED**:
`heis_half_discharged` shows the (7.1.5) exchanges impose no condition on the (8.5.5) family (the flat
engine `flatMul_swap` and the state side `stateOfVL_swap` with `normalOrderedFam_swap`), and the `F{L}`
half is free in the landed model (`compatible_free'`).  Two findings of record: the requested equivalence
between the two forms of `hrel` is **FALSE** -- `exists_functionForm_not_compatible` is a compiled
counterexample, and the exact missing ingredient is LINEARITY of the factorising function
(`compatible_iff_factorsThrough_linear`) -- and `hrel` does NOT force the base family to be additive,
because `iota` is not additive.  The named remainder is `ActionSwapStatement`, the ACTION's exchange
invariance at an arbitrary position.

`Definitions/MMFLM810Axioms.lean` (`MM.FLM810`) transcribes **Section 8.10's axioms and Theorem 8.10.2**,
the assembly step: it states (8.10.1)--(8.10.8) in the field-per-axiom structure `VertexOperatorAlgebra`
(thirteen fields, each docstring carrying its number), builds on the landed `MM.FLM85.WeightGrading`/
`GradedPiecesFinite`/`VertexOp`/`CreationProperty` and on `MM.FLM88.JacobiIdentity` for (8.10.8), and
PROVES what the landed layer supplies: `Lmode_vacuum_eq_zero` ((8.10.16) from (8.10.7)+(8.10.10)),
`componentTruncation_of_gradedVanishesBelow` ((8.10.5) from (8.10.3) and the landed (8.5.22)),
`jacobiAxiom_iff_deltaForm` ((8.10.8) iff the landed delta form), the transport of the creation property
across `spanningStatement`, and the `V_L` reductions `weightPiece_eq_bot_of_neg`,
`gradedVanishesBelow_of_weightPiece`, `vacuum_mem_of_weightPiece`,
`gradedPiecesFinite_of_weightPiecesFinite`.  Theorem 8.10.2 is stated as `Theorem8102` with
`theorem8102_of_fields` giving the exact list of remaining fields.

**Corrections of record.**  (a) The graded-dimension axiom is (8.10.2) with (8.10.3); (8.10.4) is the
state-field map and (8.10.5) the truncation -- the brief's numbering was wrong.  (b)
`MM.FLMLattice.WeightPiecesFinite` is a NAMED OPEN statement, so (8.10.2) does not follow from landed
results -- only the reduction does.  (c) The creation property does not follow from landed results either;
what is proved is its transport from the spanning family.  (d) (8.10.7) has TWO halves and the landed
(8.5.8) is only the limit half; the other half (`v_n . 1 = 0` for `n >= 0`) is what proves (8.10.16), and
the landed `MM.FLM85.creationProperty_tail` docstring mis-identifies itself with it.  (e) The vendored
`VertexAlgebra1` does state both halves of (8.10.7) but under a ring unit and with no grading -- three
measured reasons it is not the target are in the file's header. -/

/-- info: 'MM.FLM85Hr.existsUnique_iff_hrel' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Hr.existsUnique_iff_hrel

/-- info: 'MM.FLM85Hr.heis_half_discharged' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Hr.heis_half_discharged

/-- info: 'MM.FLM85Hr.exists_functionForm_not_compatible' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85Hr.exists_functionForm_not_compatible

/-- info: 'MM.FLM810.jacobiAxiom_iff_deltaForm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810.jacobiAxiom_iff_deltaForm

/-- info: 'MM.FLM810.VertexOperatorAlgebra.Lmode_vacuum_eq_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810.VertexOperatorAlgebra.Lmode_vacuum_eq_zero

/-! ## FLM Chapter 8: the action's swap, and two fields of Theorem 8.10.2 (batch 64)

`Definitions/MMFLM85ActionSwap.lean` (`MM.FLM85AS`) lands the fold machinery for the action's exchange
invariance (`foldr_swap_append'`, `ofFn_congr'`).  Batch 64 isolated two sub-goals: arbitrary-position
bookkeeping and the associativity identity
`:X:YZ:: = ::XY:Z:` of (8.4.16).  **Its substantive finding, recorded in the file's header**: the action of
(8.4.16) is ASSOCIATIVE for arbitrary families, so the exchange invariance needs NEITHER of the two
same-sign commutation hypotheses that `MM.FLM85Hr.ActionSwapStatement`'s docstring and batch 64's brief
named -- `[X,Y]` exchanges with no hypotheses at all, because the internal substitution telescopes.  So
Batch 65 closes the bookkeeping directly at the list interface; the associativity identity remains
before the action half, and the Heisenberg half remains the only discharged part.

`Definitions/MMFLM810Fields.lean` (`MM.FLM810F`) discharges two fields of Theorem 8.10.2 for the landed
model: **`Y(1,z) = 1`** ((8.10.6) -- `YCoeff_latticeElement_of_zero`, `modelBase_unit`) and **the FIRST
half of (8.10.7)**, `Y(v,z) 1 in V[[z]]` (`creationRegular_of_prescription`, derived from the landed
`FiveDatum.normalOrderedProductOf_eq_zero_of_neg` and extended to all of `V_L` by
`MM.FLM85Un.spanningStatement`).  Under the route's input `Hrel` it gives
`exists_vacuumOperator_creationRegular_of_hrel` and states the SHORTENED remaining list
(`RemainingFields`) with `theorem8102_of_hrel_modelBase`: `Hrel` plus six named fields imply Theorem 8.10.2.

**Two corrections, and the first is a false statement about the landed layer.**
1. **Reading the 8.10 axiom fields through `MM.FLM85Ext.toVertexOp` makes them FALSE**, and this is a
   theorem: `toVertexOp_not_vacuumOperator` fails at `(v, 0)` for every `v != 0`.  The landed
   (8.4.17)/(8.5.5) layer (`flatMul`, `expField`, `YCoeff`, `normalOrderedFam`, `actionFold`) is
   POWER-indexed while `VertexOp`/`component` and the axiom fields are COMPONENT-indexed; the fields
   therefore had to be stated at the (8.5.15) re-indexed `vertexOpOfField`, which is also the only reading
   consistent with `CreationProperty` at index `-1` corresponding to power `0`.  *This is a landed-interface
   mismatch of the same kind as batches 58 and 62, and the third one found by a compiler rather than a
   reader.*
2. **(8.10.6) is not cyclicity**: it is `Y(1,z) = 1`, the vacuum AS AN OPERATOR being the identity; the
   cyclicity statement is (8.10.7), and no spanning input is needed for (8.10.6).  Also recorded:
   `MM.FLMLatSt.latticeState_eq_exp` is NOT the tool (8.10.6) needs; the landed
   `expField_eq_identityField_of_no_positive` and `actVL_zero` are. -/

/-- info: 'MM.FLM85AS.foldr_swap_append'' depends on axioms: [Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AS.foldr_swap_append'

/-! Batch 65 closes the arbitrary-position bookkeeping directly at the list interface, avoiding the
dependent `Fin` transposition: `eq_take_pair_append_drop` exposes the pair and `foldr_swap_at`
transports its exchange through the right fold.  The remaining local obstacle is the operator-family
associativity identity. -/

/-- info: 'MM.FLM85AS.eq_take_pair_append_drop' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AS.eq_take_pair_append_drop

/-- info: 'MM.FLM85AS.foldr_swap_at' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AS.foldr_swap_at

/-! ## FLM Chapter 8: the creation axiom and five-field assembly (batch 66)

`Definitions/MMFLM810Creation.lean` identifies the concrete action factors with the factor list of
(8.5.5), transfers `actionFold_vacuum_zero` to the prescription, and proves the second half of
(8.10.7), `v_{-1} 1 = v`, for the linear extension.  Consequently the Section 8.10 reduction now
asks for five open fields rather than six. -/

/-- info: 'MM.FLM810C.normalOrderedFam_zero_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810C.normalOrderedFam_zero_vacuum

/-- info: 'MM.FLM810C.creationProperty_of_prescription_modelBase' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810C.creationProperty_of_prescription_modelBase

/-- info: 'MM.FLM810C.theorem8102_of_hrel_modelBase_after_creation' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810C.theorem8102_of_hrel_modelBase_after_creation

/-! ## FLM Chapter 8: component truncation and four-field assembly (batch 67)

`Definitions/MMFLM810Truncation.lean` proves (8.10.5) directly from the support of the (8.5.5)
prescription and the spanning theorem.  At the model base every component `u_n` with `n >= 0`
vanishes, so the Section 8.10 reduction now asks for only Jacobi, `L(0)`, translation and Virasoro. -/

/-- info: 'MM.FLM810T.componentTruncation_modelBase' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810T.componentTruncation_modelBase

/-- info: 'MM.FLM810T.theorem8102_of_hrel_modelBase_after_truncation' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810T.theorem8102_of_hrel_modelBase_after_truncation

/-! ## FLM Chapter 8: the genuine action-valued extension (batch 68)

`Definitions/MMFLM85ActionExtension.lean` corrects the route boundary: `normalOrderedFam` is only
the vacuum-sector flat family, while `actionPrescription` is the operator on all of `V_L` and keeps
the annihilation tail.  `ActionHrel` is now the exact relation-respect statement whose proof produces
the genuine lattice vertex operator. -/

/-- info: 'MM.FLM85AE.actionPrescription_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AE.actionPrescription_vacuum

/-- info: 'MM.FLM85AE.existsUnique_iff_actionHrel' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AE.existsUnique_iff_actionHrel

/-- info: 'MM.FLM85AE.generalVertexOperatorAction_existsUnique' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AE.generalVertexOperatorAction_existsUnique

/-- info: 'MM.FLM85AE.creationProperty_action_modelBase' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AE.creationProperty_action_modelBase

/-! ## FLM Chapter 8: genuine-action truncation and honest assembly (batch 69)

`Definitions/MMFLM85ActionTruncation.lean` transports the per-vector truncation of `actionFold`
through the spanning states.  `Definitions/MMFLM810ActionFields.lean` proves vacuum and creation
regularity for the full action and gives the honest Section 8.10 reduction: `ActionHrel` plus Jacobi,
`L(0)`, translation and Virasoro imply Theorem 8.10.2. -/

/-- info: 'MM.FLM85AT.componentTruncation_action_modelBase' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AT.componentTruncation_action_modelBase

/-- info: 'MM.FLM810AF.vacuumOperator_action_modelBase' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810AF.vacuumOperator_action_modelBase

/-- info: 'MM.FLM810AF.creationRegular_action_modelBase' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810AF.creationRegular_action_modelBase

/-- info: 'MM.FLM810AF.theorem8102_of_actionHrel' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810AF.theorem8102_of_actionHrel

/-! ## FLM Chapter 8: both Heisenberg halves for the genuine action (batch 70)

`Definitions/MMFLM85ActionRelations.lean` proves the positive-mode counterpart of the already landed
creation-mode exchange, computes every `splitPlus` coefficient of a differentiated factor as zero or
a scalar multiple of one nonnegative Heisenberg mode, and discharges coefficientwise commutation of
the two annihilation halves.  Consequently the adjacent oscillator exchange for the genuine
`actionPrescription` is reduced exactly to `ActionSwapStatement`; no concrete same-sign commutation
fact remains open. -/

/-- info: 'MM.FLM85AR.modeVL_mul_modeVL_of_nonneg' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AR.modeVL_mul_modeVL_of_nonneg

/-- info: 'MM.FLM85AR.splitPlus_factorFamily_mul_comm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AR.splitPlus_factorFamily_mul_comm

/-- info: 'MM.FLM85AR.actionPrescription_swap_of_actionSwap' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AR.actionPrescription_swap_of_actionSwap

/-- info: 'MM.FLM85AR.action_heis_exchange_of_actionSwap' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AR.action_heis_exchange_of_actionSwap

/-! ## Corrected lower-truncated normal ordering (batch 71)

`Definitions/MMFLM85TrueAction.lean` attaches the lower-truncation datum needed by the creation-half
convolution, defines the corrected one-factor action and its recursive fold, and proves that it is
again lower truncated.  It also proves the exact recovery theorem for nonnegative accumulated
families and isolates the omitted `X^-_0 Y_{-1}` term at the first negative power of the old head. -/

/-- info: 'MM.FLM85TA.headOp_ofNonnegative' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85TA.headOp_ofNonnegative

/-- info: 'MM.FLM85TA.headOp_neg_one_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85TA.headOp_neg_one_apply

/-- info: 'MM.FLM85TA.headOp_ne_old_of_neg_one_term_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85TA.headOp_ne_old_of_neg_one_term_ne_zero

/-- info: 'MM.FLM85TA.actionFamily_trunc' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85TA.actionFamily_trunc

/-- info: 'MM.FLM85TA.actionFold' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85TA.actionFold

/-- info: 'MM.FLM810F.vacuumOperator_of_prescription' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810F.vacuumOperator_of_prescription

/-- info: 'MM.FLM810F.creationRegular_of_prescription' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810F.creationRegular_of_prescription

/-- info: 'MM.FLM810F.toVertexOp_not_vacuumOperator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810F.toVertexOp_not_vacuumOperator

/-- info: 'MM.FLM810F.theorem8102_of_hrel_modelBase' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810F.theorem8102_of_hrel_modelBase

/-! ## FLM 8.1 closed: the `F[z,z⁻¹]`-module axiom (batch 72)

`Definitions/MMFLM81Module.lean` carried one named gap, `LaurentSmulAssocStatement`: the
associativity of the shift action `laurentSmul (f * g) v = laurentSmul f (laurentSmul g v)`, i.e. the
last module axiom of FLM (2.1.20) for `F[[z,z⁻¹]]`.  It is now a **theorem** (the `def` was replaced
in place).  `Definitions/MMFLM81SlmulAssoc.lean` carries the endomorphism packaging the proof is
built from -- `AddMonoidAlgebra.liftNC` at the monoid hom `n ↦ (z^n .)` -- and derives the two
endomorphism-level forms of the law. -/

/-- info: 'MM.FLM81.LaurentSmulAssocStatement' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM81.LaurentSmulAssocStatement

/-- info: 'MM.FLM81.laurentSmulEnd_mul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM81.laurentSmulEnd_mul

/-! ## The corrected action's composition law (batch 72)

`Definitions/MMFLM85ActionAlgebra.lean` (`MM.FLM85AA`) lands the engine the batch-71 handoff asked
for: the composition law of the *corrected* normal-ordered product `MM.FLM85TA.actionFamily`, in the
form the fold consumes -- two adjacent factors of (8.5.5) whose same-sign halves commute (FLM (7.1.5))
may be exchanged.  The proof runs through the four-term `expansion` of `:X(YW):` in two shared
windows, so the index sets are square and one Fubini transposition supplies the comparison; the two
mixed words `X^-WY^+` and `Y^-WX^+` are compared by pure reindexing and need no hypothesis.  This is
what turns the cut-off fold of `MM.FLM85Ac` into the genuine action of (8.5.5). -/

/-- info: 'MM.FLM85AA.actionFold_swap_of_sameSign' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AA.actionFold_swap_of_sameSign

/-- info: 'MM.FLM85AA.actionFamily_actionFamily_swap_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AA.actionFamily_actionFamily_swap_apply

/-- info: 'MM.FLM85AA.actionFamily_action_eq_expansion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AA.actionFamily_action_eq_expansion

/-- info: 'MM.FLM85AA.expansion_swap' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AA.expansion_swap

/-- info: 'MM.FLM85AA.actionFamily_fieldAdd' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AA.actionFamily_fieldAdd

/-! ## Batch 73: the fold is order-independent, and the cut-off-object diagnosis

`Definitions/MMFLM85ActionPerm.lean` (`MM.FLM85AP`) lifts the adjacent transposition of batch 72 to
an arbitrary permutation of the factor list of (8.5.5) (`actionFold_perm_of_pairwise`), proves the
concrete (8.5.4) factors satisfy the two (7.1.5) hypotheses unconditionally, and defines the
CORRECTED prescription `actionPrescriptionTA` on the lower-truncated fold.  It also contains the
definitional diagnosis `actionPrescription_eq_cutOffFold`, which settles what batch 71's route
correction did not: the landed `MM.FLM85AE.actionPrescription` is the CUT-OFF fold, not the
corrected one, so the assembly track is not yet on the object batch 71 identified as correct.

`Definitions/MMFLM85LabelLinearity.lean` (`MM.FLM85LL`) proves the label-linearity chain the
corrected prescription needed (the Heisenberg modes ARE additive in the label, `modeVL_add`,
`factorFamily_add`, `factorFactor_add`), hence `LabelAdditive` for `actionPrescriptionTA`, hence
`ActionHrelTA` and the existence--uniqueness of the (8.5.5) vertex operator on the corrected object,
conditional only on the named spanning statement `RelSpanningStatement`. -/

/-- info: 'MM.FLM85AP.actionFold_perm_of_pairwise' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AP.actionFold_perm_of_pairwise

/-- info: 'MM.FLM85AP.actionPrescriptionTA_swap' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AP.actionPrescriptionTA_swap

/-- info: 'MM.FLM85AP.actionPrescription_eq_cutOffFold' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85AP.actionPrescription_eq_cutOffFold

/-- info: 'MM.FLM85LL.modeVL_add' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85LL.modeVL_add

/-- info: 'MM.FLM85LL.factorFactor_add' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85LL.factorFactor_add

/-- info: 'MM.FLM85LL.labelAdditive_actionPrescriptionTA' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85LL.labelAdditive_actionPrescriptionTA

/-- info: 'MM.FLM85LL.actionHrelTA_of_spanning' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85LL.actionHrelTA_of_spanning

/-- info: 'MM.FLM85LL.existsUnique_actionPrescriptionTA_of_spanning' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85LL.existsUnique_actionPrescriptionTA_of_spanning

/-! ## Batch 74: the assembly is MIGRATED to the corrected object, and the named spanning
statement of batch 73 is REFUTED

Two corrections, both dispatcher-verified.

**(1) The Section 8.10 assembly now runs on the corrected (8.5.5) prescription.**
`Definitions/MMFLM85TrueActionVacuum.lean` ports the vacuum layer to `MM.FLM85TA.actionFold` (its
`headOp_vacuum_eq_cutOff` is the whole content of the correction on `ι(1)`),
`Definitions/MMFLM85ActionTruncationTA.lean` proves (8.10.5) there -- strictly stronger than the
landed version, which needed a pointwise base bound that the bundled truncation datum now supplies --
and `Definitions/MMFLM810ActionFieldsTA.lean` proves (8.10.6) and both halves of (8.10.7) and lands
the corrected assembly boundary: `ActionHrelTA` plus four fields imply Theorem 8.10.2.

**(2) `MM.FLM85AP.RelSpanningStatement` (batch 73's named input) is FALSE, and now provably so.**
`MM.FLM85Hr.heisRel` records only the exchange of the FIRST TWO factors of the list, while `stateOfVL`
is a symmetric function of the whole list, so an exchange at any later position is a relation the
landed module misses.  `MM.FLM85RS.not_relSpanningStatement` is a compiled refutation over `L = ℤ`:
the explicit functional `psi` kills `heisRel ⊔ labelRel` but takes the value `-2` on the relation
`⟨[A,B,C],0⟩ − ⟨[A,C,B],0⟩`, which lies in the kernel of the state map
(`MM.FLM85RS.badRel_mem_ker`).  The corrected relation module is `MM.FLM85RS.permRel` (exchanges at
every position), whose spanning statement `PermSpanningStatement` is the honest remaining input, and
`MM.FLM85RS.actionHrelTA_of_permSpanning` /
`MM.FLM85RS.existsUnique_actionPrescriptionTA_of_permSpanning` consume it.  Note that
`MM.FLM810AFT.theorem8102_of_relSpanning` therefore has a FALSE hypothesis -- use
`MM.FLM810AFT.theorem8102_of_actionHrel` (or the `permSpanning` route) instead. -/

/-- info: 'MM.FLM85TAV.headOp_vacuum_eq_cutOff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85TAV.headOp_vacuum_eq_cutOff

/-- info: 'MM.FLM85TAV.actionPrescriptionTA_zero_vacuum_modelBase' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85TAV.actionPrescriptionTA_zero_vacuum_modelBase

/-- info: 'MM.FLM85ATT.componentTruncation_of_actionPrescriptionTA' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85ATT.componentTruncation_of_actionPrescriptionTA

/-- info: 'MM.FLM810AFT.theorem8102_of_actionHrel' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810AFT.theorem8102_of_actionHrel

/-- info: 'MM.FLM85RS.badRel_mem_ker' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85RS.badRel_mem_ker

/-- info: 'MM.FLM85RS.not_relSpanningStatement' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85RS.not_relSpanningStatement

/-- info: 'MM.FLM85RS.permRel_le_ker' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85RS.permRel_le_ker

/-- info: 'MM.FLM85RS.actionHrelTA_of_permSpanning' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85RS.actionHrelTA_of_permSpanning

/-! ## Batch 75: relation calculus for the corrected (8.5.6) presentation -/

/-- info: 'MM.FLM85RC.permRel_of_perm_append' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85RC.permRel_of_perm_append

/-- info: 'MM.FLM85RC.labelRel_zsmul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85RC.labelRel_zsmul

/-- info: 'MM.FLM85RC.labelRel_basisExpansion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85RC.labelRel_basisExpansion

/-! ## Batch 76: the corrected (8.5.6) relation presentation is complete

`Definitions/MMFLM85BasisReduction.lean` expands every oscillator label over an integral lattice
basis modulo `labelRel`.  `Definitions/MMFLM85MonomialBasis.lean` identifies the resulting
basis-labelled words with the standard symmetric-algebra/tensor-product basis of `V_L`; equality of
their exponent vectors is exactly `List.Perm`.  Finally `Definitions/MMFLM85PermSpanning.lean`
proves the general free-module fibre-kernel theorem and applies it to obtain
`PermSpanningStatement`, the exact kernel equality, unconditional `ActionHrelTA`, and the unique
linear vertex-operator map of FLM (8.5.6). -/

/-- info: 'MM.FLM85BR.labelRel_sup_basisStateSpan_eq_top' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85BR.labelRel_sup_basisStateSpan_eq_top

/-- info: 'MM.FLM85MB.stateOfVL_basisWord_eq_vlMonomialBasis' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85MB.stateOfVL_basisWord_eq_vlMonomialBasis

/-- info: 'MM.FLM85PS.ker_lmapDomain_eq_fiberRel' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85PS.ker_lmapDomain_eq_fiberRel

/-- info: 'MM.FLM85PS.permSpanningStatement' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85PS.permSpanningStatement

/-- info: 'MM.FLM85PS.kernelEqPermRelations' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85PS.kernelEqPermRelations

/-- info: 'MM.FLM85PS.actionHrelTA' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85PS.actionHrelTA

/-- info: 'MM.FLM85PS.existsUnique_actionPrescriptionTA' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85PS.existsUnique_actionPrescriptionTA

/-- info: 'MM.FLM810CA.theorem8102_of_remainingFields' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CA.theorem8102_of_remainingFields

/-! ## Batch 77: the four remaining fields are reduced to construction generators

`Definitions/MMFLM810RemainingReduction.lean` uses the spanning states (8.5.4) and the defining
generators of `weightPiece` to eliminate arbitrary target vectors from the remaining verification
boundary.  The reductions are purely linear and introduce no conformal-vector assumptions. -/

/-- info: 'MM.FLM810RR.l0Grading_of_weightGenerators' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810RR.l0Grading_of_weightGenerators

/-- info: 'MM.FLM810RR.translationAxiom_of_stateData' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810RR.translationAxiom_of_stateData

/-- info: 'MM.FLM810RR.virasoroAxiomsOf_of_stateData' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810RR.virasoroAxiomsOf_of_stateData

/-- info: 'MM.FLM810RR.jacobiAxiom_of_stateTargets' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810RR.jacobiAxiom_of_stateTargets

/-- info: 'MM.FLM810RR.theorem8102_of_generatorFields' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810RR.theorem8102_of_generatorFields

/-! ## Batch 78: the conformal vector is landed on the current carrier -/

/-- info: 'MM.FLM810CV.conformalVector_mem_weightPiece_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CV.conformalVector_mem_weightPiece_two

/-- info: 'MM.FLM810CV.conformalStateSum_eq_conformalVector' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CV.conformalStateSum_eq_conformalVector

/-- info: 'MM.FLM810CV.field_conformalVector' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CV.field_conformalVector

/-- info: 'MM.FLM810CV.LOf_conformalVector' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CV.LOf_conformalVector

/-! ## §8.6 source correction: the (8.6.3) factor is an operator -/

/-- info: 'MM.FLM86M.constraint864_sum_of_independent'' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86M.constraint864_sum_of_independent'

/-- info: 'MM.FLM86M.constraint864_iff_sum_and_eps_of_independent' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86M.constraint864_iff_sum_and_eps_of_independent

/-- info: 'MM.FLM86OD.sourceBigradingCoeff861_apply_tmul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OD.sourceBigradingCoeff861_apply_tmul

/-- info: 'MM.FLM86N.operatorDisplay8615_zero_iff_8612' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86N.operatorDisplay8615_zero_iff_8612

/-- info: 'MM.FLM86N.operatorLimitExists_operatorTheta8620' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86N.operatorLimitExists_operatorTheta8620

/-- info: 'MM.FLM86OD.sourceDelta861_eq_normalized' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OD.sourceDelta861_eq_normalized

/-- info: 'MM.FLM86OD.sourceDeltaExp861_eq_normalized' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OD.sourceDeltaExp861_eq_normalized

/-- info: 'MM.FLM86OD.sourceRightFactorTerm861All_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OD.sourceRightFactorTerm861All_apply

/-- info: 'MM.FLM86.sourceShift861_iotaVL_self' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86.sourceShift861_iotaVL_self

/-- info: 'MM.FLM86.sourceShift861_mul_actVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86.sourceShift861_mul_actVL

/-- info: 'MM.FLM86OD.sourceDelta861OnIota_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OD.sourceDelta861OnIota_apply

/-- info: 'MM.FLM86OD.sourceDelta861OnIota_apply_tmul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OD.sourceDelta861OnIota_apply_tmul

/-- info: 'MM.FLM86OD.sourceDeltaExp861OnIota_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OD.sourceDeltaExp861OnIota_apply

/-- info: 'MM.FLM86OD.sourceRightFactorTerm861_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OD.sourceRightFactorTerm861_apply

/-- info: 'MM.FLM86OD.sourceRightFactorTerm861_apply_tmul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OD.sourceRightFactorTerm861_apply_tmul

/-! ## Batches 98--99: central charge fixed, and a false corrected-Virasoro reduction retired

`MM.FLM810CC.centralCharge_vacuum_finrank` verifies from the `(2,-2)` vacuum bracket that the
Sugawara field has central charge `rank L`, not either of the previously recorded larger values.
The direct successor check is equally important: normal ordering a corrected `n = 1` factor against
the identity field returns that factor, so its power-zero coefficient is the creation mode and the
former vanishing input to the corrected-Virasoro reduction is false.  The rank-one counterexample is
guarded below; it prevents a proof plan from silently treating this as an elaboration issue. -/

/-- info: 'MM.FLM810CC.centralCharge_vacuum_finrank' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CC.centralCharge_vacuum_finrank

/-- info: 'MM.FLM810CC.centralCharge_modelBase_finrank' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CC.centralCharge_modelBase_finrank

/-- info: 'MM.FLM810VC3.vc3_action_zero_eq_mode' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810VC3.vc3_action_zero_eq_mode

/-- info: 'MM.FLM810CCProbe.not_probe_vc3_action_zero_statement' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CCProbe.not_probe_vc3_action_zero_statement

/-! ## Batch 105: the §8.6 operator Θ, the §8.7 convolution, and the named-Jacobi bridge

Every declaration below is guarded in its own file as well; the guards are repeated here because this
file is the delivery gate, and because the three new groups carry the corrections of record that
batch 105 produced: the landed (8.6.20) pre-factor is *not* the source's operator (W1), the full
convolution retains the negative-power coefficients the refuted two-term window dropped (W2), and
the landed `MM.FLM810.JacobiAxiom` was **free** — it held for every `VertexOp` — so the named
hypothesis used for the bridge is the repaired one (W3). -/

/-! ## Tasks W6 and W7: the two repairs of the landed Jacobi axiom

Batch 105 compiled the defect (the group above, W3); task W6 repaired it by conjoining the source's
finiteness gloss as `MM.FLM88.CrossWindow`; task W7 replaced that conjunct by the source's own
per-monomial, per-element reading (`MMFLM810JF.FaithfulJacobi`), because task W5 measured the W6
conjunct to be equivalent, in characteristic zero, to the vanishing of every component product
(`MM.FLM810JB.jacobi8108_iff_zeroProduct`) — i.e. not a finiteness statement at all.

The landed `MM.FLM810.JacobiAxiom` is therefore **no longer the same statement** as the named
`MM.FLM810NB.Jacobi8108`, and the three declarations of W6 that identified the two
(`jacobiAxiom_iff_jacobi8108`, `jacobi8108_jacobiAxiom`,
`prop8107EquivalenceLanded_iff_Prop8107Equivalence`) are gone — they were `Iff.rfl`/`:=
h` and are false now.  Their replacements are `MM.FLM810NB.crossWindowVectorwise_of_jacobi8108`
(what the W6 predicate does give: the source's cross-side finiteness) and
`MM.FLM810NB.jacobiAxiom_of_crossWindow_iterateWindow` (the W6 data plus the iterate side's finiteness
at the same window gives the landed axiom).  Batch 105's theorem
`MM.FLM810NB.proposition8107_landed_is_the_route` — the identification of the landed
`MM.FLM810Rat.Proposition8107` with the book's route — is gone for the same reason.

The axiom is not free (`MM.FLM810NB.not_jacobiAxiom_model`) and not vacuous
(`MM.FLM810JB.jacobiAxiom_of_squareZeroIdeal` produces witnesses), and its finiteness conjunct is
strictly weaker than the W6 one, with a witness: `MM.FLM810FM.scalarModel_crossWindowPointwise`
(the scalar model satisfies the per-monomial reading) together with
`MM.FLM810FM.not_crossWindow_scalarModel` (it satisfies `CrossWindow` at no window).  The defunct
predicate of batch 105 is kept, with its freeness, as
`MM.FLM810NB.JacobiAxiomUnconstrained` / `jacobiAxiomUnconstrained_free`, so that the original defect
stays reproducible; the separation is `jacobiAxiomUnconstrained_not_sufficient_model`. -/

/-- info: 'MM.FLM810NB.crossWindowVectorwise_of_jacobi8108' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810NB.crossWindowVectorwise_of_jacobi8108

/-- info: 'MM.FLM810NB.jacobiAxiom_of_crossWindow_iterateWindow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810NB.jacobiAxiom_of_crossWindow_iterateWindow

/-- info: 'MM.FLM810NB.iterateSummand_vanishes_of_truncation' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810NB.iterateSummand_vanishes_of_truncation

/-- info: 'MM.FLM810NB.jacobiAxiomUnconstrained_free' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810NB.jacobiAxiomUnconstrained_free

/-- info: 'MM.FLM810NB.not_jacobiAxiom_model' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810NB.not_jacobiAxiom_model

/-- info: 'MM.FLM810NB.jacobiAxiomUnconstrained_not_sufficient_model' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810NB.jacobiAxiomUnconstrained_not_sufficient_model

/-- info: 'MM.FLM810JF.crossWindowVectorwise_of_truncation' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810JF.crossWindowVectorwise_of_truncation

/-- info: 'MM.FLM810JF.iterateWindowVectorwise_of_truncation' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810JF.iterateWindowVectorwise_of_truncation

/-- info: 'MM.FLM810JF.faithfulJacobi_iff_stable' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810JF.faithfulJacobi_iff_stable

/-- info: 'MM.FLM810JB.jacobiAxiom_of_squareZeroIdeal' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810JB.jacobiAxiom_of_squareZeroIdeal

/-- info: 'MM.FLM810FM.scalarModel_crossWindowPointwise' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810FM.scalarModel_crossWindowPointwise

/-- info: 'MM.FLM810FM.scalarModel_crossWindowVectorwise' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810FM.scalarModel_crossWindowVectorwise

/-- info: 'MM.FLM810FM.not_crossWindow_scalarModel' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810FM.not_crossWindow_scalarModel

/-- info: 'MM.FLM86T.operatorTotalLimitExists_thetaMulOperator8620' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86T.operatorTotalLimitExists_thetaMulOperator8620

/-- info: 'MM.FLM86T.not_exists_uniform_window_bound_uPowMulNegOperatorCoeff2Z' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86T.not_exists_uniform_window_bound_uPowMulNegOperatorCoeff2Z

/-- info: 'MM.FLM86T.operatorTheta8620_diag_ne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86T.operatorTheta8620_diag_ne

/-- info: 'MM.FLM87SC.actionFold_pair_oneField_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SC.actionFold_pair_oneField_apply

/-- info: 'MM.FLM87SA.LOf_conformalVectorZero_vacuumNormalized' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SA.LOf_conformalVectorZero_vacuumNormalized

/-- info: 'MM.FLM87SA.correctedGoal8109_of_freeBosonBracket' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SA.correctedGoal8109_of_freeBosonBracket

/-- info: 'MM.FLM87SA.centralCharge_of_freeBosonBracketZero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SA.centralCharge_of_freeBosonBracketZero

/-- info: 'MM.FLM810NB.productRationality_of_jacobi8108_to_bridge' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810NB.productRationality_of_jacobi8108_to_bridge

/-- info: 'MM.FLM810NB.not_jacobi8108_model' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810NB.not_jacobi8108_model

/-! ## Batch 106: the operator residue family, and the measurement that the repaired Jacobi axiom is not the source's

W5's guards are the load-bearing ones: `jacobi8108_iff_zeroProduct` says the finiteness conjunct landed
by W6 (a window uniform in all `(l,m,n)`) forces every product of two component operators to vanish in
characteristic zero, so `prodCoef = 0` and the iota-bridge is discharged vacuously.  Task W7 carried out
the repair that sentence calls for: the landed cone reads the source's own per-monomial, per-element
gloss (`MMFLM810JF.FaithfulJacobi`), and the W6 predicate `Jacobi8108` remains as the strictly stronger
one it was measured to be — see the W6/W7 group below, where the strictness is compiled with the scalar
model of `Definitions/MMFLM810FaithfulModel.lean`. -/

/-- info: 'MM.FLM86R.operatorTotalLimitExists_resumCoeffOperator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86R.operatorTotalLimitExists_resumCoeffOperator

/-- info: 'MM.FLM86R.resumCoeffOperator_eq_sourcePrefactorMulOperator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86R.resumCoeffOperator_eq_sourcePrefactorMulOperator

/-- info: 'MM.FLM86R.resumCoeffOperator_eq_thetaMulOperator8620' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86R.resumCoeffOperator_eq_thetaMulOperator8620

/-! ## Task W9: the operator Taylor step (8.6.22), and the repair of the (8.6.20) prefactor

The two files `Definitions/MMFLM86TaylorOperatorAux.lean` / `Definitions/MMFLM86TaylorOperator.lean`
carry the operator analogue of `MM.FLM84Y.resumCoeff_eq_taylorCoeff` -- (8.6.21) = (8.6.22) -- and the
`(z_1-z_2)^j` compatibility of the residue family with the source's quadrant bound.  The second of
those is the *corrected* form of `MM.FLM86R.ResidueUMulCompatibilityStatement`, whose hypothesis-free
form is refuted by `MM.FLM86Y.not_residueUMulCompatibilityStatement_one`.  The prefactor guards below
are the repaired state of `MM.FLM86T.thetaMulOperator8620`: the source's unit `(-1)^{-N}` sits on the
`z_1`-ray alone, so the object *is* `MM.FLM86R.sourcePrefactorMulOperator` and satisfies (8.6.21); the
batch-106 refutations `..._ne_thetaMulOperator8620` and the old
`..._eq_thetaMulOperator8620` point-value reading are retired (their statements are recorded in the
docstrings of `MM.FLM86T.thetaMulOperator8620` and of §5 of the residue file). -/

/-- info: 'MM.FLM86T.thetaMulOperator8620_apply_deltaOpCoeff2_id' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86T.thetaMulOperator8620_apply_deltaOpCoeff2_id

/-- info: 'MM.FLM86Y.resumCoeffOperator_eq_taylorCoeffOperator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86Y.resumCoeffOperator_eq_taylorCoeffOperator

/-- info: 'MM.FLM86Y.resumCoeffOperator_uPowMulOperatorCoeff2' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86Y.resumCoeffOperator_uPowMulOperatorCoeff2

/-- info: 'MM.FLM86Y.not_residueUMulCompatibilityStatement_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86Y.not_residueUMulCompatibilityStatement_one

/-- info: 'MM.FLM86R.sourcePrefactorMulOperator_eq_thetaMulOperator8620' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86R.sourcePrefactorMulOperator_eq_thetaMulOperator8620

/-- info: 'MM.FLM86Y.taylorCoeffOperator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86Y.taylorCoeffOperator

/-- info: 'MM.FLM86Y.diagTaylorOperator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86Y.diagTaylorOperator

/-- info: 'MM.FLM86Y.binomCoeffFinDiff_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86Y.binomCoeffFinDiff_eq

/-- info: 'MM.FLM86R.sourcePrefactorMulOperator_apply_deltaOpCoeff2' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86R.sourcePrefactorMulOperator_apply_deltaOpCoeff2

/-- info: 'MM.FLM86R.resumCoeffOperator_eq_sourcePrefactorMulOperator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86R.resumCoeffOperator_eq_sourcePrefactorMulOperator

/-- info: 'MM.FLM86R.resumCoeffOperator_deltaOpCoeff2_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86R.resumCoeffOperator_deltaOpCoeff2_ne_zero

/-- info: 'MM.FLM810JB.jacobi8108_iff_zeroProduct' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810JB.jacobi8108_iff_zeroProduct

/-- info: 'MM.FLM810JB.prodCoef_eq_zero_of_jacobi8108' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810JB.prodCoef_eq_zero_of_jacobi8108

/-- info: 'MM.FLM810JB.jacobi8108ToIotaBridge_of_charZero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810JB.jacobi8108ToIotaBridge_of_charZero

/-- info: 'MM.FLM810JBAux.crossWindow_zero_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810JBAux.crossWindow_zero_iff

/-! ## Batch 107: the faithful Jacobi axiom, the Fock-to-lattice Sugawara transport, and (8.6.22)

The load-bearing guards here are the pair that replaces the batch-106 defect: `FaithfulJacobi` states the
source's per-monomial, per-element finiteness, and the scalar model satisfies it while satisfying the
uniform `CrossWindow` at no window — so the faithful predicate is not vacuous and the uniform one is
strictly stronger.  W8's transport is the first bracket statement about the *actual* carrier
`M1 F L ⊗ F{L}`; its one remaining hypothesis, `SugawaraFoldIdentity`, is named after the fold it
identifies and not after the bracket it yields. -/

/-- info: 'MM.FLM810JF.crossWindowVectorwise_of_truncation' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810JF.crossWindowVectorwise_of_truncation

/-- info: 'MM.FLM810FM.scalarModel_crossWindowVectorwise' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810FM.scalarModel_crossWindowVectorwise

/-- info: 'MM.FLM810FM.not_crossWindow_scalarModel' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810FM.not_crossWindow_scalarModel

/-- info: 'MM.FLM87ST.fockEquiv_mode' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ST.fockEquiv_mode

/-- info: 'MM.FLM87ST.fockSugawaraVL_bracket' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ST.fockSugawaraVL_bracket

/-- info: 'MM.FLM87ST.freeBosonSugawaraBracket_of_foldIdentity' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ST.freeBosonSugawaraBracket_of_foldIdentity

/-- info: 'MM.FLM86Y.resumCoeffOperator_eq_taylorCoeffOperator' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86Y.resumCoeffOperator_eq_taylorCoeffOperator

/-- info: 'MM.FLM86R.resumCoeffOperator_eq_thetaMulOperator8620' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86R.resumCoeffOperator_eq_thetaMulOperator8620

/-- info: 'MM.FLM86Y.not_residueUMulCompatibilityStatement_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86Y.not_residueUMulCompatibilityStatement_one

/-! ## Batch 108: the vacuum row of the Sugawara fold/Fock comparison

The full operator identity `SugawaraFoldIdentity` remains open, but its high-mode vacuum row is now
proved on both sides: the FLM (8.4.16) fold and the transported normal-ordered Fock sum both kill
`1 ⊗ ι(0)` for every `n ≥ -1`. -/

/-- info: 'MM.FLM87SV.sugawaraMode_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.sugawaraMode_vacuum

/-- info: 'MM.FLM87SV.fockSugawaraVL_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.fockSugawaraVL_vacuum

/-- info: 'MM.FLM87SV.sugawaraFoldIdentity_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.sugawaraFoldIdentity_vacuum

/-! ## Batch 109: the `L(-2)` vacuum row of the Sugawara fold/Fock comparison

At the first nonzero creation mode, the (8.4.16) fold and the transported Fock operator both send
`1 ⊗ ι(0)` to the conformal vector.  The equality uses orthonormality only on the Fock side, to
identify the dual basis in the inverse-Gram conformal vector with the given basis. -/

/-- info: 'MM.FLM87SV.sugawaraMode_neg_two_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.sugawaraMode_neg_two_vacuum

/-- info: 'MM.FLM87SV.fockSugawaraVL_neg_two_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.fockSugawaraVL_neg_two_vacuum

/-- info: 'MM.FLM87SV.sugawaraFoldIdentity_neg_two_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.sugawaraFoldIdentity_neg_two_vacuum

/-! ## Batch 110: the high-mode degree-zero Fock row

The high-mode comparison is not restricted to `ι(0)`: for every lattice element `a`, both
operators kill `1 ⊗ ι(a)`.  This is still a value calculation, but it tests the whole degree-zero
Fock summand rather than its vacuum vector alone. -/

/-- info: 'MM.FLM87SV.sugawaraMode_iota_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.sugawaraMode_iota_vacuum

/-- info: 'MM.FLM87SV.fockSugawaraVL_iota_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.fockSugawaraVL_iota_vacuum

/-- info: 'MM.FLM87SV.sugawaraFoldIdentity_iota_vacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.sugawaraFoldIdentity_iota_vacuum

/-! ## Batch 111: high-mode comparison on the degree-zero lattice submodule

The individual `ι(a)` calculations now extend by linearity to their span `iotaSpan`, giving the
high-mode equality on the entire Fock-degree-zero lattice submodule without choosing a group-algebra
basis. -/

/-- info: 'MM.FLM87SV.iotaSpan' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.iotaSpan

/-- info: 'MM.FLM87SV.sugawaraFoldIdentity_on_iotaSpan' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.sugawaraFoldIdentity_on_iotaSpan

/-! ## Batch 112: the complete initial mode range on the degree-zero lattice submodule

The regular (zero-mode-free) two-factor fold now has its `z^0` creation calculation on every
`ι(a)`.  It matches the transported Fock `L(-2)` there, and linearity extends it to `iotaSpan`.
Together with the high-mode row, the comparison holds on that submodule for every `n ≥ -2`. -/

/-- info: 'MM.FLM87SV.actionFold_two_zero_iota' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.actionFold_two_zero_iota

/-- info: 'MM.FLM87SV.sugawaraMode_neg_two_iota' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.sugawaraMode_neg_two_iota

/-- info: 'MM.FLM87SV.fockSugawaraVL_neg_two_iota' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.fockSugawaraVL_neg_two_iota

/-- info: 'MM.FLM87SV.sugawaraFoldIdentity_neg_two_on_iotaSpan' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.sugawaraFoldIdentity_neg_two_on_iotaSpan

/-- info: 'MM.FLM87SV.sugawaraFoldIdentity_on_iotaSpan_of_neg_two_le' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SV.sugawaraFoldIdentity_on_iotaSpan_of_neg_two_le

/-! ## Batch 113: the generic Fock normal-order side of the fold identity

The remaining target is no longer approached by more vacuum rows.  On arbitrary vectors the Fock
Sugawara operator is now expressed in the same locally finite integer-indexed normal-order language
as FLM (8.4.16), and each summand is transported explicitly.  What remains is only the fold-side
head/tail reindexing to that `finsum`. -/

/-- info: 'MM.FLM87SI.normalOrderedHeisPair_apply_finite' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SI.normalOrderedHeisPair_apply_finite

/-- info: 'MM.FLM87SI.mode_eq_conjEnd_alpha' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SI.mode_eq_conjEnd_alpha

/-- info: 'MM.FLM87SI.normalOrderedHeisPair_basis_eq_tensor_pairNO' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SI.normalOrderedHeisPair_basis_eq_tensor_pairNO

/-- info: 'MM.FLM87SI.normalOrderedHeisNO_apply_finite' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SI.normalOrderedHeisNO_apply_finite

/-- info: 'MM.FLM87SI.fockSugawaraVL_apply_eq_normalOrderedHeisFinsum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SI.fockSugawaraVL_apply_eq_normalOrderedHeisFinsum

/-! ## Batch 114: the fold *is* the normal-ordered `finsum`, and FLM (8.7.9) follows -/

-- The (8.4.16) fold at the Sugawara power is the integer-indexed normal-ordered pair sum;
-- `SugawaraFoldIdentity` is therefore a theorem, and FLM (8.7.9) follows for the landed factors.

/-- info: 'MM.FLM87FC.actionFold_eq_normalOrderedHeisFinsum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87FC.actionFold_eq_normalOrderedHeisFinsum

/-- info: 'MM.FLM87FC.conformalFold_diag_eq_normalOrderedHeisFinsum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87FC.conformalFold_diag_eq_normalOrderedHeisFinsum

/-- info: 'MM.FLM87FC.dualCoeff_eq_ite' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87FC.dualCoeff_eq_ite

/-- info: 'MM.FLM87FC.sugawaraFoldIdentity' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87FC.sugawaraFoldIdentity

/-- info: 'MM.FLM87FC.freeBosonSugawaraBracket' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87FC.freeBosonSugawaraBracket

/-- info: 'MM.FLM87ZN.modeZ' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZN.modeZ

/-- info: 'MM.FLM87ZN.normalOrderedHeisPairZero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZN.normalOrderedHeisPairZero

/-- info: 'MM.FLM87ZN.actionFoldZero_eq_normalOrderedHeisFinsumZero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZN.actionFoldZero_eq_normalOrderedHeisFinsumZero

/-- info: 'MM.FLM87ZN.conformalFoldZero_diag_eq_finsumZero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZN.conformalFoldZero_diag_eq_finsumZero

/-- info: 'MM.FLM87ZD.zeroPart' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZD.zeroPart

/-- info: 'MM.FLM87ZD.zeroPart_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZD.zeroPart_zero

/-- info: 'MM.FLM87ZD.zeroPart_of_ne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZD.zeroPart_of_ne

/-- info: 'MM.FLM87ZD.pairZero_diff_finsum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZD.pairZero_diff_finsum

/-- info: 'MM.FLM87ZD.sugawaraModeZero_diag' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZD.sugawaraModeZero_diag

/-- info: 'MM.FLM87ZD.sugawaraModeZero_eq_fockSugawaraVL_add_zeroPart' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZD.sugawaraModeZero_eq_fockSugawaraVL_add_zeroPart

/-! ## Batch 116/117: FLM (8.7.9) for the (7.1.33) zero-mode-corrected Sugawara modes

The branch that closes FLM (8.7.9) at `c = dim 𝔥` for FLM's own `L(n)`.  Three batches, and the
guards below are the load-bearing ones:

* batch 116 (`MM.FLM87ZBK`) -- the two cross terms of the assembly, under the orthonormal basis the
  whole branch runs in, and the landed refutation of the *first* interface, whose object was a
  degenerate operator-level `finsum`;
* batch 117 (`MM.FLM87ZDG`, `MM.FLM87ZDGC`) -- the decomposition is additive only under an
  orthonormal basis, and that hypothesis is **not removable**: the hOrth-free statement is
  machine-checked false (`MM.FLM87ZDGC.not_generalSugawaraDecomposition`);
* batch 117 (`MM.FLM87ZBF`) -- the assembly, i.e. the paper's target
  `FreeBosonSugawaraBracketZero` at `c = card κ = dim 𝔥`.

Read the module docstrings before citing any of these: the surviving hypothesis is
`MM.FLM87ST.OrthonormalBasis bL form`, which is FLM (8.7.3)'s own standing assumption, not a gap. -/

/-- info: 'MM.FLM87ZBK.zeroPart_comm_orthonormal' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZBK.zeroPart_comm_orthonormal

/-- info: 'MM.FLM87ZBK.fockSugawaraVL_comm_zeroPart' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZBK.fockSugawaraVL_comm_zeroPart

/-- info: 'MM.FLM87ZBA2.not_fockSugawaraVLZeroBracket_int' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZBA2.not_fockSugawaraVLZeroBracket_int

/-- info: 'MM.FLM87ZDGC.not_generalSugawaraDecomposition' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZDGC.not_generalSugawaraDecomposition

/-- info: 'MM.FLM87ZDG.sugawaraModeZero_apply_eq_regular_add_zeroCorr' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZDG.sugawaraModeZero_apply_eq_regular_add_zeroCorr

/-- info: 'MM.FLM87ZBF.fockSugawaraVLZero_bracket_of_orth' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZBF.fockSugawaraVLZero_bracket_of_orth

/-- info: 'MM.FLM87ZBF.sugawaraModeZero_eq_fockSugawaraVLZero_of_orth' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZBF.sugawaraModeZero_eq_fockSugawaraVLZero_of_orth

/-- info: 'MM.FLM87ZBF.freeBosonSugawaraBracketZero_of_orth' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87ZBF.freeBosonSugawaraBracketZero_of_orth

/-! ## Batch 118: the general-basis boundary of the Sugawara branch, the 8.6 spine map, and the Jacobi certificate

* `MM.FLM87SG.sugawaraCollapse_iff_orthonormal` is the batch's headline **finding**, and it closes the
  question batch 117 opened: the honest general-basis collapse (symmetry of the form plus the
  inverse-Gram contraction of the regular pairs) is **equivalent** to FLM (8.7.3)'s orthonormal-basis
  hypothesis.  So `freeBosonSugawaraBracketZero_of_orth` is a reduction to a *necessary* hypothesis,
  and the general-basis (8.7.9) needs the bracket computation redone, not a rearrangement.
* `MM.FLM86SG` carries the compiled map of (8.6.3)--(8.6.27) and the source-faithful statement of
  Theorem 8.6.1 with its reductions; the two `...Statement` declarations are `def ... : Prop`, i.e.
  named and **not** asserted.
* `MM.FLM810SJ.scalarModel_certificate` is the one-model certificate for the faithful Jacobi axiom:
  satisfiability, strictness over the W6 uniform window, and non-degeneracy in a single model.  Its
  `[CharZero F]` is not removable (the ledger's earlier spelling without it is false in
  characteristic `p`). -/

/-- info: 'MM.FLM87SG.sugawaraCollapse_iff_orthonormal' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SG.sugawaraCollapse_iff_orthonormal

/-- info: 'MM.FLM87SG.freeBosonSugawaraBracketZero_of_collapse' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SG.freeBosonSugawaraBracketZero_of_collapse

/-- info: 'MM.FLM86SG.theorem861Source_of_coeffFamily_and_spanning' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SG.theorem861Source_of_coeffFamily_and_spanning

/-- info: 'MM.FLM86SG.sourceResidue861_eq_unshifted' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SG.sourceResidue861_eq_unshifted

/-- info: 'MM.FLM810SJ.crossBracket_eq_crossIterate_scalarModel' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810SJ.crossBracket_eq_crossIterate_scalarModel

/-- info: 'MM.FLM810SJ.scalarModel_faithfulJacobi' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810SJ.scalarModel_faithfulJacobi

/-- info: 'MM.FLM810SJ.scalarModel_certificate' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810SJ.scalarModel_certificate

/-! ## Batch 119: FLM (8.6.5), the k-fold normal-ordered product, and the shifted field

The three objects §8.6's proof chain needed before (8.6.6)--(8.6.12) can be stated.

* `MM.FLM86MS` -- the multi-variable series of states `A`, `B` of (8.6.5), carried as a coefficient
  function `MultiIdx k -> V_L` (NOT `MvPowerSeries`: `V_L` is only an `F`-module).  The `k = 1`
  identification with the landed `state865` and the block multiplicativity are unconditional.
* `MM.FLM86KF` -- the `k`-fold normal-ordered product, with `k = 2` equal to the landed
  `MM.FLM84.normalPair`; and the first equality of (8.6.6), exponential form = normal-ordered form,
  proved for every `k` with the source's own (8.6.4) constraint as the only hypothesis.  (8.6.8) is
  thereby closed.  The ordinary-product family is the named gap `Display866Family3`.
* `MM.FLM86SF` -- the shifted field `Y(a, z+w)` as the binomial re-expansion, with `Y(a,z+0)=Y(a,z)`,
  the composition law, the `w^1`-coefficient identified with the landed `MM.FLM84.deriv`, and the
  scalar cancellation `renorm869` of (8.6.9)'s renormalisation factors.  (8.6.10) for `k >= 2` is
  proved from (8.4.20) + (8.4.25); the `k = 1` case is the named gap `Display8610One`, reduced to the
  landed (8.5.12) `MM.FLM85Ext.iterateStatement`. -/

/-- info: 'MM.FLM86MS.multiSeries_ext' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MS.multiSeries_ext

/-- info: 'MM.FLM86MS.multiStateIdx_one_eq_state865' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MS.multiStateIdx_one_eq_state865

/-- info: 'MM.FLM86MS.multiStateIdx_zero_exp' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MS.multiStateIdx_zero_exp

/-- info: 'MM.FLM86KF.kFoldNormalOrder_two' depends on axioms: [propext, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86KF.kFoldNormalOrder_two

/-- info: 'MM.FLM86KF.kFoldNormalOrder_eq_prod864_mul_multiExpIdx' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86KF.kFoldNormalOrder_eq_prod864_mul_multiExpIdx

/-- info: 'MM.FLM86KF.display866868_expForm_eq_normForm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86KF.display866868_expForm_eq_normForm

/-- info: 'MM.FLM86SF.shiftCoef_shiftCoef' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SF.shiftCoef_shiftCoef

/-- info: 'MM.FLM86SF.renorm869' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SF.renorm869

/-- info: 'MM.FLM86SF.display8610List_of_vacuum_and_step' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SF.display8610List_of_vacuum_and_step

/-! ## Batch 120: the operator-level field, the diagonal filter, and the convolution product

* `MM.FLM84OF.operatorLevelStatement_opOpenBox` is **unconditional**: the reduced operator-level
  problem of batch 118 is discharged, and `existsUnique_recursion_solution` shows its solution is
  unique.  The batch also measured that this does **not** close the four named gaps: the flat product
  sets the `Y(a,z)alpha(z)^+` summand of (8.4.19) to zero, the honest tail is provably nonzero
  (`exists_tailWindow_ne_zero`), and the honest windowed equation is provably *not* satisfied by that
  field (`not_deriv_fieldFamily_eq_opOpenBoxWindow`) while it does hold on the vacuum.
* `MM.FLM85NS.diagFilter` is the (8.5.5) diagonal filter, with cutoff independence, finite support on
  the antidiagonal, and the identification of the landed (8.5.5) recursion with it.
* `MM.FLM85CP.conv` is the (8.5.15) convolution product in one variable, with all four ring laws
  proved on the locally finite families; the finiteness needed is the two-sided
  `LocallyFiniteCoef`, derived from the landed `FLM85It.LocallyFinite` + `LandsInEndZ` (the landed
  (8.10.5) alone is one-sided and does not suffice). -/

/-- info: 'MM.FLM84OF.operatorLevelStatement_opOpenBox' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84OF.operatorLevelStatement_opOpenBox

/-- info: 'MM.FLM84OF.existsUnique_recursion_solution' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84OF.existsUnique_recursion_solution

/-- info: 'MM.FLM84OF.not_deriv_fieldFamily_eq_opOpenBoxWindow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84OF.not_deriv_fieldFamily_eq_opOpenBoxWindow

/-- info: 'MM.FLM85NS.diagFilter_support_finite' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85NS.diagFilter_support_finite

/-- info: 'MM.FLM85NS.normalOrderedProduct_eq_foldr_diagStep' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85NS.normalOrderedProduct_eq_foldr_diagStep

/-- info: 'MM.FLM85CP.conv_assoc' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85CP.conv_assoc

/-- info: 'MM.FLM85CP.conv_vacuumField_vacuumField_apply_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85CP.conv_vacuumField_vacuumField_apply_one

/-! ## Batch 121: the state interface, the vacuum field on V_L, and the honest (8.4.36) with the deficit

* `MM.FLM85SI.LatticeDatum` attaches to a `FiveDatum` the lattice element of each factor and of the
  base, which is what made batch 120's measured obstruction (the named gap was not statable on `V_L`)
  into a statement about landed objects.  The reordering case is unconditional, the basis-labelled
  case is proved, and the general case is reduced to the named `LabelsDeterminedByNonzeroState`.
* `MM.FLM84VF` discharges `VacuumFieldAt`: FLM (8.5.3)/(8.5.18) is landed on `V_L` at the coefficient
  level (`vacuumLabel_component_family`), and the (8.6.10) chain now holds with `hvac` discharged --
  what is left of (8.6.10) for every `k` is exactly `IterateProductStep`.
* `MM.FLM84AP` removes the support hypothesis of the landed operator-level (8.4.36) (that hypothesis is
  exactly `expFamily X 1 = X`, i.e. it says the flat carrier's exponential is the creation half's),
  and computes the deficit `annihPair` exactly on `V_L`: it is central and vanishes identically when
  `form a b = 0` -- proved on ALL of `V_L`, not on a subspace.  The pairing-nonzero case is the single
  named residual `PairingProductFormResidual`, whose `p = 0` instance is proved. -/

/-- info: 'MM.FLM85SI.LatticeDatum.normalOrderedProduct_eq_of_stateOf_eq_ofBasisWord' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85SI.LatticeDatum.normalOrderedProduct_eq_of_stateOf_eq_ofBasisWord

/-- info: 'MM.FLM84VF.vacuumLabel_component_family' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84VF.vacuumLabel_component_family

/-- info: 'MM.FLM84VF.display8610List_conv_of_prescription_modelBase' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84VF.display8610List_conv_of_prescription_modelBase

/-- info: 'MM.FLM84AP.honestLevel8436_of' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84AP.honestLevel8436_of

/-- info: 'MM.FLM84AP.annihPair_oscField_latticeField_eq_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84AP.annihPair_oscField_latticeField_eq_zero

/-- info: 'MM.FLM84AP.ordField_oscField_latticeField_eq_openBoxField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84AP.ordField_oscField_latticeField_eq_openBoxField

/-! ## Batch 122: the last hypothesis of (8.6.10) is smaller, and two batch-121 residuals are FALSE

* `MM.FLM85LD.normalOrderedWellDefinedOnVL` is **unconditional** -- (8.5.6) as a function of the state
  is now a theorem, and batch 121's residual `LabelsDeterminedByNonzeroState` is **refuted**
  (`not_labelsDeterminedByNonzeroState`: two data with equal nonzero states and non-permutation labels
  at the rank-one probe).  The repair is `FockWordDeterminesFold`, which is strictly weaker and proved
  in full generality.
* `MM.FLM84EF` pins the expansion family (`diagA 0 = deltaInt`, `diagA 1 = deltaInt - shiftOne`,
  `diagA (-1) j = 1`) and **refutes** batch 121's `PairingProductFormResidual` at `p = +-1`
  (`not_pairingProductFormResidual_rankOne_one`, `..._neg_one`).  The defect is the residual's *first
  field*: (8.4.22)/(8.4.25) are about the lattice field `Y(a,z)` of (8.4.17), whereas the landed
  `oscField a` is the Heisenberg field of (8.4.7)/(8.4.10).
* `MM.FLM85IS` proves the `j = 0` level of `IterateProductStep` at the vacuum
  (`iterateProductStepLevelAt_zero_vacuum_componentField`) and shows that the vacuum instance is
  *exactly* the landed (8.5.12) at `b = iota(1)`, with the residual
  `IterateProductStepResidual` left as a `def`; the hypothesis is consistent and non-vacuous
  (`iterateProductStep_spanVacuum_conv`, `exists_iterateProductStep_conv`). -/

/-- info: 'MM.FLM85LD.normalOrderedWellDefinedOnVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85LD.normalOrderedWellDefinedOnVL

/-- info: 'MM.FLM85LD.not_labelsDeterminedByNonzeroState' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85LD.not_labelsDeterminedByNonzeroState

/-- info: 'MM.FLM84EF.diagA_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84EF.diagA_zero

/-- info: 'MM.FLM84EF.not_pairingProductFormResidual_rankOne_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84EF.not_pairingProductFormResidual_rankOne_one

/-- info: 'MM.FLM85IS.iterateProductStepLevelAt_zero_vacuum_componentField' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85IS.iterateProductStepLevelAt_zero_vacuum_componentField

/-- info: 'MM.FLM85IS.iterateProductStep_spanVacuum_conv' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85IS.iterateProductStep_spanVacuum_conv

/-! ## Batch 123: the (8.4.20) object, the contraction, and the iterate step re-scoped

* `MM.FLM84DC.dblColon` is the (8.4.20) normal-ordered product ACROSS two lattice fields, with its
  (8.4.17) values, its (8.4.19) bridge and a non-degeneracy witness at the rank-one datum.  Measured:
  on this carrier the ordinary product collapses to it, so the windowed law (`ProductLaw`) is true at
  `p = 0` and **false at `p = 1`** (`not_productLaw_rankEl_one`) -- a wider window cannot repair it.
* `MM.FLM84CT.annihPair_oscField_latticeField` is the (8.4.19) deficit computed exactly:
  `[a-bar(z1)^+, Y(b,z2)]` is a SCALAR times the shifted field, with the honest guard `m < -1` in the
  landed `splitPlus` vocabulary (the zero mode is not part of `modeVL` here; `fullPlus` restores the
  uniform `m < 0` form, and the unguarded statement is refuted).
* `MM.FLM85IC` proves the created-state step is **equivalent** to (8.6.10) itself given `hvac`, not a
  strictly weaker residual, and refutes its lowest non-vacuum level.  So the remaining target is
  (8.4.25) for the concrete normal-ordered product -- nothing weaker exists. -/

/-- info: 'MM.FLM84DC.dblColon' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84DC.dblColon

/-- info: 'MM.FLM84DC.not_productLaw_rankEl_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84DC.not_productLaw_rankEl_one

/-- info: 'MM.FLM84DC.dblColon_rankElOne_one_zero_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84DC.dblColon_rankElOne_one_zero_ne_zero

/-- info: 'MM.FLM84CT.annihPair_oscField_latticeField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84CT.annihPair_oscField_latticeField

/-- info: 'MM.FLM84CT.fullPlus_contraction' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84CT.fullPlus_contraction

/-- info: 'MM.FLM85IC.createdStepResidual_iff_display8610List' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85IC.createdStepResidual_iff_display8610List

/-- info: 'MM.FLM85IC.exists_vacuumFieldAt_unit_iterateStatement_not_createdStepResidual' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85IC.exists_vacuumFieldAt_unit_iterateStatement_not_createdStepResidual

/-! ## Batch 124: the completed carrier with E^+ represented, the delta contraction, and conv additivity

* `MM.FLM84CM` builds the Fock-degree completion `Vhat_L` of `V_L`, defines the annihilation half
  `E^+(z)` of (8.4.17) IN `w = z^{-1}` so the landed coefficientwise exponential applies, and PROVES
  its local nilpotence (`annihExp_kills`); the coefficientwise completed product is window-independent
  and bounded-degree, and the landed vacuum-sector creation exponential is its restriction.  Measured
  limits, both recorded in the file: `Classical.choose`-derived bounds in a *statement* make
  elaboration diverge (10^6 heartbeats, not a marginal cost), so the action carries its window as data;
  and `E^-` raises the Fock degree without bound, so `Y(a,z)` is not a completed field in this
  presentation and (8.4.25) is still not stated.
* `MM.FLM84DCT.fullPlus_contraction_gen` is the contraction as a GENERATING FUNCTION,
  `[a-bar(z1)^+, Y(b,z2)] = <a,b> z2^{-1} delta(z1/z2) Y(b,z2)`, with the dictionary to the landed
  coefficientwise form and to `MM.FLM84Y.z2InvDeltaFamily`/`expansionA(-1) - expansionB(-1)`; the
  expansion convention is forced by (8.5.6) (`deltaMul_eq_expansionA_smul`).
* `MM.FLM85CA.conv_add_right` and friends: `conv` is now additive and homogeneous in each argument on
  the locally finite families, and the hypotheses are provably not removable
  (`not_conv_add_right_unconditional`).  With the created states proved to span `V_L`
  (`createdStateSpan_eq_top`), the display (8.6.10) is EQUIVALENT to the one-step (8.4.25) at every
  state (`display8610List_iff_iterateProductStep_conv`). -/

/-- info: 'MM.FLM84CM.annihExp_kills' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84CM.annihExp_kills

/-- info: 'MM.FLM84CM.actOn_ofVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84CM.actOn_ofVL

/-- info: 'MM.FLM84CM.rankOne_actOn_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84CM.rankOne_actOn_ne_zero

/-- info: 'MM.FLM84DCT.fullPlus_contraction_gen' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84DCT.fullPlus_contraction_gen

/-- info: 'MM.FLM84DCT.deltaMul_eq_expansionA_smul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84DCT.deltaMul_eq_expansionA_smul

/-- info: 'MM.FLM85CA.conv_add_right' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85CA.conv_add_right

/-- info: 'MM.FLM85CA.not_conv_add_right_unconditional' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85CA.not_conv_add_right_unconditional

/-- info: 'MM.FLM85CA.createdStateSpan_eq_top' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85CA.createdStateSpan_eq_top

/-- info: 'MM.FLM85CA.display8610List_iff_iterateProductStep_conv' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85CA.display8610List_iff_iterateProductStep_conv

/-! ## Batch 125: the assembled lattice field, the ratio window, and the contraction's honest guard

* `MM.FLM84LF.YFam` is FLM (8.4.17) assembled in the landed convolution carrier:
  `Y(a,z) = (E^- * (a z^{a(0)})) * E^+`, with the middle factor `midFam` packaged as one family.  The
  acceptance test is met -- on a lattice generator it IS the landed (8.5.11) state (`YFam_iotaVL`) and
  on the vacuum it reproduces the landed `YCoeff` -- and (8.10.5)-above holds.  The one named residual
  is `ActsOnCompletion` (the two `CField` conditions), whose lower half needs the open
  `LatticeWeightDecomposition`; batch 124's claim that `E^-` raises the degree WITHOUT BOUND was
  prose, and only its quantitative form is now landed (`creationExpVL_raises`).
* `MM.FLM84RW` builds the ratio window `E^+_a(z1) E^-_b(z2)` with its finiteness PROVED twice (support
  window; effective window with at most `N+1` terms on Fock degree `<= N`), lands the `form a b = 0`
  case of the identity, and pins the EXPONENT: the source prints the POSITIVE exponent
  (`(1 - z2/z1)^{<a,b>}`), and the brief's negative exponent is refuted (`annihIdx_one_mul_..._add`).
* `MM.FLM84CN` proves the landed contraction's `m < -1` guard is necessary in the SHARP form:
  the unguarded identity holds IFF `form a b = 0` (`annihPair_oscField_eq_unguarded_iff`), so batch
  124's "the unguarded form is false" was true only under `form a b != 0`. -/

/-- info: 'MM.FLM84LF.YFam_iotaVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84LF.YFam_iotaVL

/-- info: 'MM.FLM84LF.YFam_vacuumVL_eq_YCoeff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84LF.YFam_vacuumVL_eq_YCoeff

/-- info: 'MM.FLM84LF.rankOne_YFam_neg_two_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84LF.rankOne_YFam_neg_two_ne_zero

/-- info: 'MM.FLM84RW.effectiveWindow_card_le' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84RW.effectiveWindow_card_le

/-- info: 'MM.FLM84RW.ratioProd_iotaVL_eq_YCoeff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84RW.ratioProd_iotaVL_eq_YCoeff

/-- info: 'MM.FLM84RW.annihIdx_one_mul_creationExpVL_one_add' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84RW.annihIdx_one_mul_creationExpVL_one_add

/-- info: 'MM.FLM84CN.annihPair_oscField_eq_unguarded_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84CN.annihPair_oscField_eq_unguarded_iff

/-- info: 'MM.FLM84CN.fullPlus_sub_annihPair_oscField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84CN.fullPlus_sub_annihPair_oscField

/-! ## Batch 126: the weight decomposition is proved, the Fock sharpness lands (and refutes a residual), and the ratio window identity closes

* `MM.FLMLWD.latticeWeightDecomposition` — FLM (7.1.40)'s **spanning** half, the statement recorded
  as open at `MMFLMLatticeModule.lean:881`, is now a theorem, unconditional in `form`.  The same batch
  measured that it was never the blocker the ledger claimed: it is a spanning statement, it is never
  consumed as a hypothesis anywhere, and the sharpness the 8.6 chain needed came from a different
  route.
* `MM.FLM85FS.creationExpVL_ne_zero` — `creationExpVL a n (iotaVL c) != 0` for ALL `n >= 0` with the
  honest hypothesis `a != 0` (not removable: `a = 0` is a compiled counterexample), proved by the
  explicit top-monomial computation `evalVL_creationExpVL_eq` (`1/k!` identified) with NO use of the
  weight decomposition.  And `MM.FLM85FS.not_actsOnCompletion` **refutes** batch 125's named residual:
  `YFam` is not a `CField`, so the completed action of batch 124 does not receive it.  The remaining
  named gap is `FockFiltrationStrict` (strictness of the filtration).
* `MM.FLM84RWC.ratioWindowIdentity` — the two-factor identity of batch 125 is a THEOREM now (under the
  standing symmetry hypothesis), with the general triangular reindexing lemma landed and a second
  non-vacuity coefficient verified. -/

/-- info: 'MM.FLMLWD.latticeWeightDecomposition' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMLWD.latticeWeightDecomposition

/-- info: 'MM.FLM85FS.creationExpVL_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85FS.creationExpVL_ne_zero

/-- info: 'MM.FLM85FS.evalVL_creationExpVL_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85FS.evalVL_creationExpVL_eq

/-- info: 'MM.FLM85FS.not_actsOnCompletion' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85FS.not_actsOnCompletion

/-- info: 'MM.FLM84RWC.ratioWindowIdentity' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84RWC.ratioWindowIdentity

/-- info: 'MM.FLM84RWC.sum_range_sum_range_smul_eq_sum_range_sum_smul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84RWC.sum_range_sum_range_smul_eq_sum_range_sum_smul

/-! ## Batch 127: the filtration is strict, the independence half lands, and `FockDimensionIdentity` is FALSE

* `MM.FLM85FT.fockFiltrationStrict_of_ne_zero` — batch 126's last named gap is **proved**, with the
  honest hypothesis `a != 0`, and the sharp form `fockFiltrationStrict_iff_ne_zero` shows the
  hypothesis is exactly right (`a = 0` is a compiled exception).  The route is the degree-graded
  extraction functional `M(1) -> F[X]`, which records the degree in the exponent of `X`.  As a
  by-product the second `CField` field `bdd` is **refuted** for `YFam`
  (`not_bdd_YFam_of_ne_zero`), so both halves of `ActsOnCompletion` now fail.
* `MM.FLMFI.gradedPiece_disjoint` and `MM.FLMFI.weightPiece_disjoint` — the INDEPENDENCE half of
  FLM (7.1.40) is landed, unconditionally (no `CharZero F`, no `Module.Free Z L`, no hypothesis on
  `form`), by basis bookkeeping.  And `MM.FLMFock.FockDimensionIdentity` — recorded as the residual of
  that layer — is **FALSE as stated** (its `kappa` is never tied to a basis of `L`).
* `MM.FLMRepair` repairs the batch-126 naming defects with PROVED re-statements, and records two
  further findings: the left zero law of `conv` is **unconditional** (the batch-126 claim that it
  cannot be is false, and the same holds for `conv_add_left`, `conv_smul_left`, `conv_smul_right` --
  only `conv_add_right` and the left unit law genuinely need hypotheses), and FLM (7.1.40) is printed
  as a DIRECT SUM, so the missing half is `iSupIndep`, strictly stronger than pairwise disjointness. -/

/-- info: 'MM.FLM85FT.fockFiltrationStrict_iff_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85FT.fockFiltrationStrict_iff_ne_zero

/-- info: 'MM.FLM85FT.not_bdd_YFam_of_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85FT.not_bdd_YFam_of_ne_zero

/-- info: 'MM.FLM85FT.derivOf_map_fockLe_succ' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85FT.derivOf_map_fockLe_succ

/-- info: 'MM.FLMFI.gradedPiece_disjoint' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMFI.gradedPiece_disjoint

/-- info: 'MM.FLMFI.weightPiece_disjoint' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMFI.weightPiece_disjoint

/-- info: 'MM.FLMRepair.latticeWeightSpanning' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMRepair.latticeWeightSpanning

/-- info: 'MM.FLMRepair.conv_zero_left_unconditional' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMRepair.conv_zero_left_unconditional

/-- info: 'MM.FLMRepair.not_YFamTwoSidedWindow_of_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMRepair.not_YFamTwoSidedWindow_of_ne_zero

/-! ## Batch 128: the two-variable carrier, the step's linearity, and the (7.1.40) direct sum

* `MM.FLM84TV` carries the two-variable product `Y(a,z1)Y(b,z2)` as `Z -> Z -> End_F V_L` with
  ordinary exponents (in two variables a coefficient is a single composition, so NO finiteness
  hypothesis is needed -- unlike the one-variable `conv`, which batch 127 refuted for `YFam`).  The
  vacuum identification holds in the honest form, and the (8.4.21) COCYCLE half is landed with no
  hypothesis on the form.
* `MM.FLM85SL` lands the honest form of the step's linearity (the step-predicate is a SUBMODULE of the
  states under additivity and homogeneity of the product in its second argument), the single-state
  consumer, and the cleaner display consumer `display8610List_conv_of_createdStep`, whose hypotheses
  are just the vacuum field and the step at the created states.
* `MM.FLMLDS.weightPiece_iSupIndep` -- the DIRECT SUM form of FLM (7.1.40), with `weightPiece_isInternal`
  and the coordinate identities.  And the negative result: pairwise disjointness CANNOT give it
  (`line_pairwise` + `line_not_iSupIndep`: three lines in Q^2 are pairwise disjoint but not
  independent, since `iSupIndep_iff_pairwiseDisjoint` needs an `Order.Frame` and `Submodule` is not
  one), so batch 127's pairwise statement was strictly weaker. -/

/-- info: 'MM.FLM84TV.twoVarField_apply' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84TV.twoVarField_apply

/-- info: 'MM.FLM84TV.midBlock2_swap' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84TV.midBlock2_swap

/-- info: 'MM.FLM84TV.creationHalf2_swap' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84TV.creationHalf2_swap

/-- info: 'MM.FLM84TV.rankOne_twoVarField_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84TV.rankOne_twoVarField_ne_zero

/-- info: 'MM.FLM85SL.display8610List_conv_of_createdStep' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85SL.display8610List_conv_of_createdStep

/-- info: 'MM.FLM85SL.iterateProductStepAt_add' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85SL.iterateProductStepAt_add

/-- info: 'MM.FLM85SL.exists_field_not_determining_step' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85SL.exists_field_not_determining_step

/-- info: 'MM.FLMLDS.weightPiece_iSupIndep' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMLDS.weightPiece_iSupIndep

/-- info: 'MM.FLMLDS.weightPiece_isInternal' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMLDS.weightPiece_isInternal

/-- info: 'MM.FLMLDS.line_not_iSupIndep' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMLDS.line_not_iSupIndep

/-- info: 'MM.FLM86TN.normOrdered2_swap' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TN.normOrdered2_swap

/-- info: 'MM.FLM86TN.annihExp_comm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TN.annihExp_comm

/-- info: 'MM.FLM86TN.productLaw2Zero_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TN.productLaw2Zero_iff

/-- info: 'MM.FLM86TN.convWith2_delta2Two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TN.convWith2_delta2Two

/-- info: 'MM.FLM86EX.locallyFinite2_convWith2' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86EX.locallyFinite2_convWith2

/-- info: 'MM.FLM86EX.normOrdered2_witnesses' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86EX.normOrdered2_witnesses

/-- info: 'MM.FLM86EX.not_extraction8612_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86EX.not_extraction8612_zero

/-- info: 'MM.FLM86EX.extraction8612_of_pairing' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86EX.extraction8612_of_pairing

/-- info: 'MM.FLM86EX.extraction8612_proof_irrel' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86EX.extraction8612_proof_irrel

/-! ### (8.6.6) at `k = 2`: the pairing factor is a wedge, not an extraction kernel

`Definitions/MMFLM86OrdTwo.lean` classifies scalar two-variable families as `LocallyFinite2` iff
finitely supported, and uses that to prove the *negative* result that the binomial expansion
`expansionA (−N−1)` of the pairing factor `(z₁ − z₂)^{−N−1}` is **not** an admissible convolution
factor.  So batch 130's `Extraction8612` cannot be instantiated at the binomial family; the positive
half is the wedge law `pairingScalarTwoVar_conv_eq`. -/

/-- info: 'MM.FLM86OT.locallyFinite2_scalar_iff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OT.locallyFinite2_scalar_iff

/-- info: 'MM.FLM86OT.not_locallyFinite2_scalar_of_not_finite' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OT.not_locallyFinite2_scalar_of_not_finite

/-- info: 'MM.FLM86OT.locallyFinite2_scalar_single' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OT.locallyFinite2_scalar_single

/-- info: 'MM.FLM86OT.pairingScalarTwo_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OT.pairingScalarTwo_eq

/-- info: 'MM.FLM86OT.locallyFinite2_pairingScalarTwoVar' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OT.locallyFinite2_pairingScalarTwoVar

/-- info: 'MM.FLM86OT.pairingScalarTwoVar_eq_smul_delta2Two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OT.pairingScalarTwoVar_eq_smul_delta2Two

/-- info: 'MM.FLM86OT.pack_first' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OT.pack_first

/-- info: 'MM.FLM86OT.expansionA_neg_coeff' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OT.expansionA_neg_coeff

/-- info: 'MM.FLM86OT.not_locallyFinite2_expansionA_neg' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OT.not_locallyFinite2_expansionA_neg

/-- info: 'MM.FLM86OT.family3Two_of_residual' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OT.family3Two_of_residual

/-- info: 'MM.FLM86OT.family3Two_of_finite_extraction' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OT.family3Two_of_finite_extraction

/-- info: 'MM.FLM86OT.pairingScalarTwoVar_conv_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OT.pairingScalarTwoVar_conv_eq

/-! ### The mixed pair `E⁺_a(z₁)E⁻_b(z₂)`, and the single residual for `LocallyFinite2 ∘ normOrdered2`

`Definitions/MMFLM86MixedPair.lean` resolves the mixed pair in a finite window (FLM (8.4.19)/(8.4.22))
and isolates the *degree obstruction* that keeps `LocallyFinite2 (normOrdered2 …)` open: there is an
in-chain killing theorem for `E⁺` (`annihExp_kills`) and none for `E⁻`, because `E⁻` *raises* the Fock
degree.  The named residual is `MixedPairWindow`, and the file proves it implies the target with no
further input. -/

/-- info: 'MM.FLM86MP.mixedPairCA_eq_window_of_subset' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MP.mixedPairCA_eq_window_of_subset

/-- info: 'MM.FLM86MP.mixedPairCA_eq_mixedPairAC_of_form_eq_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MP.mixedPairCA_eq_mixedPairAC_of_form_eq_zero

/-- info: 'MM.FLM86MP.creationPair2_zero_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MP.creationPair2_zero_zero

/-- info: 'MM.FLM86MP.rankOne_creationExpVL_one_iotaVL_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MP.rankOne_creationExpVL_one_iotaVL_ne_zero

/-- info: 'MM.FLM86MP.creationPair2_one_zero_iotaVL_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MP.creationPair2_one_zero_iotaVL_ne_zero

/-- info: 'MM.FLM86MP.not_locallyFinite2_creationPair2_of_unbounded' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MP.not_locallyFinite2_creationPair2_of_unbounded

/-- info: 'MM.FLM86MP.locallyFinite2_pair_of_finite_outer' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MP.locallyFinite2_pair_of_finite_outer

/-- info: 'MM.FLM86MP.locallyFinite2_normOrdered2_of_mixedPairWindow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MP.locallyFinite2_normOrdered2_of_mixedPairWindow

/-! ### The degree-filtration route, and its refutation

`Definitions/MMFLM86Slice.lean` attacks `MixedPairWindow` by Fock-degree slicing.  The positive part:
sliding index windows are *unconditionally* locally finite (`locallyFinite2_sliceTwo`), and slice
stabilization is *equivalent* to `LocallyFinite2` (`locallyFinite2_iff_sliceStable`), so slicing is
not a weakening.  The negative part, which is the batch's main finding: the degree route is
**refuted** on the chain's own object — under `MixedPairUnboundedCreation` the creation pair is *not*
degree-bounded (`not_degreeBounded2_creationPair2_of_unbounded`) even though every one of its slices
is locally finite (`sliceTwo_locallyFinite_but_creationPair2_not`), because `E⁻` *raises* Fock degree
by its own index (`modeVL_raises`) and `fockLeVL` cannot bound the raising side. -/

/-- info: 'MM.FLM86SL.locallyFinite2_sliceTwo' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SL.locallyFinite2_sliceTwo

/-- info: 'MM.FLM86SL.sliceTwo_apply_of_le' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SL.sliceTwo_apply_of_le

/-- info: 'MM.FLM86SL.locallyFinite2_iff_sliceStable' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SL.locallyFinite2_iff_sliceStable

/-- info: 'MM.FLM86SL.exists_sliceTwo_stabilizes' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SL.exists_sliceTwo_stabilizes

/-- info: 'MM.FLM86SL.locallyFinite2_of_degreeBounded' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SL.locallyFinite2_of_degreeBounded

/-- info: 'MM.FLM86SL.mixedPairWindow_of_degreeWindow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SL.mixedPairWindow_of_degreeWindow

/-- info: 'MM.FLM86SL.locallyFinite2_normOrdered2_of_degreeWindow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SL.locallyFinite2_normOrdered2_of_degreeWindow

/-- info: 'MM.FLM86SL.mixedPairWindow_iff_sliceStable' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SL.mixedPairWindow_iff_sliceStable

/-- info: 'MM.FLM86SL.not_degreeBounded2_pointTwo' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SL.not_degreeBounded2_pointTwo

/-- info: 'MM.FLM86SL.not_degreeBounded2_creationPair2_of_unbounded' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SL.not_degreeBounded2_creationPair2_of_unbounded

/-- info: 'MM.FLM86SL.sliceTwo_locallyFinite_but_creationPair2_not' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SL.sliceTwo_locallyFinite_but_creationPair2_not

/-- info: 'MM.FLM86SL.locallyFinite2_midBlock2_of_degreeWindow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86SL.locallyFinite2_midBlock2_of_degreeWindow

/-! ### The diagonal-window route (batch 132): the block's diagonal collapse, and the pair-fibre reformulation

`Definitions/MMFLM86WindowDirect.lean` builds the window of `MixedPairWindow` **by hand** from the
block's own diagonal fibres (`convWith2_iotaVL`, `convWith2_diagonalSum`), reduces the target to the
single hypothesis `PairFibreWindowed`, and then proves the route is a **reformulation, not a reduction**:
`not_pairFibreWindowed_of_unbounded` refutes the hypothesis at the chain's own rank-one datum
(conditional on `MixedPairUnboundedCreation`).  The gap is exactly one arithmetic statement: the
creation exponential's index support inside the block's window. -/

/-- info: 'MM.FLM86WD.convWith2_iotaVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86WD.convWith2_iotaVL

/-- info: 'MM.FLM86WD.convWith2_diagonalSum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86WD.convWith2_diagonalSum

/-- info: 'MM.FLM86WD.pairFibre_of_locallyFinite' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86WD.pairFibre_of_locallyFinite

/-- info: 'MM.FLM86WD.handWindow_spec' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86WD.handWindow_spec

/-- info: 'MM.FLM86WD.locallyFinite2_innerConvolution_of_pairFibreWindowed' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86WD.locallyFinite2_innerConvolution_of_pairFibreWindowed

/-- info: 'MM.FLM86WD.locallyFinite2_normOrdered2_of_pairFibreWindowed' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86WD.locallyFinite2_normOrdered2_of_pairFibreWindowed

/-- info: 'MM.FLM86WD.mixedPairWindow_of_pairFibreWindowed' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86WD.mixedPairWindow_of_pairFibreWindowed

/-- info: 'MM.FLM86WD.mixedPairWindow_of_pairFibreWindowed_verdict' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86WD.mixedPairWindow_of_pairFibreWindowed_verdict

/-- info: 'MM.FLM86WD.pairFibreWindowed_of_factors_through' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86WD.pairFibreWindowed_of_factors_through

/-- info: 'MM.FLM86WD.not_pairFibreWindowed_of_unbounded' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86WD.not_pairFibreWindowed_of_unbounded

/-! ### The uniformity ladder (batch 132 file 3)

`Definitions/MMFLM86Uniform.lean` makes the uniformity-in-the-state obstruction a ladder of window
notions and lands the true chain `UniformWindow ⇒ FibreWindowed ⇒ LocallyFinite2 ⇒ LocallyFiniteIn2`,
the characterization `uniformWindow_iff_finitelySupported`, and the correction `uniformWindow_delta2Two`
(the earlier draft's "delta2Two separates" was false — a constant term *is* uniform). -/

/-- info: 'MM.FLM86UF.locallyFinite2_of_uniformWindow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UF.locallyFinite2_of_uniformWindow

/-- info: 'MM.FLM86UF.fibreUniform_of_uniformWindow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UF.fibreUniform_of_uniformWindow

/-- info: 'MM.FLM86UF.locallyFiniteIn2_of_uniformWindow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UF.locallyFiniteIn2_of_uniformWindow

/-- info: 'MM.FLM86UF.fibreWindowed_of_uniformWindow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UF.fibreWindowed_of_uniformWindow

/-- info: 'MM.FLM86UF.locallyFinite2_of_fibreWindowed' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UF.locallyFinite2_of_fibreWindowed

/-- info: 'MM.FLM86UF.locallyFiniteIn2_of_fibreWindowed' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UF.locallyFiniteIn2_of_fibreWindowed

/-- info: 'MM.FLM86UF.locallyFiniteIn2_of_locallyFinite2' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UF.locallyFiniteIn2_of_locallyFinite2

/-- info: 'MM.FLM86UF.uniformWindow_iff_finitelySupported' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UF.uniformWindow_iff_finitelySupported

/-- info: 'MM.FLM86UF.uniformWindow_delta2Two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UF.uniformWindow_delta2Two

/-- info: 'MM.FLM86UF.mixedPairWindow_of_locallyFinite2_pair' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UF.mixedPairWindow_of_locallyFinite2_pair

/-- info: 'MM.FLM86UF.not_uniformWindow_creationPair2_of_unbounded' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UF.not_uniformWindow_creationPair2_of_unbounded

/-- info: 'MM.FLM86UF.creationPair2_ladder_fails_of_unbounded' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UF.creationPair2_ladder_fails_of_unbounded

/-! ### The infinite support of the normal-ordered product (batch 133)

`Definitions/MMFLM86InfSupp.lean` refutes the `LocallyFinite2` carrier claim of batches 129--132 at
the chain's own datum: on the vacuum the block is the identity at `(0,0)` and the annihilation pair
kills everything but `(0,0)`, so the value of `normOrdered2` at `(0,k)` is the single creation
coefficient `E^-_b(z_2)_k`, which is nonzero for every `k ≥ 0` by the landed
`MM.FLM85FS.creationExpVL_ne_zero`.  Hence `MixedPairWindow`, `LocallyFinite2 (creationPair2 …)` and
`LocallyFinite2 (normOrdered2 …)` are **false**, and batch 131's named hypothesis
`MixedPairUnboundedCreation` is a **theorem** — which makes the four conditional refutations of
batches 131--132 vacuous. -/

/-- info: 'MM.FLM86IS.mixedPairUnboundedCreation' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86IS.mixedPairUnboundedCreation

/-- info: 'MM.FLM86IS.normOrdered2_vacuumVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86IS.normOrdered2_vacuumVL

/-- info: 'MM.FLM86IS.creationPair2_not_locallyFinite2' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86IS.creationPair2_not_locallyFinite2

/-- info: 'MM.FLM86IS.normOrdered2_not_locallyFinite2' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86IS.normOrdered2_not_locallyFinite2

/-- info: 'MM.FLM86IS.midBlock2_vacuumVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86IS.midBlock2_vacuumVL

/-- info: 'MM.FLM86IS.annihPair2_vacuumVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86IS.annihPair2_vacuumVL

/-! ### The one-sided replacement predicate (batch 134)

`Definitions/MMFLM86OneSided.lean` names the finiteness notion the source actually uses --- the family
kills a state outside the union of the two half-planes `{q.1 ≤ K1}` and `{q.2 ≤ K2}` --- and proves the
positive result the refuted predicate could not give: the creation pair `E^-_a(z_1)E^-_b(z_2)`
**satisfies** it, while failing `LocallyFinite2` (batch 133).  Recorded but *not* landed in that file:
the closure under addition and the transfer from `LocallyFinite2` (both true, both left as
`Prop`-valued `def`s because their `Int` `min`/`max` bookkeeping was not closed). -/

/-- info: 'MM.FLM86OS.locallyFinite2OneSided_creationPair2' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OS.locallyFinite2OneSided_creationPair2

/-- info: 'MM.FLM86OS.locallyFinite2OneSided_creationPair2_not_locallyFinite2' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OS.locallyFinite2OneSided_creationPair2_not_locallyFinite2

/-- info: 'MM.FLM86OS.locallyFinite2OneSided_smul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86OS.locallyFinite2OneSided_smul

/-! ### The per-`P` construction (batch 135)

`Definitions/MMFLM86PerP.lean` lands the source's own per-monomial clause of (8.6.14) — "the
coefficient of `P` **and of each monomial of lower total degree than `P`** in `F_N` is a polynomial in
`z_1 - z_2`", which `MMFLM86SpineGap.lean` had recorded as carried "as a finiteness parameter, not as
a lemma" — together with `extraction8615`, the object every landed (8.6.15)/(8.6.17) display was still
taking as a parameter, and its identification with the landed source-typed display
`MM.FLM86N.OperatorDisplay8615`.  Stated but **not** proved there: `Extraction8616Limit` (the (8.6.16)
diagonal limit), which is the residual; nothing in that file mentions the refuted
`LocallyFinite2 (normOrdered2 …)`. -/

/-- info: 'MM.FLM86PP.truncN_uPowMul_factorCoeff8614Multi_of_sum_le' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86PP.truncN_uPowMul_factorCoeff8614Multi_of_sum_le

/-- info: 'MM.FLM86PP.poly_extract_P' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86PP.poly_extract_P

/-- info: 'MM.FLM86PP.truncN_uPowMul_factorCoeff8614Multi_eq_monomial' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86PP.truncN_uPowMul_factorCoeff8614Multi_eq_monomial

/-- info: 'MM.FLM86PP.truncN_uPowMul_factorCoeff8614Multi_lower' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86PP.truncN_uPowMul_factorCoeff8614Multi_lower

/-- info: 'MM.FLM86PP.extraction8615_eq_operatorDisplay8615' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86PP.extraction8615_eq_operatorDisplay8615

/-! ### The (8.6.16) limit: refuted as stated, repaired as a per-state statement (batch 136)

`Definitions/MMFLM86LimitStep.lean` finds that the (8.6.16) reading batches 134/135 gave it — the
landed `MM.FLM86N.OperatorLimitExists` for the grading-shifted `extraction8615` — is **false** at the
chain's own rank-one datum, by a mechanism *different* from batch 133's: the block's first index on the
sector `M(1) ⊗ ι(c)` is `⟨ā,c̄⟩`, unbounded below over `c ∈ L`, so no *uniform* lower bound in the first
index exists.  What survives is the per-state, quarter-plane form: `Extraction8616OneSided` is **proved**
for every datum, monomial and affine shift, and the diagonal substitution is well defined per state
(`diagSum_window`).  The same file also proves the *content* of batch 134's `Prop`-valued
`LocallyFinite2OneSidedAdd` (as `locallyFinite2OneSided_add`; a verifier pass noted that the def's own
type is not instantiated by a landed declaration, the two differing in their binders) and
`normOrdered2_locallyFinite2OneSided`. -/

/-- info: 'MM.FLM86LS.normOrdered2_rankOne_not_operatorLimitExists' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86LS.normOrdered2_rankOne_not_operatorLimitExists

/-- info: 'MM.FLM86LS.not_extraction8616LimitGrading_rankOne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86LS.not_extraction8616LimitGrading_rankOne

/-- info: 'MM.FLM86LS.extraction8616OneSided_holds' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86LS.extraction8616OneSided_holds

/-- info: 'MM.FLM86LS.normOrdered2_locallyFinite2OneSided' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86LS.normOrdered2_locallyFinite2OneSided

/-- info: 'MM.FLM86LS.diagSum_window' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86LS.diagSum_window

/-- info: 'MM.FLM86LS.locallyFinite2OneSided_add' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86LS.locallyFinite2OneSided_add

/-! ### (8.6.17) at `k = l = 1`: the plan's statement corrected, the per-state identity reduced (batch 137)

`Definitions/MMFLM86Identity8617.lean` takes the (8.6.17) target named in batch 136's plan, finds the
plan's literal statement **false as written** (its left side is `[P](F_N)·Y Y`, which carries
`truncN n P` extra powers of `u`; proved as `planOrdinary8617_eq`, together with the fact that the
plan's own suggested cross-check datum is the one where the defect cancels), and proves the corrected
per-state identity from **one** named algebraic obligation (`NegPowMul8617`, the negative-upper
Chu–Vandermonde for the falling-factorial `binomCoeff`) plus a second named geometric one
(`Contraction8612`, the (8.6.12) contraction at `k = l = 1`).  The `truncN n P = 0` case and the whole
window half are proved with no obligation. -/

/-- info: 'MM.FLM86ID.extraction8617_of_negPowMul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86ID.extraction8617_of_negPowMul

/-- info: 'MM.FLM86ID.extraction8617_of_truncN_eq_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86ID.extraction8617_of_truncN_eq_zero

/-- info: 'MM.FLM86ID.extraction8617_of_contraction_and_algebra' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86ID.extraction8617_of_contraction_and_algebra

/-- info: 'MM.FLM86ID.planOrdinary8617_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86ID.planOrdinary8617_eq

/-- info: 'MM.FLM86ID.exists_bound8617' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86ID.exists_bound8617

/-! ### The (8.6.17) algebraic obligation, discharged (batch 138)

`Definitions/MMFLM86ChuVandermonde.lean` proves batch 137's `NegPowMul8617` **outright, with no
hypotheses beyond the def's own vanishing condition** — the source's expansion convention
`u^{-N}(u^M X) = u^{M-N}X`, whose coefficientwise content is the Chu–Vandermonde convolution with a
**negative upper entry** for the landed falling-factorial `binomCoeff`.  Route: Mathlib's Pochhammer
`descPochhammer_smeval_add` holds for arbitrary ring elements, so dividing by `k!` gives the convolution
at arbitrary upper entries in one step.  Consequently `MM.FLM86ID.extraction8617_of_negPowMul` no longer
assumes anything algebraic, and `MM.FLM86CV.extraction8617_holds` gives (8.6.17) at every datum. -/

/-- info: 'MM.FLM86CV.negPowMul8617' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86CV.negPowMul8617

/-- info: 'MM.FLM86CV.extraction8617_holds' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86CV.extraction8617_holds

/-- info: 'MM.FLM86CV.antidiagonal_binomCoeff_add' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86CV.antidiagonal_binomCoeff_add

/-- info: 'MM.FLM86CV.binomCoeffF_add' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86CV.binomCoeffF_add

/-! ### G2 and G3 of the Theorem 8.6.1 gap map (batch 139)

`Definitions/MMFLM86Contraction8612.lean` (G2) proves the carrier identities the (8.6.12) contraction at
`k = l = 1` needs — including the (7.1.38) index shift of the block by the pairing, which the gap map's
consumption list had missed — and reduces the contraction to one named bookkeeping residue
(`Contraction8612Ratio`); **G2 is not closed**, and the file says so.
`Definitions/MMFLM86ThetaPerState.lean` (G3) verifies by compilation that the landed (8.6.20)/(8.6.21)
hypotheses *are* the refuted `OperatorLimitExists`, replaces them by a per-state form, proves the
transfer from the landed form, proves strictness, and gives unconditional per-state positives at the
chain's own `Y_P`. -/

/-- info: 'MM.FLM86CT.midFam_mul_midFam' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86CT.midFam_mul_midFam

/-- info: 'MM.FLM86CT.contractionTerm_resolved' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86CT.contractionTerm_resolved

/-- info: 'MM.FLM86TPS.not_operatorLimitExists_extraction8615_rankOne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TPS.not_operatorLimitExists_extraction8615_rankOne

/-- info: 'MM.FLM86TPS.resumPrefactorPerState_of_operatorLimitExists' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TPS.resumPrefactorPerState_of_operatorLimitExists

/-- info: 'MM.FLM86TPS.locallyFinite2OneSided_of_perState_bounds' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TPS.locallyFinite2OneSided_of_perState_bounds

/-! ### The (8.6.12) reindexing closed, and a fifth false-uniform def found (batch 140)

`Definitions/MMFLM86Reindex8612.lean` closes the G2 residue batch 139 named: the fourfold `Finset`
reindexing along the explicit bijection is proved, and with it **`MM.FLM86ID.Contraction8612` is
discharged for every exponent** — so `MM.FLM86ID.extraction8617_of_contraction_and_algebra` no longer
assumes the contraction, and (8.6.17) is closed at `k = l = 1`.  The batch also found that batch 139's
residue *def* `Contraction8612Ratio` is **false at a negative exponent**: it asks for one threshold `T0`
per state, while the threshold must depend on `(p,q)`.  The corrected statement is proved for every sign.
`Definitions/MMFLM86ThetaOperatorPerState.lean` restates `OperatorDisplay8620Statement` per state (the
def of record is unsatisfiable at `Y_P` for every window pair), with transfer, proved strictness and
unconditional positives. -/

/-- info: 'MM.FLM86RX.twoVarField_eq_sum_range' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86RX.twoVarField_eq_sum_range

/-- info: 'MM.FLM86RX.contraction8612_holds' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86RX.contraction8612_holds

/-- info: 'MM.FLM86RX.threshold_holds' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86RX.threshold_holds

/-- info: 'MM.FLM86RX.not_contraction8612Ratio_of_neg' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86RX.not_contraction8612Ratio_of_neg

/-- info: 'MM.FLM86TO.operatorDisplay8620PerState_of_statement' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TO.operatorDisplay8620PerState_of_statement

/-- info: 'MM.FLM86TO.not_operatorDisplay8620Statement_but_perState_rankOne' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TO.not_operatorDisplay8620Statement_but_perState_rankOne

/-! ### The (8.6.24) face at `k = l = 1`, and G4 re-scoped (batch 141)

`Definitions/MMFLM86MultiVarSeries.lean` builds the source's (8.6.5) series and the (8.6.25)
cross-contraction factor on the landed carriers, proves the `k = 1` identification (non-vacuity) and
proves `display8625_iff_contraction`: **(8.6.25) is equivalent to the cross-contraction identity** — so
the last gap is a missing *proof* (the §8.4 operator-product computation), **not** a missing object:
the multi-variable carrier had already landed in batch 119, and the file names the stale sentence that
said otherwise.
`Definitions/MMFLM86Theorem861K1.lean` assembles the (8.6.24) face at `k = l = 1`: the commutator
coefficient *is* the difference of the two product coefficients and that difference *is* the landed
(8.6.21)/(8.6.22) prefactor object, with the exact converse — so the remaining hypothesis
(`Display8619Z`, the source's (8.6.19) on the `z₁`-ray) is exactly the missing input. -/

/-- info: 'MM.FLM86MV.display8625_iff_contraction' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MV.display8625_iff_contraction

/-- info: 'MM.FLM86MV.seriesCoeff_zero_zero_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MV.seriesCoeff_zero_zero_ne_zero

/-- info: 'MM.FLM86T81.commutatorCoeff_eq_thetaMulOperator8620' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86T81.commutatorCoeff_eq_thetaMulOperator8620

/-- info: 'MM.FLM86T81.display8624_rankOne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86T81.display8624_rankOne

/-- info: 'MM.FLM86T81.display8624_rankOne_perState' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86T81.display8624_rankOne_perState

/-! ### Batch 141's `Display8625` is FALSE, and the uniform bound is refuted (batch 142)

`Definitions/MMFLM86CrossContraction.lean` re-read the page image of (8.6.25) and found that batch 141's
transcription **dropped the `ι(1)`**: the source's right side is the *jointly* normal-ordered product
applied to the **vacuum**, not the A-side product read on the state `B`.  With that correction
`Display8625` is **false** (`not_display8625_rankOne_conv`, `exists_not_display8625_rankOne_conv`), so
batch 141's "the last gap is one cross-contraction proof" is replaced by: the missing object is the
mixed `(k,l)` normal-ordered product with its vacuum insertion.
`Definitions/MMFLM86BoundPerState.lean` shows the `hK2` that batches 140/141 consumed is **state-uniform**
while the landed supply (`exists_bound8617`) is **per state** — and the uniform form is **refuted** at the
chain's own rank-one datum, so those theorems cannot be instantiated there as stated.  The file supplies
the per-state replacements and proves them (`truncAtBounds`), removing the vacuity for the `k = l = 1`
(8.6.12)/(8.6.17) face. -/

/-- info: 'MM.FLM86XC.not_display8625_rankOne_conv' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86XC.not_display8625_rankOne_conv

/-- info: 'MM.FLM86XC.exists_not_display8625_rankOne_conv' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86XC.exists_not_display8625_rankOne_conv

/-- info: 'MM.FLM86BPS.not_stateUniform_secondIndexBound_rankOne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86BPS.not_stateUniform_secondIndexBound_rankOne

/-- info: 'MM.FLM86BPS.extraction8617_rankOne_perState_of_exists_bound' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86BPS.extraction8617_rankOne_perState_of_exists_bound

/-- info: 'MM.FLM86BPS.cutRight_normOrdered2_rankOne_ne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86BPS.cutRight_normOrdered2_rankOne_ne

/-! ### The mixed `(k,l)` product built, and the `pairCoef` laws (batch 143)

`Definitions/MMFLM86MixedProduct.lean` builds the object batch 142 proved was missing: the *jointly*
normal-ordered product `∏_i Y(a_i,z₀+w_i)·∏_j Y(b_j,x_j)` read on a state, its `k = l = 1`
identification with the landed `twoVarField`, and the corrected (8.6.25) reduced to **one named scalar
residue** (`BinomialForm8612One`) — with **its own correction to batch 142's `JointDisplay`**, whose
diagonal shape cannot be instantiated at the actual joint object because the display **convolves** in
`(r,s)`.
`Definitions/MMFLM86PairCoefLaws.lean` proves the induction base (empty-product and support laws, the
matching-case product law) and **refutes** the split law the induction was expected to use
(`not_pairCoefSplitLaw`, with a measured counterexample), replacing it with the true increment law. -/

/-- info: 'MM.FLM86MXP.mixedProd_one_one_eq_twoVarShift' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MXP.mixedProd_one_one_eq_twoVarShift

/-- info: 'MM.FLM86MXP.display8625One_iff_binomialForm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86MXP.display8625One_iff_binomialForm

/-- info: 'MM.FLM86PCL.pairCoef_zero_left' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86PCL.pairCoef_zero_left

/-- info: 'MM.FLM86PCL.not_pairCoefSplitLaw' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86PCL.not_pairCoefSplitLaw

/-- info: 'MM.FLM86PCL.pairCoef_matching' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86PCL.pairCoef_matching

/-! ### (8.6.25) at `k = l = 1` is a THEOREM, and the general joint object exists (batch 144)

`Definitions/MMFLM86Binomial8612.lean` proves the scalar identity batch 143 left open and closes the
display on the vacuum: **`display8625One_vacuumVL`** — the corrected (8.6.25) at `k = l = 1`, with no new
hypothesis.  `Definitions/MMFLM86Binomial8612Refute.lean` records the defect that made this delicate:
batch 143's `BinomialForm8612One` is **false at a general state** (`¬ BinomialForm8612One … (ι(−1))`), true
only where the state (8.6.25) actually lives, and the file names the per-state hypothesis that separates
the two.  `Definitions/MMFLM86JointGeneral.lean` builds the mixed joint object for every `k, l`, proves
the `k + l = 2` identification with batch 143's object, and proves the double-convolution increment step
at `k + l = 3`. -/

/-- info: 'MM.FLM86B86.display8625One_vacuumVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86B86.display8625One_vacuumVL

/-- info: 'MM.FLM86B86.scalar8612' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86B86.scalar8612

/-- info: 'MM.FLM86B86R.not_binomialForm8612One_rankOne_iotaNegOne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86B86R.not_binomialForm8612One_rankOne_iotaNegOne

/-- info: 'MM.FLM86JG.jointProd_one_one_eq_jointNO' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86JG.jointProd_one_one_eq_jointNO

/-- info: 'MM.FLM86JG.pairCoefIncrement_one_one' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86JG.pairCoefIncrement_one_one

/-! ### Theorem 8.6.1's display assembled and reduced; the `pairCoef` increment proved in general (batch 145)

`Definitions/MMFLM86IncrementTwoTwo.lean` **proves `PairCoefIncrement` outright** (not at `(2,2)` only):
the `(2,2)` and `(2,1)` instances are corollaries, and the file *measures* why `k = 2` is the first case
with content (`compBox_two_one_card`).  `Definitions/MMFLM86TheoremDisplay.lean` states (8.6.3) on the
landed carrier and proves it is **equivalent to the landed `Corollary851` at the states of (8.6.2)** ---
i.e. to the `Res_{z₀}` (`p = −1`) face of the landed Jacobi delta form, which is Remark 8.8.11's reading
of the theorem --- so the display reduces to the repository's named open input, and that is the honest
outcome. -/

/-- info: 'MM.FLM86I22.pairCoefIncrement' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86I22.pairCoefIncrement

/-- info: 'MM.FLM86I22.pairCoefIncrement_two_two' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86I22.pairCoefIncrement_two_two

/-- info: 'MM.FLM86TDA.display863_iff_sourceStatement' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TDA.display863_iff_sourceStatement

/-- info: 'MM.FLM86TDA.residue863_iff_corollary851' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TDA.residue863_iff_corollary851

/-- info: 'MM.FLM86TDA.residue863_iff_deltaResidueFace' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TDA.residue863_iff_deltaResidueFace

/-! ### The product expansion at every state (batch 147)

`Definitions/MMFLM86ProductExpansion.lean` proves, for `0 <= <a,b>` and at **every state and every index
pair**, `twoVarField a b = convWith2 (normOrdered2 a b) (contrFam <a,b>)` — the product expansion
(8.5.12)/(8.6.12) on the carrier, with no vacuum hypothesis and no per-state threshold (the tail is cut
by the scalar binomial vanishing `C(N,k) = 0` for `k > N`).  It also records two corrections: the landed
`MM.FLM84P.productExpansionStatement` is **not typeable at this carrier** (`conv2` needs a commutative
ring; the carrier product is composition), and its faithful ring-level transcription is **false**, with an
explicit rank-one vacuum counterexample.  `0 <= <a,b>` is proved essential: for a negative exponent the
contraction family is not locally finite and `convWith2` does not apply. -/

/-- info: 'MM.FLM86PE.twoVarField_eq_convWith2_contrFam' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86PE.twoVarField_eq_convWith2_contrFam

/-- info: 'MM.FLM86PE.twoVarField_eq_sum_range_contrFam' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86PE.twoVarField_eq_sum_range_contrFam

/-- info: 'MM.FLM86PE.not_locallyFinite2_contrFam_of_neg' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86PE.not_locallyFinite2_contrFam_of_neg

/-! ### The quadrant hypothesis removed, and the first dictionary link (batch 148)

`Definitions/MMFLM86Quadrant8612.lean` closes batch 147's §8 residue in a **stronger** form than asked:
the quadrant hypothesis is **removed** — for `0 ≤ ⟨a,b⟩` and a state with the landed two-sided vanishing,
`twoVarField a b P Q v = conv2Var (normOrdered2 a b) (contrFam ⟨a,b⟩) P Q v` at **every** `(P,Q)`.  Off
the quadrant both sides are `0`; the explicit reindexing is batch 147's named work.  The file also proves
the *state hypothesis cannot be dropped*: `not_quadrantResidueStateFree_rankOne` refutes the state-free
form **inside** the quadrant, so batch 147's §8 item 3 was mis-stated about what was missing.
`Definitions/MMFLM86Dictionary8612.lean` proves **link (1)** of batch 147's dictionary (the `z₁ = z₀+z₂`
shift: the new `altSum_eq` from scratch, then `diagFam_twoVarField_eq`) and pins **link (2)** as one named
`Prop`, `DiagOrdinary` — i.e. (8.5.11)/(8.5.12) at the module level, which is now the single obstruction
to applying `corollary851_iff_theorem842`. -/

/-- info: 'MM.FLM86Q86.twoVarField_apply_eq_conv2Var' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86Q86.twoVarField_apply_eq_conv2Var

/-- info: 'MM.FLM86Q86.not_quadrantResidueStateFree_rankOne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86Q86.not_quadrantResidueStateFree_rankOne

/-- info: 'MM.FLM86D86.altSum_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86D86.altSum_eq

/-- info: 'MM.FLM86D86.diagFam_twoVarField_eq' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86D86.diagFam_twoVarField_eq

/-! ## The goal, and the fact that it is not vacuous -/

-- Not guarded: this one is the `sorry`.
-- #print axioms MM.MoonshineModule.moonshine_conjecture

/-! ### Batch 152: the finiteness parenthetical of (8.5.26), and the display (8.6.3) from (8.10.8)

`Definitions/MMFLM86UniformVanishing.lean` lands the source's own finiteness parenthetical of printed
p. 201 — *"`ι(a)_i·ι(b) = 0` for `i` sufficiently large"* — as a **uniform-in-`(m,n)`** statement, which
is the one input `MM.FLM88.corollary851_of_jacobiIdentity` consumes.  It also **refutes** the landed
`WeightGrading.IsHomogeneousOp` (`isHomogeneousOp_eq_zero`): the predicate demands the weight identity
also at `T a = 0`, where it reads `S.wt 0 = S.wt a + p`, so it forces `p = 0` and is unsatisfiable at
every `p ≠ 0`; every landed lemma taking it as a hypothesis is therefore vacuous.  The satisfiable repair
is `IsHomogeneousOpOn`, and the axiom-level route — the source's parenthetical *is* (8.10.5) — needs
neither.

`Definitions/MMFLM86DisplayVOASplit.lean` lands **FLM Theorem 8.6.1's display (8.6.3)** from exactly two
inputs: the faithful (8.10.8) `MM.FLM810JF.FaithfulJacobi` (the `jacobi` field of the landed
`MM.FLM810.VertexOperatorAlgebra`) and the uniform window above.  The passage uses only the `l = 0` face
of (8.8.41), where the cross side is the window-independent commutator family, so the axiom's
per-monomial, per-element window suffices — which is why the display needs no uniform `JacobiIdentity`.
The Section 8.10 assembly form `display863_of_remainingFields` consumes **only** the `JacobiAxiom`
conjunct of the four `ActionRemainingFields`. -/

/-- info: 'MM.FLM86UV.exists_uniform_bracketTerm_vanishing' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UV.exists_uniform_bracketTerm_vanishing

/-- info: 'MM.FLM86UV.not_isHomogeneousOp' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86UV.not_isHomogeneousOp

/-- info: 'MM.FLM86DVS.display863_of_voa_self' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86DVS.display863_of_voa_self

/-- info: 'MM.FLM86DVS.display863_fixed_window' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86DVS.display863_fixed_window

/-- info: 'MM.FLM86DVS.display863_of_remainingFields' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86DVS.display863_of_remainingFields

/-! ### Batch 153: the corrected (zero-mode) build of `V_L`, and the concrete exponential product

`Definitions/MMFLM810CorrectedZeroAssembly.lean` lands the Section 8.10 assembly line at the
**zero-mode-corrected** action prescription `MM.FLM85ZP.actionPrescriptionTAZero`, whose unique
extension is `MM.FLM810ZMU.Yzero` — the field of the construction, since the landed prescription's
field omits the (7.1.33)/(7.1.41) zero mode `a(0)` and is *refuted* on two sibling fields
(`MM.FLM810MD.not_l0OnWeightGenerators_modelBase`).  `Definitions/MMFLM86ExpProduct.lean` lands the
concrete two-point product at the lattice generators and its commutator corollary, and measures the
two factors still missing there: the grading shift `z^{a(0)}` and the annihilation half `E^+` — so the
object the remaining work must be stated about is the assembled (8.4.17) field
`MM.FLM84LF.YFam`, not `Yzero`.  See `ROADMAP.md` "Batch 153" and `NOTES.md` §66--67. -/

/-- info: 'MM.FLM86EP.Yzero_iotaVL_mul_Yzero_iotaVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86EP.Yzero_iotaVL_mul_Yzero_iotaVL

/-- info: 'MM.FLM86EP.commutatorFamily_Yzero_iotaVL_eq_c' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86EP.commutatorFamily_Yzero_iotaVL_eq_c

/-- info: 'MM.FLM810CZA.componentTruncationZero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CZA.componentTruncationZero

/-- info: 'MM.FLM810CZA.theorem8102_of_generatorFieldsZero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CZA.theorem8102_of_generatorFieldsZero

/-- info: 'MM.FLM810CZA.theorem8102_of_remainingFieldsZero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CZA.theorem8102_of_remainingFieldsZero

/-! ### Batch 154: the honest (8.4.17) field `MM.FLM84LF.YFam` at the lattice generators

`Definitions/MMFLM86YFamProduct.lean` lands the two-point product of the **assembled** field
`YFam` -- the only landed `V_L` field carrying both the grading shift `z^{a(0)}` and the annihilation
half `E^+` -- together with the (8.4.22)/(8.4.25) expansion into the two-variable carrier and the
coefficientwise `(z_1-z_2)^{<a,b>}`.  The expansion carries `0 <= <a,b>`: for a negative pairing the
contraction family is not locally finite, and the classical resolution is the `z_1 <-> z_2` symmetry,
which batch 154's task R1 lands in `Definitions/MMFLM86TwoVarSwap.lean`.

`Definitions/MMFLM86IterateIota.lean` lands the **iterate side** of `MM.FLM85Co.Corollary851` at the
lattice generators -- the `l = 0` face of the Jacobi identity, which is Theorem 8.6.1's display -- with
the sharp window `(-<a,b>).toNat` and no (8.10.5) hypothesis.  It carries the source's (8.5.2) as
`MM.FLM86II.YFamOnGenerators`, whose landed inhabitant `MM.FLM810ZMU.Yzero` is batch 155's task S1. -/

/-- info: 'MM.FLM86YP.YFam_mul_eq_twoVarField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86YP.YFam_mul_eq_twoVarField

/-- info: 'MM.FLM86YP.contraction_coeff_eq_binom' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86YP.contraction_coeff_eq_binom

/-- info: 'MM.FLM86II.iterateOf_lattice_eq_zero_of_window' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86II.iterateOf_lattice_eq_zero_of_window

/-- info: 'MM.FLM86II.stateFamilyStatement_lattice' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86II.stateFamilyStatement_lattice

/-- info: 'MM.FLM86II.corollary851Residue_lattice' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86II.corollary851Residue_lattice

/-- info: 'MM.FLM86YZF.not_YFamOnGenerators_modelBaseField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86YZF.not_YFamOnGenerators_modelBaseField

/-- info: 'MM.FLM86YZF.Yzero_iotaVL_apply_iotaVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86YZF.Yzero_iotaVL_apply_iotaVL

/-- info: 'MM.FLM86YZF.not_iterateStateFamily_lattice_Yzero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86YZF.not_iterateStateFamily_lattice_Yzero

/-- info: 'MM.FLM86TS.twoVarField_swap2' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TS.twoVarField_swap2

/-- info: 'MM.FLM86TS.not_swap2_twoVarField_rankOne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86TS.not_swap2_twoVarField_rankOne

/-- info: 'MM.FLM86CI.commutator_YFam_eq_zero_of_even' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86CI.commutator_YFam_eq_zero_of_even

/-- info: 'MM.FLM86CI.evenCocycle_c_mul_neg_one_zpow' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86CI.evenCocycle_c_mul_neg_one_zpow

/-- info: 'MM.FLM86CI.not_YFamOnGenerators_and_corollary851_rankOne' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86CI.not_YFamOnGenerators_and_corollary851_rankOne

/-- info: 'MM.FLMIotaVar.iota12Ring_injective' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMIotaVar.iota12Ring_injective

/-- info: 'MM.FLMIotaVar.iota12_sub_iota21_invShift' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLMIotaVar.iota12_sub_iota21_invShift

/-- info: 'MM.FLM86CS.not_modelBasePositiveModesKillVacuum' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86CS.not_modelBasePositiveModesKillVacuum

/-- info: 'MM.FLM86CS.rankOne_component_neg_two_ne_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM86CS.rankOne_component_neg_two_ne_zero

/-- info: 'MM.FLM810TB.translationOnStateData_baseRepaired_base_state_iff' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810TB.translationOnStateData_baseRepaired_base_state_iff

/-- info: 'MM.FLM810TB.baseRepaired_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810TB.baseRepaired_zero

/-- info: 'MM.FLM85BA.genFam_vacuum_creates' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85BA.genFam_vacuum_creates

/-- info: 'MM.FLM85BA.genFam_lower_truncation_iotaVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85BA.genFam_lower_truncation_iotaVL

/-- info: 'MM.FLM85BA.Yaligned_iotaVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85BA.Yaligned_iotaVL

/-- info: 'MM.FLM84DY.actionFold_iotaVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84DY.actionFold_iotaVL

/-- info: 'MM.FLM84DY.deriv_creationExpVL' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84DY.deriv_creationExpVL

/-- info: 'MM.FLM85CF.splitPlus_defect_at_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85CF.splitPlus_defect_at_zero

/-- info: 'MM.FLM85CF.deriv_YCoeff_eq_opOpenBox_canonicalField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85CF.deriv_YCoeff_eq_opOpenBox_canonicalField

/-- info: 'MM.FLM85SP.annihPair_canonicalField_latticeField' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85SP.annihPair_canonicalField_latticeField

/-- info: 'MM.FLM85SP.splitPlus_heisFam_neg_defect_at_zero' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM85SP.splitPlus_heisFam_neg_defect_at_zero

/-- info: 'MM.FLM810TA2.theorem8102_of_generatorFieldsAligned_l0' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810TA2.theorem8102_of_generatorFieldsAligned_l0

/-- info: 'MM.FLM84TLP.tailLeibniz_tailOp' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84TLP.tailLeibniz_tailOp

/-- info: 'MM.FLM84TLP.actionFamily_deriv' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84TLP.actionFamily_deriv

/-- info: 'MM.FLM84TLP.not_tailLeibnizResidual' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM84TLP.not_tailLeibnizResidual

/-- info: 'MM.FLM810TG.actionFold_deriv_field' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810TG.actionFold_deriv_field

/-- info: 'MM.FLM810TG.translationOnStateData_iff_dFold' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810TG.translationOnStateData_iff_dFold

/-- info: 'MM.FLM87SH.fockSugawara_neg_one_creation' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SH.fockSugawara_neg_one_creation

/-- info: 'MM.FLM87SH.correctedStateHalf_of_zeroPart' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SH.correctedStateHalf_of_zeroPart

/-- info: 'MM.FLM810SHC.lMinusOneCreationMode' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810SHC.lMinusOneCreationMode

/-- info: 'MM.FLM810SHC.zeroPartCreationCommutes' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810SHC.zeroPartCreationCommutes

/-- info: 'MM.FLM87SBC.theorem8102_of_generatorFieldsAligned_dimH' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SBC.theorem8102_of_generatorFieldsAligned_dimH

/-- info: 'MM.FLM87SBC.not_orthonormalBasis_of_even' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SBC.not_orthonormalBasis_of_even

/-- info: 'MM.FLM810CI.Yzero_modeVL_eq_actionFamily_nat' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CI.Yzero_modeVL_eq_actionFamily_nat

/-- info: 'MM.FLM810CI.baseResidual_iff_actionFamily_base' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CI.baseResidual_iff_actionFamily_base

/-- info: 'MM.FLM87GS.form_eq_of_gramTwist' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87GS.form_eq_of_gramTwist

/-- info: 'MM.FLM87GS.not_gramTwist_rankOne_even' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87GS.not_gramTwist_rankOne_even

/-- info: 'MM.FLM810DFA.translationResidual_of_baseResidual' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810DFA.translationResidual_of_baseResidual

/-- info: 'MM.FLM810DFA.factorSmul' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810DFA.factorSmul

/-- info: 'MM.FLM87TC.sugawaraModeZero_mul_modeZ_sub' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87TC.sugawaraModeZero_mul_modeZ_sub

/-- info: 'MM.FLM87DC.normalOrderedHeisPairZero_mul_normalOrderedHeisPairZero_sub' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87DC.normalOrderedHeisPairZero_mul_normalOrderedHeisPairZero_sub

/-- info: 'MM.FLM87SR.sugawaraBracketAtDimH' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SR.sugawaraBracketAtDimH

/-- info: 'MM.FLM87SR.virasoroOnStateData_aligned_dimH_noOrth' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SR.virasoroOnStateData_aligned_dimH_noOrth

/-- info: 'MM.FLM87SR.lMinusOneCreationMode_noOrth' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM87SR.lMinusOneCreationMode_noOrth

/-- info: 'MM.FLM810TNO.theorem8102_of_generatorFieldsAligned_noOrth' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810TNO.theorem8102_of_generatorFieldsAligned_noOrth

/-- info: 'MM.FLM810TNO.baseResidual_iff_creationModeStep' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810TNO.baseResidual_iff_creationModeStep

/-- info: 'MM.FLM810JZF.corollary851_Yaligned_lattice_of_nonneg' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810JZF.corollary851_Yaligned_lattice_of_nonneg

/-- info: 'MM.FLM810JZF.yFamOnGenerators_vertexOpOfField_Yaligned' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810JZF.yFamOnGenerators_vertexOpOfField_Yaligned

/-- info: 'MM.FLM810CC.derivDefect_comp_modeVL_sub' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CC.derivDefect_comp_modeVL_sub

/-- info: 'MM.FLM810JF2.not_jacobiOnStateTargets_ZAligned_trivialCocycle' depends on axioms: [propext,
 Classical.choice,
 Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810JF2.not_jacobiOnStateTargets_ZAligned_trivialCocycle

/-- info: 'MM.FLM810JF2.cocycleCompatible_of_jacobiOnStateTargets' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810JF2.cocycleCompatible_of_jacobiOnStateTargets

/-- info: 'MM.FLM810CFC.theorem8102_of_hs' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CFC.theorem8102_of_hs

/-- info: 'MM.FLM810CFC.currentFieldComm' depends on axioms: [propext, Classical.choice, Quot.sound] -/
#guard_msgs in
#print axioms MM.FLM810CFC.currentFieldComm
