Finite-sum weights and coefficients for the quantum Tet certificate
DefinitionQuantumSixJSumCertificateAuxiliary rational functions over for the finite-sum certificate of the Appendix Tet recurrence. The bundle specifies the raw summand, common factorial weight, cleared three-term coefficients, flux multiplier, flux, raw and finite-sum residuals, finite summation length, Appendix prefactor, and clearing factor. The diagonal and two step-2 entry functions are branch-expanded expressions used for factorial shifts; their identification with the symmetric two-index matrix is a proof obligation, not assumed. All factorials retain their signed-index zero convention and division is total in the rational-function field. No identity or recurrence is assumed.
Independent mathematical read-back
Read-back: finite-sum certificate declarations
Explicit notation used in the paragraphs
All scalar values below belong to the rational-function field , where is the image of the polynomial indeterminate. For every integer , write
In particular . Powers with integer exponents are field powers. All division and inversion are total field operations: and . All label subtraction is integer subtraction, not truncated subtraction. Every division of integer labels by means Euclidean integer division (for divisor , the floor of the half), including when the numerator is negative or odd. No evaluation at a numerical value of is involved.
The predicate means that are nonnegative integers, each is at most the sum of the other two, and is even. Write and , always with the external labels of the paragraph in question. The following explicitly specified scalar expressions provide notation for expanded dependency quantities:
For external integers and integer channels , let the four-entry and three-entry lists be
List indices start at . Put
Here an integer-indexed sum from to a negative upper endpoint is empty and equals zero. Thus includes both the admissibility guard on the finite sum and total division by ; it is not a separate unspecified coefficient.
Declaration paragraphs
QuantumSixJ.diagonalEntry. For all integers , this defines a scalar equal to if and , and equal to zero otherwise, with expanded above. In particular the value at is zero even if both triples in satisfy the triangle and parity conditions; inadmissible and negative horizontal labels also take the zero branch. There is no additional nonvanishing or positivity hypothesis.
QuantumSixJ.Lp2. For all integers , this defines the scalar when both and hold, and zero otherwise, where is the explicitly guarded product of the two expressions divided by given above. Both horizontal channels must satisfy nonnegative triangle and even-sum conditions; no separate hypothesis restricts any input integer, and the formula includes .
QuantumSixJ.Lm2. For all integers , this defines the scalar when both and hold, and zero otherwise, where is the explicitly guarded expression above. In particular and give zero because the channel is negative; neither subtraction is natural-number subtraction. There are no hypotheses on the input labels.
QuantumSixJ.Certificate.rawSummand. For any eight integers , this defines the scalar
Here denotes the explicitly defined signed-index quantum factorial above, while the bare letter inside an argument is the sixth integer parameter. There is no admissibility or support guard and no restriction ; a negative factorial argument in the denominator makes the quotient zero by total field division, and makes the numerator factorial zero.
QuantumSixJ.Certificate.commonWeight. For any seven integers , set and ; this defines the scalar
The function is the signed-index quantum factorial, distinct from the integer parameter . The definition has no hypotheses, including no support, admissibility, or positivity restriction, and inverses of zero factorial values are zero.
QuantumSixJ.Certificate.lowerCoefficient. For any integers , this defines the scalar , with every bracket the rational-function quotient specified above. There are no sign, parity, or nonzero assumptions on the parameters; the definition includes and negative inputs.
QuantumSixJ.Certificate.upperCoefficient. For any integers , set ; this defines the scalar . Every bracket is the specified rational-function quotient; the integer parameter is not a factorial here. There are no hypotheses, and at the final factor is .
QuantumSixJ.Certificate.centerCoefficient. For any integers , set and ; this defines the scalar
All brackets are the explicit rational functions above, all parameters range over all integers without further assumptions, and the formula includes zero and negative values of .
QuantumSixJ.Certificate.scaledMultiplier. For any integers , set ; this defines the scalar
The brackets are the stated rational-function quotients. No support, sign, parity, or nonzero restrictions are imposed on any of the seven integer parameters.
QuantumSixJ.Certificate.flux. For any integers , set and ; this defines the scalar
Here is the signed-index factorial, distinct from the integer parameter , and all bracket and factorial expressions are expanded in the conventions above. There are no hypotheses and no explicit support guard; zero denominators and negative factorial arguments use the total-field and signed-factorial conventions.
QuantumSixJ.Certificate.rawResidual. For any integers , set and , and abbreviate the following explicit products by solely within this paragraph:
The defined scalar is exactly
The notation denotes the factorial and bare the integer parameter. There are no hypotheses or support restrictions, and zero denominators give zero quotients, not undefined terms.
QuantumSixJ.Certificate.sumLength. For any integers , this defines the natural number , where the maximum is regarded as a natural number before adding . The truncation applies to the whole sum of the six integers, not to its individual terms; hence every input gives a length of at least , and a nonpositive total gives length exactly .
QuantumSixJ.Certificate.totalResidual. For any integers , put , , , , , , , and . For these integers form
This defines the scalar
Factorial is distinct from the integer . There are no admissibility or positivity hypotheses. The summation uses the natural numbers cast to integers, and contains at least three terms even when the total of the six labels is negative; are the displayed derived integers, without separately replacing them by other half-sums on arbitrary odd inputs.
QuantumSixJ.Certificate.prefactor. For any integers , using the four and three explicit half-sum lists above, this defines the scalar
There is no admissibility guard: odd or negative labels still have values, using Euclidean division for the half-sums, zero for negative-index factorials, and total field division. In particular a negative one of the six denominator labels makes the value zero.
QuantumSixJ.Certificate.clearingFactor. For every integer , this defines the scalar , with each bracket the specified rational-function quotient. No assumption that this product is nonzero is part of the definition; it equals zero at least for because one factor is .
QuantumSixJ.Certificate.mainResidual. For any integers , define, within this paragraph, when and zero otherwise; when and zero otherwise; and when and zero otherwise. The defined scalar is
where are the explicitly expanded predicates and rational-function finite-sum expressions above. No admissibility, positivity, or nonzero condition is assumed on the six integers; the neighbor values include negative channels, the zero diagonal at is retained, and every quotient, including the division by in each , uses total field division.
import Definitions.Def_QuantumSixJScalar
/-! Auxiliary finite-sum weights and coefficients for the telescoping proof.
The three entry functions are the diagonal and step-2 entries, written without
two-index minimum/maximum branches for factorial-shift calculations.
-/
noncomputable section
open scoped BigOperators QuantumSixJ Classical
namespace QuantumSixJ
def diagonalEntry (a b c d j : ℤ) : Scalar :=
if hAdmissible a b c d j ∧ j ≠ 0 then
-h a b c d j * ⟬2⟭ * Λ a j d * Λ b j c / (⟬j⟭ * ⟬j + 2⟭)
else 0
def Lp2 (a b c d j : ℤ) : Scalar :=
if hAdmissible a b c d j ∧ hAdmissible a b c d (j + 2) then
h a b c d (j + 2) * ⟬(a + d - j) / 2⟭ * ⟬(b + c - j) / 2⟭
else 0
def Lm2 (a b c d j : ℤ) : Scalar :=
if hAdmissible a b c d j ∧ hAdmissible a b c d (j - 2) then
h a b c d j * ⟬(a + d - (j - 2)) / 2⟭ * ⟬(b + c - (j - 2)) / 2⟭
else 0
end QuantumSixJ
noncomputable section
namespace QuantumSixJ.Certificate
open scoped QuantumSixJ BigOperators
def rawSummand (A B C D E F G S : ℤ) : Scalar :=
(-1 : Scalar) ^ S * ⟬S + 1⟭! /
(⟬S - A⟭! * ⟬S - B⟭! * ⟬S - C⟭! * ⟬S - D⟭! *
⟬E - S⟭! * ⟬F - S⟭! * ⟬G - S⟭!)
def commonWeight (A B C E F j S : ℤ) : Scalar :=
let D := E + F - C - j
let G := A + B - j
(-1 : Scalar) ^ S * ⟬S + 1⟭! *
(⟬S - A + 1⟭!)⁻¹ * (⟬S - B + 1⟭!)⁻¹ * (⟬S - C⟭!)⁻¹ *
(⟬S - D⟭!)⁻¹ * (⟬E - S + 1⟭!)⁻¹ * (⟬F - S + 1⟭!)⁻¹ * (⟬G - S⟭!)⁻¹
def lowerCoefficient (A B j : ℤ) : Scalar :=
(⟬A - j + 1⟭ * ⟬B - j + 1⟭ * ⟬A + 1⟭ * ⟬B + 1⟭) * ⟬2⟭ * ⟬j + 2⟭
def upperCoefficient (C E F j : ℤ) : Scalar :=
let D := E + F - C - j
(⟬E - C + 1⟭ * ⟬F - D + 1⟭ * ⟬F - C + 1⟭ * ⟬E - D + 1⟭) * ⟬2⟭ * ⟬j⟭
def centerCoefficient (A B C E F j : ℤ) : Scalar :=
let D := E + F - C - j
let G := A + B - j
let la := ⟬A - j⟭ * ⟬E - C⟭ - ⟬F - D⟭ * ⟬A + 2⟭
let lb := ⟬B - j⟭ * ⟬F - C⟭ - ⟬E - D⟭ * ⟬B + 2⟭
let ll := ⟬F - B⟭ * ⟬E - A⟭ - ⟬G - D⟭ * ⟬C + 2⟭
let nb := -(la * lb + ll * ⟬j⟭ * ⟬j + 2⟭)
nb * ⟬j + 1⟭
def scaledMultiplier (A B C E F j t : ℤ) : Scalar :=
let D := E + F - C - j
⟬2⟭ * (⟬j + 2⟭ * ⟬t - E - 1⟭ *
(⟬j⟭ * ⟬F - A + 1⟭ * ⟬t - B⟭ +
⟬B - j + 1⟭ * ⟬A + 1⟭ * ⟬F - t + 1⟭) -
⟬j⟭ * ⟬F - C + 1⟭ * ⟬F - D + 1⟭ * ⟬t - A⟭ * ⟬t - B⟭)
def flux (A B C E F j S : ℤ) : Scalar :=
let D := E + F - C - j
let G := A + B - j
rawSummand A B (C + 1) (D + 1) (E + 1) (F + 1) G S *
scaledMultiplier A B C E F j S
def rawResidual (A B C E F j S : ℤ) : Scalar :=
let D := E + F - C - j
let G := A + B - j
lowerCoefficient A B j * rawSummand (A - 1) (B - 1) C D (E - 1) (F - 1) G S +
centerCoefficient A B C E F j * rawSummand A B C D E F G S +
upperCoefficient C E F j * rawSummand (A + 1) (B + 1) C D (E + 1) (F + 1) G S
def sumLength (a b c d j l : ℤ) : ℕ := (a + b + c + d + j + l).toNat + 3
def totalResidual (a b c d j l : ℤ) : Scalar :=
let A := tetA a b c d j l
let B := tetB a b c d j l
∑ k ∈ Finset.range (sumLength a b c d j l),
rawResidual (A 0) (A 1) (A 2) (B 0) (B 1) j (k : ℤ)
def prefactor (a b c d j l : ℤ) : Scalar :=
(∏ i : Fin 4, ∏ k : Fin 3, ⟬tetB a b c d j l k - tetA a b c d j l i⟭!) /
(⟬a⟭! * ⟬b⟭! * ⟬c⟭! * ⟬d⟭! * ⟬j⟭! * ⟬l⟭!)
def clearingFactor (j : ℤ) : Scalar := ⟬2⟭ * ⟬j⟭ * ⟬j + 1⟭ * ⟬j + 2⟭
def mainResidual (a b c d j l : ℤ) : Scalar :=
Lm2 a b c d j * normalizedTetSum a b c d (j - 2) l +
(diagonalEntry a b c d j - Λ a b l * h a b c d j) * normalizedTetSum a b c d j l +
Lp2 a b c d j * normalizedTetSum a b c d (j + 2) l
end QuantumSixJ.Certificate
end