Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Jacobi cube bridge definitions: complex Euler cube, triangular theta sum and formal series

Definition
QseriesFormalization_Pending_JacobiCubeAnalyticToFormal

by FormallyCorrect · Oct 23, 2026 · Mathlib 0df444a (Lean v4.33.1)

chan-invitation-qseriesformal-power-seriespentagonal-numberstheta-functions

This bundle defines, for complex qqq, the totalized complex-valued function f(q)=(∏n≥1(1−qn))3f(q)=\big(\prod_{n\ge1}(1-q^n)\big)^3f(q)=(∏n≥1​(1−qn))3 and the triangular-exponent sum g(q)=∑n≥0(−1)n(2n+1)qn(n+1)/2g(q)=\sum_{n\ge0}(-1)^n(2n+1)q^{n(n+1)/2}g(q)=∑n≥0​(−1)n(2n+1)qn(n+1)/2. It also defines two formal multilinear series on C\mathbb{C}C built from scalar coefficient sequences, one with coefficients given by the Jacobi triple sign and one by the cube convolution of pentagonal signs. They serve to compare formal and analytic sides of Jacobi's identity (q;q)∞3=g(q)(q;q)_\infty^3=g(q)(q;q)∞3​=g(q).

The complex tsum and tprod have defaults 000 and 111 when their families are not summable or multipliable, respectively. The definitions are on all of C\mathbb CC; analyticity and the series identity are established on the unit disc by separate theorems.

Definition code
-- Generated by qseries-p2m/p2m/generate.py from QseriesFormalization.Pending.JacobiCubeAnalyticToFormal: skeleton subtraction
-- keeps 4 declaration(s); proofs kept; project imports -> Definitions bundles.
import Definitions.Def_QseriesFormalization_Chapter19_JacobiTripleSignChar
import Mathlib.Combinatorics.Enumerative.Partition.GenFun
import Mathlib.RingTheory.PowerSeries.Basic
import Mathlib.RingTheory.PowerSeries.Expand
import Mathlib.RingTheory.PowerSeries.Inverse
import Mathlib.Analysis.SpecificLimits.Normed
import Mathlib.Analysis.Normed.Ring.InfiniteSum
import Mathlib
import Mathlib.Combinatorics.Enumerative.Partition.Basic
import Mathlib.Tactic.Linarith
import Mathlib.Analysis.SpecialFunctions.Log.Summable
import Mathlib.Analysis.Normed.Group.Tannery

/-!
# Pending: B2 via analytic → formal Taylor bridge

Independent attack route on the cube convolution identity. Avoids
Sylvester's combinatorial bijection by leveraging the already-proved
**analytic** Jacobi cube identity from Chapter 4:

  `jacobiIdentity_pochhammer (q : ℂ) (hq : ‖q‖ < 1) :
       (eulerPentagonalInfiniteProduct q)^3
         = ∑' n : ℕ, ((-1)^n · (2n+1) · q^(n(n+1)/2))`

The plan: extract coefficient `n` from both sides via analytic Taylor
uniqueness, and identify both with the corresponding formal-PS coefficient.

## Roadmap

Let `f q := (eulerPentagonalInfiniteProduct q)^3` and
    `g q := ∑' n, (-1)^n (2n+1) q^{n(n+1)/2}`.
Both are analytic on `Metric.ball 0 1`, and equal there by
`jacobiIdentity_pochhammer`.

1. **Polynomial truncation agreement (analytic side).**  For `N > n`,
   `f q ≡ ((∏_{k=1}^N (1 - q^k))^3 : polynomial)  (mod q^{N+1})` near 0.
   *Reason*: the tail factors `∏_{k>N}(1 - q^k)` have constant coefficient
   1 and start at order > N, so they don't affect coefficients of degree
   ≤ N.

2. **Polynomial coefficient = formal-PS coefficient.**  For
   `P : ℂ[X]` and `n < deg(P)+1`, `P.coeff n` (polynomial) =
   `(P : ℂ⟦X⟧).coeff n` (formal PS) = analytic Taylor coefficient of
   `P.eval q` at `0`.

3. **Truncation = formal qPochInfPS truncation.**  Already proved as
   `coeff_qPochInfPS_pow_eq_coeff_finite_product_pow`.

4. **RHS Taylor extraction.**  The Taylor coefficient at `0` of `g`
   of order `n` equals `((jacobiTripleSign n : ℤ) : ℂ)` — by index
   unpacking and dominated convergence on the geometric tail.

5. **Combine via analytic uniqueness.**  `HasFPowerSeriesAt.eq_formal-
   MultilinearSeries_of_eventually` (Mathlib) gives that the formal
   multilinear series at 0 of `f` and `g` coincide, hence their
   coefficient functions agree.

Substantial Mathlib infrastructure (`HasFPowerSeriesAt`,
`AnalyticAt.taylor`, `Polynomial.hasFPowerSeries`) is involved. Each
step below is a cleanly-stated sorry; closing them is multi-day Lean
work but follows standard analytic patterns.

Once all five are closed, the headline goal in
`Pending/Chapter19_B2_FromCubeConvolution.lean` follows in two lines
(rewrite + ext, matched against this file's bridge theorems).
-/

namespace QseriesFormalization
namespace Pending
namespace JacobiCubeAnalyticToFormal

open QseriesFormalization.PartI.Ch04 (eulerPentagonalInfiniteProduct
  )
open QseriesFormalization.PartIV.Ch19 (qPochInfPS jacobiThetaPS jacobiTripleSign
   
  )

/-- **The analytic LHS function**: cube of the Euler pentagonal product. -/
noncomputable def fAnalytic (q : ℂ) : ℂ :=
  (eulerPentagonalInfiniteProduct q) ^ 3

/-- **The analytic RHS function**: triangular-exponent sum. -/
noncomputable def gAnalytic (q : ℂ) : ℂ :=
  ∑' n : ℕ, ((-1) ^ n * (2 * (n : ℂ) + 1) * q ^ (n * (n + 1) / 2))

/-! ### Step 1: polynomial truncation agreement

For each `n`, there exists `N` such that
  `fAnalytic q = ((∏_{k=0}^{N-1} (1 - q^(k+1)))^3) + (higher order tail)`
where the tail contributes 0 to the coefficient of `q^n` for `n < N`.

The right Lean machinery: `HasFPowerSeriesOnBall` + tail estimates.
-/

/- **Step 1.** The analytic Taylor coefficient at `0` of `fAnalytic` of
order `n` equals the polynomial coefficient at order `n` of the finite
truncation `(∏_{k=0}^{n}(1 - X^(k+1)))^3 ∈ ℂ[X]`.

Statement deferred until the Mathlib idiom is fixed (one of
`iteratedFDeriv`, `HasFPowerSeriesAt`, `Analytic.taylorCoeff`).  A
placeholder `True` here would violate the playbook (trivially-true
RHS), so we leave the precise statement out of the file and document
it here as the next concrete dependency. -/

/-! ### Step 2: polynomial coefficient = formal PS coefficient.

This direction is essentially `Polynomial.coe_powerSeries` plus
`Polynomial.coeff_coe` or `PowerSeries.coeff_polynomial`. Mathlib has
the natural ring hom `ℂ[X] →+* ℂ⟦X⟧` (`Polynomial.toPowerSeries`) and
it preserves coefficients.
-/

/-! ### Step 3: truncation = formal qPochInfPS truncation.

Already proved in `Chapter19.coeff_qPochInfPS_pow_eq_coeff_finite_product_pow`.
-/

/-! ### Step 4: RHS Taylor extraction. **CLOSED.**

The reindex `∑' k, jacobiTripleSign k · q^k = ∑' n, (-1)^n (2n+1) q^{T_n}`
is now proved unconditionally in `Chapter19_JacobiTripleSignChar` as
`tsum_jacobiTripleSign_eq_jacobi_series`. -/

/-! ### Step 5: combine via analytic uniqueness.

`Mathlib.Analysis.Analytic.Uniqueness.HasFPowerSeriesAt.eq_formalMultilinearSeries_of_eventually`
gives: if `f` and `g` are analytic at `0` with formal multilinear series
`p` and `q` respectively, and `f = g` eventually near `0`, then `p = q`.

Applied here: `fAnalytic` has formal series `ofScalars ℂ (jts ·)` on
`ball 0 1` (the `hasFPowerSeriesOnBall_fAnalytic` below); the formal-PS
`(qPochInfPS ℂ) ^ 3` is also an analytic-PS at 0 (via its coefficients
matching a polynomial truncation up to high order).  By the uniqueness
of formal multilinear series for an analytic function, the coefficient
sequences coincide. -/

/-- **The candidate formal multilinear series** for `fAnalytic` /
`jacobiThetaPS ℂ`: built from the scalar coefficient sequence
`fun n => (jacobiTripleSign n : ℂ)` using Mathlib's `.ofScalars`. -/
noncomputable def jacobiThetaSeries : FormalMultilinearSeries ℂ ℂ ℂ :=
  FormalMultilinearSeries.ofScalars ℂ (fun n => ((jacobiTripleSign n : ℤ) : ℂ))

/-- **The candidate formal series via `cubeConvolution`**: built using
`ofScalars` on `n ↦ (cubeConvolution n : ℂ)`. -/
noncomputable def cubeConvolutionSeries : FormalMultilinearSeries ℂ ℂ ℂ :=
  FormalMultilinearSeries.ofScalars ℂ
    (fun n => ((QseriesFormalization.PartIV.Ch19.cubeConvolution n : ℤ) : ℂ))

end JacobiCubeAnalyticToFormal
end Pending
end QseriesFormalization
Source
Lean formalization (Xiang Huang) of Hei-Chi Chan, An Invitation to q-Series: From Jacobi's Triple Product Identity to Ramanujan's "Most Beautiful Identity" (World Scientific, 2011). Lean source: https://github.com/xiangyazi24/invitation-to-qseries-lean/blob/5df34b280b6a9c4a68ab09105b4e5d3c7bbe88d1/QseriesFormalization/Pending/JacobiCubeAnalyticToFormal.lean (definitions of this module that the uploaded theorems need; ported to Lean v4.33.1 / Mathlib 0df444a).

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me