AFTD Auto-Formalizing Theoretical Domains

wild_triple_partition_term_antitone_odd_step

theoremverified

For every odd q>=3 and admissible fixed cut size h>=1 with2*h<=q, the canonical triple-partition resource term wtc_term(q,h) weakly decreases when q is replaced by q+2.

Statement

theorem wild_triple_partition_term_antitone_odd_step
    (q h : ℕ) (hq : 3 ≤ q) (hodd : q%2 = 1)
    (hh : 1 ≤ h) (hhq : 2*h ≤ q) :
    wtc_term (q+2) h ≤ wtc_term q h
Source
IN-359 new technical route for OP-306: algebraic continuation of the existing sufficient permutation resource bound. Exact rational audits8964/8965 verify the proposed step ratios on finite inputs, not a uniform theorem. Proof is still required; no wild-number bound or research advance is claimed.
Verified
29 Oct 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 1
Used by 1

The proof, explained

The proof shows that wtc_term(q+2, h) ≤ wtc_term(q, h) for odd q = 2t+1 by case analysis on the parity of the cut size h. Increasing q by 2 shifts the three binomial coefficients appearing in wtc_term by 2, 3, and 6 steps, respectively. The helper lemma wtc_step_pack reduces the ratio comparison to a single degree-11 polynomial inequality on the shift factors. In both the even and odd parity cases, algebraic identities (wtc_step_poly_even and wtc_step_poly_odd) cancel the bulk of the factors, reducing the comparison to a product of positive linear factors.

  1. For k ≤ n, the binomial coefficient n.choose k is strictly positive in ℝ.

    By Nat.choose_pos, the natural binomial coefficient is positive, and casting to ℝ preserves positivity.

    lines 1–3

    uses Nat.choose_pos

    private lemma wtc_step_choose_pos (n k : ℕ) (h : k ≤ n) : (0:ℝ) < ((n.choose k : ℕ) : ℝ) := by
      have := Nat.choose_pos h
      exact_mod_cast this
  2. The natural binomial coefficient shifts by 2: (n+2).choose k * (n+1-k) * (n+2-k) = n.choose k * (n+1) * (n+2).

    Applying Nat.choose_mul_succ_eq twice (at n+1 and n) and rearranging factors via ring equality yields the two-step shift formula.

    lines 5–13

    uses Nat.choose_mul_succ_eq

    private lemma wtc_step_choose_two (n k : ℕ) :
        (n+2).choose k * (n+1-k) * (n+2-k) = n.choose k * (n+1) * (n+2) := by
      have h1 : (n+2).choose k * (n+2-k) = (n+1).choose k * (n+2) := (Nat.choose_mul_succ_eq (n+1) k).symm
      have h0 : (n+1).choose k * (n+1-k) = n.choose k * (n+1) := (Nat.choose_mul_succ_eq n k).symm
      calc (n+2).choose k * (n+1-k) * (n+2-k)
          = (n+2).choose k * (n+2-k) * (n+1-k) := by ring
        _ = (n+1).choose k * (n+2) * (n+1-k) := by rw [h1]
        _ = (n+1).choose k * (n+1-k) * (n+2) := by ring
        _ = n.choose k * (n+1) * (n+2) := by rw [h0]
  3. The natural binomial coefficient shifts by 3: (n+3).choose k * (n+1-k) * (n+2-k) * (n+3-k) = n.choose k * (n+1) * (n+2) * (n+3).

    Combine the two-step shift wtc_step_choose_two at n+1 with a single shift Nat.choose_mul_succ_eq at n.

    lines 15–24

    uses Nat.choose_mul_succ_eq, wtc_step_choose_two

    private lemma wtc_step_choose_three (n k : ℕ) :
        (n+3).choose k * (n+1-k) * (n+2-k) * (n+3-k) = n.choose k * (n+1) * (n+2) * (n+3) := by
      have h2 : (n+1).choose k * (n+1-k) = n.choose k * (n+1) := (Nat.choose_mul_succ_eq n k).symm
      have h := wtc_step_choose_two (n+1) k
      calc (n+3).choose k * (n+1-k) * (n+2-k) * (n+3-k)
          = ((n+3).choose k * (n+2-k) * (n+3-k)) * (n+1-k) := by ring
        _ = ((n+1).choose k * (n+2) * (n+3)) * (n+1-k) := by rw [h]
        _ = ((n+1).choose k * (n+1-k)) * (n+2) * (n+3) := by ring
        _ = (n.choose k * (n+1)) * (n+2) * (n+3) := by rw [h2]
        _ = n.choose k * (n+1) * (n+2) * (n+3) := by ring
  4. The natural binomial coefficient shifts by 6: (n+6).choose k times 6 downward factors equals n.choose k times 6 upward factors.

    Combine two applications of the 3-step shift wtc_step_choose_three, evaluated at n+3 and at n.

    lines 26–36

    uses wtc_step_choose_three

    private lemma wtc_step_choose_six (n k : ℕ) :
        (n+6).choose k * (n+1-k) * (n+2-k) * (n+3-k) * (n+4-k) * (n+5-k) * (n+6-k)
          = n.choose k * (n+1) * (n+2) * (n+3) * (n+4) * (n+5) * (n+6) := by
      have h := wtc_step_choose_three (n+3) k
      have h2 := wtc_step_choose_three n k
      calc (n+6).choose k * (n+1-k) * (n+2-k) * (n+3-k) * (n+4-k) * (n+5-k) * (n+6-k)
          = ((n+6).choose k * (n+4-k) * (n+5-k) * (n+6-k)) * ((n+1-k)*(n+2-k)*(n+3-k)) := by ring
        _ = ((n+3).choose k * (n+4) * (n+5) * (n+6)) * ((n+1-k)*(n+2-k)*(n+3-k)) := by rw [h]
        _ = ((n+3).choose k * (n+1-k) * (n+2-k) * (n+3-k)) * (n+4) * (n+5) * (n+6) := by ring
        _ = (n.choose k * (n+1) * (n+2) * (n+3)) * (n+4) * (n+5) * (n+6) := by rw [h2]
        _ = n.choose k * (n+1) * (n+2) * (n+3) * (n+4) * (n+5) * (n+6) := by ring
  5. The shift-by-2 identity holds over ℝ when k ≤ n.

    Cast wtc_step_choose_two to ℝ using congrArg, distribute the cast over subtractions using Nat.cast_sub since k ≤ n, and simplify with linear arithmetic.

    lines 38–48

    uses congrArg, wtc_step_choose_two, Nat.cast_sub

    private lemma wtc_step_cross_two (n k : ℕ) (hk : k ≤ n) :
        ((n+2).choose k : ℝ) * (((n:ℝ)+1-(k:ℝ)) * ((n:ℝ)+2-(k:ℝ)))
          = ((n).choose k : ℝ) * (((n:ℝ)+1) * ((n:ℝ)+2)) := by
      have h := congrArg (fun x : ℕ => (x:ℝ)) (wtc_step_choose_two n k)
      have e1 : (((n+1-k:ℕ)):ℝ) = (n:ℝ)+1-(k:ℝ) := by
        rw [Nat.cast_sub (by omega : k ≤ n+1)]; push_cast; ring
      have e2 : (((n+2-k:ℕ)):ℝ) = (n:ℝ)+2-(k:ℝ) := by
        rw [Nat.cast_sub (by omega : k ≤ n+2)]; push_cast; ring
      push_cast at h
      rw [e1, e2] at h
      linarith [h]
  6. The shift-by-3 identity holds over ℝ when k ≤ n.

    Cast wtc_step_choose_three to ℝ using congrArg, distribute the cast over the three subtractions via Nat.cast_sub, and conclude by linear arithmetic.

    lines 50–62

    uses congrArg, wtc_step_choose_three, Nat.cast_sub

    private lemma wtc_step_cross_three (n k : ℕ) (hk : k ≤ n) :
        ((n+3).choose k : ℝ) * (((n:ℝ)+1-(k:ℝ)) * ((n:ℝ)+2-(k:ℝ)) * ((n:ℝ)+3-(k:ℝ)))
          = ((n).choose k : ℝ) * (((n:ℝ)+1) * ((n:ℝ)+2) * ((n:ℝ)+3)) := by
      have h := congrArg (fun x : ℕ => (x:ℝ)) (wtc_step_choose_three n k)
      have e1 : (((n+1-k:ℕ)):ℝ) = (n:ℝ)+1-(k:ℝ) := by
        rw [Nat.cast_sub (by omega : k ≤ n+1)]; push_cast; ring
      have e2 : (((n+2-k:ℕ)):ℝ) = (n:ℝ)+2-(k:ℝ) := by
        rw [Nat.cast_sub (by omega : k ≤ n+2)]; push_cast; ring
      have e3 : (((n+3-k:ℕ)):ℝ) = (n:ℝ)+3-(k:ℝ) := by
        rw [Nat.cast_sub (by omega : k ≤ n+3)]; push_cast; ring
      push_cast at h
      rw [e1, e2, e3] at h
      linarith [h]
  7. The shift-by-6 identity holds over ℝ when k ≤ n.

    Cast wtc_step_choose_six to ℝ using congrArg, distribute the cast across the six subtractions via Nat.cast_sub, and conclude with linear arithmetic.

    lines 64–83

    uses congrArg, wtc_step_choose_six, Nat.cast_sub

    private lemma wtc_step_cross_six (n k : ℕ) (hk : k ≤ n) :
        ((n+6).choose k : ℝ) * (((n:ℝ)+1-(k:ℝ)) * ((n:ℝ)+2-(k:ℝ)) * ((n:ℝ)+3-(k:ℝ))
          * ((n:ℝ)+4-(k:ℝ)) * ((n:ℝ)+5-(k:ℝ)) * ((n:ℝ)+6-(k:ℝ)))
          = ((n).choose k : ℝ) * (((n:ℝ)+1) * ((n:ℝ)+2) * ((n:ℝ)+3) * ((n:ℝ)+4) * ((n:ℝ)+5) * ((n:ℝ)+6)) := by
      have h := congrArg (fun x : ℕ => (x:ℝ)) (wtc_step_choose_six n k)
      have e1 : (((n+1-k:ℕ)):ℝ) = (n:ℝ)+1-(k:ℝ) := by
        rw [Nat.cast_sub (by omega : k ≤ n+1)]; push_cast; ring
      have e2 : (((n+2-k:ℕ)):ℝ) = (n:ℝ)+2-(k:ℝ) := by
        rw [Nat.cast_sub (by omega : k ≤ n+2)]; push_cast; ring
      have e3 : (((n+3-k:ℕ)):ℝ) = (n:ℝ)+3-(k:ℝ) := by
        rw [Nat.cast_sub (by omega : k ≤ n+3)]; push_cast; ring
      have e4 : (((n+4-k:ℕ)):ℝ) = (n:ℝ)+4-(k:ℝ) := by
        rw [Nat.cast_sub (by omega : k ≤ n+4)]; push_cast; ring
      have e5 : (((n+5-k:ℕ)):ℝ) = (n:ℝ)+5-(k:ℝ) := by
        rw [Nat.cast_sub (by omega : k ≤ n+5)]; push_cast; ring
      have e6 : (((n+6-k:ℕ)):ℝ) = (n:ℝ)+6-(k:ℝ) := by
        rw [Nat.cast_sub (by omega : k ≤ n+6)]; push_cast; ring
      push_cast at h
      rw [e1, e2, e3, e4, e5, e6] at h
      linarith [h]
  8. If A2*P1 = A*Q1, B2*P2 = B*Q2, D2*P3 = D*Q3 and Q1*Q2*P3 ≤ P1*P2*Q3 with positive terms, then x*(A2*B2/D2) ≤ x*(A*B/D) for x ≥ 0.

    Multiplying the equations gives A2*B2*D*(P1*P2*Q3) = A*B*D2*(Q1*Q2*P3). Applying the assumed inequality on Q1*Q2*P3 and canceling the positive product P1*P2*Q3 shows A2*B2*D ≤ A*B*D2. Dividing by positive denominators D2 and D via div_le_div_iff₀ and scaling by x ≥ 0 completes the proof.

    lines 85–103

    uses mul_le_mul_of_nonneg_left, le_of_mul_le_mul_right, div_le_div_iff₀

    private lemma wtc_step_pack (x A A2 B B2 D D2 P1 Q1 P2 Q2 P3 Q3 : ℝ)
        (hx : 0 ≤ x) (hA : 0 < A) (hB : 0 < B) (hD : 0 < D) (hD2 : 0 < D2)
        (hP1 : 0 < P1) (hQ3 : 0 < Q3) (hP2 : 0 < P2)
        (hAA : A2 * P1 = A * Q1) (hBB : B2 * P2 = B * Q2) (hDD : D2 * P3 = D * Q3)
        (hQle : Q1 * Q2 * P3 ≤ P1 * P2 * Q3) :
        x * (A2 * B2 / D2) ≤ x * (A * B / D) := by
      have hprod : A2 * B2 * D * (P1*P2*Q3) = A * B * D2 * (Q1*Q2*P3) := by
        calc A2 * B2 * D * (P1*P2*Q3) = (A2*P1)*(B2*P2)*(D*Q3) := by ring
          _ = (A*Q1)*(B*Q2)*(D2*P3) := by rw [hAA, hBB, hDD]
          _ = A * B * D2 * (Q1*Q2*P3) := by ring
      have hpos : 0 < P1*P2*Q3 := by positivity
      have hle : A2 * B2 * D * (P1*P2*Q3) ≤ A * B * D2 * (P1*P2*Q3) := by
        rw [hprod]
        exact mul_le_mul_of_nonneg_left hQle (by positivity)
      have hm : A2 * B2 * D ≤ A * B * D2 := le_of_mul_le_mul_right hle hpos
      have hdiv : A2*B2/D2 ≤ A*B/D := by
        rw [div_le_div_iff₀ hD2 hD]
        linarith [hm]
      exact mul_le_mul_of_nonneg_left hdiv hx
  9. The shift factor inequality Q1*Q2*P3 ≤ P1*P2*Q3 holds for even cut sizes h = 2s with 4s ≤ 2t+1.

    Multiplying both sides by the strictly positive factor hDEN = (6t+6-6s)(6t+5)(6t+7) reduces the 11th-degree polynomial inequality to the identity hid: almost all factors cancel, leaving the 3-factor inequality hNUM. Nonlinear arithmetic closes hNUM, and canceling hDEN yields the claim.

    lines 105–145

    uses mul_pos, mul_nonneg, mul_le_mul_of_nonneg_left, le_of_mul_le_mul_right

    private lemma wtc_step_poly_even (t s : ℝ) (ht : 1 ≤ t) (hs : 0 ≤ s) (hcon : 4*s ≤ 2*t+1) :
        (2*t+2)*(2*t+3) * ((3*t+2)*(3*t+3)*(3*t+4)) *
          ((6*t+4-6*s)*(6*t+5-6*s)*(6*t+6-6*s)*(6*t+7-6*s)*(6*t+8-6*s)*(6*t+9-6*s))
        ≤ (2*t+2-2*s)*(2*t+3-2*s) * ((3*t+2-3*s)*(3*t+3-3*s)*(3*t+4-3*s)) *
          ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)) := by
      have hDEN : 0 < (6*t+6-6*s)*(6*t+5)*(6*t+7) := by
        have h1 : (0:ℝ) < 6*t+6-6*s := by nlinarith
        have h2 : (0:ℝ) < 6*t+5 := by linarith
        have h3 : (0:ℝ) < 6*t+7 := by linarith
        exact mul_pos (mul_pos h1 h2) h3
      have hNUM : (6*t+6)*(6*t+5-6*s)*(6*t+7-6*s) ≤ (6*t+6-6*s)*(6*t+5)*(6*t+7) := by
        nlinarith [mul_nonneg (mul_nonneg (by linarith : (0:ℝ) ≤ 6*t+6) (by linarith : (0:ℝ) ≤ 6*t+6-6*s)) (by norm_num : (0:ℝ) ≤ 1)]
      have hid : ((2*t+2)*(2*t+3) * ((3*t+2)*(3*t+3)*(3*t+4)) *
          ((6*t+4-6*s)*(6*t+5-6*s)*(6*t+6-6*s)*(6*t+7-6*s)*(6*t+8-6*s)*(6*t+9-6*s)))
          * ((6*t+6-6*s)*(6*t+5)*(6*t+7))
        = ((2*t+2-2*s)*(2*t+3-2*s) * ((3*t+2-3*s)*(3*t+3-3*s)*(3*t+4-3*s)) *
          ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)))
          * ((6*t+6)*(6*t+5-6*s)*(6*t+7-6*s)) := by ring
      have hR : 0 ≤ (2*t+2-2*s)*(2*t+3-2*s) * ((3*t+2-3*s)*(3*t+3-3*s)*(3*t+4-3*s)) *
          ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)) := by
        have h1 : (0:ℝ) < 2*t+2-2*s := by nlinarith
        have h2 : (0:ℝ) < 2*t+3-2*s := by nlinarith
        have h3 : (0:ℝ) < 3*t+2-3*s := by nlinarith
        have h4 : (0:ℝ) < 3*t+3-3*s := by nlinarith
        have h5 : (0:ℝ) < 3*t+4-3*s := by nlinarith
        have g1 : (0:ℝ) < 6*t+4 := by linarith
        have g2 : (0:ℝ) < 6*t+5 := by linarith
        have g3 : (0:ℝ) < 6*t+6 := by linarith
        have g4 : (0:ℝ) < 6*t+7 := by linarith
        have g5 : (0:ℝ) < 6*t+8 := by linarith
        have g6 : (0:ℝ) < 6*t+9 := by linarith
        positivity
      have hstep : ((2*t+2)*(2*t+3) * ((3*t+2)*(3*t+3)*(3*t+4)) *
          ((6*t+4-6*s)*(6*t+5-6*s)*(6*t+6-6*s)*(6*t+7-6*s)*(6*t+8-6*s)*(6*t+9-6*s)))
          * ((6*t+6-6*s)*(6*t+5)*(6*t+7))
          ≤ ((2*t+2-2*s)*(2*t+3-2*s) * ((3*t+2-3*s)*(3*t+3-3*s)*(3*t+4-3*s)) *
          ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)))
          * ((6*t+6-6*s)*(6*t+5)*(6*t+7)) := by
        rw [hid]
        exact mul_le_mul_of_nonneg_left hNUM hR
      exact le_of_mul_le_mul_right hstep hDEN
  10. The shift factor inequality Q1*Q2*P3 ≤ P1*P2*Q3 holds for odd cut sizes h = 2s+1 with 4s+2 ≤ 2t+1.

    Similarly to the even case, multiplying both sides by hDEN = (6t+5)(6t+7)(6t+6-6s) reduces the inequality via the cancellation identity hid to the 3-factor comparison hNUM, which holds by nonlinear arithmetic. Canceling hDEN yields the claim.

    lines 147–188

    uses mul_pos, mul_nonneg, mul_le_mul_of_nonneg_left, le_of_mul_le_mul_right

    private lemma wtc_step_poly_odd (t s : ℝ) (ht : 1 ≤ t) (hs : 0 ≤ s) (hcon : 4*s+2 ≤ 2*t+1) :
        (2*t+2)*(2*t+3) * ((3*t+2)*(3*t+3)*(3*t+4)) *
          ((6*t+1-6*s)*(6*t+2-6*s)*(6*t+3-6*s)*(6*t+4-6*s)*(6*t+5-6*s)*(6*t+6-6*s))
        ≤ (2*t+1-2*s)*(2*t+2-2*s) * ((3*t+1-3*s)*(3*t+2-3*s)*(3*t+3-3*s)) *
          ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)) := by
      have hDEN : 0 < (6*t+5)*(6*t+7)*(6*t+6-6*s) := by
        have h1 : (0:ℝ) < 6*t+6-6*s := by nlinarith
        have h2 : (0:ℝ) < 6*t+5 := by linarith
        have h3 : (0:ℝ) < 6*t+7 := by linarith
        exact mul_pos (mul_pos h2 h3) h1
      have hNUM : (6*t+6)*(6*t+1-6*s)*(6*t+5-6*s) ≤ (6*t+5)*(6*t+7)*(6*t+6-6*s) := by
        nlinarith [mul_nonneg (mul_nonneg (by linarith : (0:ℝ) ≤ 6*t+6) (by linarith : (0:ℝ) ≤ 6*t+1-6*s)) (by linarith : (0:ℝ) ≤ 6*t+5-6*s),
                   mul_nonneg (by linarith : (0:ℝ) ≤ 2*s+1) (mul_nonneg (by linarith : (0:ℝ) ≤ 6*t+6) (by linarith : (0:ℝ) ≤ 6*t+3-6*s))]
      have hid : ((2*t+2)*(2*t+3) * ((3*t+2)*(3*t+3)*(3*t+4)) *
          ((6*t+1-6*s)*(6*t+2-6*s)*(6*t+3-6*s)*(6*t+4-6*s)*(6*t+5-6*s)*(6*t+6-6*s)))
          * ((6*t+5)*(6*t+7)*(6*t+6-6*s))
        = ((2*t+1-2*s)*(2*t+2-2*s) * ((3*t+1-3*s)*(3*t+2-3*s)*(3*t+3-3*s)) *
          ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)))
          * ((6*t+6)*(6*t+1-6*s)*(6*t+5-6*s)) := by ring
      have hR : 0 ≤ (2*t+1-2*s)*(2*t+2-2*s) * ((3*t+1-3*s)*(3*t+2-3*s)*(3*t+3-3*s)) *
          ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)) := by
        have h1 : (0:ℝ) < 2*t+1-2*s := by nlinarith
        have h2 : (0:ℝ) < 2*t+2-2*s := by nlinarith
        have h3 : (0:ℝ) < 3*t+1-3*s := by nlinarith
        have h4 : (0:ℝ) < 3*t+2-3*s := by nlinarith
        have h5 : (0:ℝ) < 3*t+3-3*s := by nlinarith
        have g1 : (0:ℝ) < 6*t+4 := by linarith
        have g2 : (0:ℝ) < 6*t+5 := by linarith
        have g3 : (0:ℝ) < 6*t+6 := by linarith
        have g4 : (0:ℝ) < 6*t+7 := by linarith
        have g5 : (0:ℝ) < 6*t+8 := by linarith
        have g6 : (0:ℝ) < 6*t+9 := by linarith
        positivity
      have hstep : ((2*t+2)*(2*t+3) * ((3*t+2)*(3*t+3)*(3*t+4)) *
          ((6*t+1-6*s)*(6*t+2-6*s)*(6*t+3-6*s)*(6*t+4-6*s)*(6*t+5-6*s)*(6*t+6-6*s)))
          * ((6*t+5)*(6*t+7)*(6*t+6-6*s))
          ≤ ((2*t+1-2*s)*(2*t+2-2*s) * ((3*t+1-3*s)*(3*t+2-3*s)*(3*t+3-3*s)) *
          ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)))
          * ((6*t+5)*(6*t+7)*(6*t+6-6*s)) := by
        rw [hid]
        exact mul_le_mul_of_nonneg_left hNUM hR
      exact le_of_mul_le_mul_right hstep hDEN
  11. Express the odd integer q as 2t+1 with t ≥ 1 and split into cases according to whether h is even or odd.

    Since q is odd and at least 3, q can be written as 2t+1 with t ≥ 1. The parity of h is split into h % 2 = 0 and h % 2 = 1 using Nat.mod_two_eq_zero_or_one.

    lines 190–201

    uses Nat.odd_iff.mpr, Nat.mod_two_eq_zero_or_one

    theorem wild_triple_partition_term_antitone_odd_step
        (q h : ℕ) (hq : 3 ≤ q) (hodd : q%2 = 1)
        (hh : 1 ≤ h) (hhq : 2*h ≤ q) :
        wtc_term (q+2) h ≤ wtc_term q h := by
      obtain ⟨t, ht⟩ : ∃ t, q = 2*t+1 := by
        have ho : Odd q := Nat.odd_iff.mpr hodd
        obtain ⟨t, ht⟩ := ho
        exact ⟨t, by omega⟩
      subst ht
      have ht1 : 1 ≤ t := by omega
      have htR : (1:ℝ) ≤ (t:ℝ) := by exact_mod_cast ht1
      rcases Nat.mod_two_eq_zero_or_one h with hh2 | hh2
  12. In the even cut size case h = 2s, simplify wtc_term and establish shift relations for the three binomial coefficients.

    Writing h = 2s, simplifying integer divisions evaluates the arguments of the binomial coefficients. The real shift identities wtc_step_cross_two, wtc_step_cross_three, and wtc_step_cross_six are applied to establish hAA, hBB, and hDD.

    lines 202–246

    uses Nat.even_iff.mpr, wtc_term, wtc_step_cross_two, wtc_step_cross_three, wtc_step_cross_six

      · obtain ⟨s, hs⟩ : ∃ s, h = 2*s := by
          have := Nat.even_iff.mpr hh2
          obtain ⟨s, hs⟩ := this
          exact ⟨s, by omega⟩
        subst hs
        have hsle : 4*s ≤ 2*t+1 := by omega
        have hsleR : 4*(s:ℝ) ≤ 2*(t:ℝ)+1 := by exact_mod_cast hsle
        simp only [wtc_term,
          show 3*(2*t+1+2) = 6*t+9 from by omega,
          show (6*t+9)/2 = 3*t+4 from by omega,
          show 3*(2*t+1) = 6*t+3 from by omega,
          show (6*t+3)/2 = 3*t+1 from by omega,
          show 3*(2*s) = 6*s from by omega, show (6*s)/2 = 3*s from by omega]
        have hAA : ((2*t+3).choose (2*s) : ℝ) * ((2*(t:ℝ)+2-2*(s:ℝ))*(2*(t:ℝ)+3-2*(s:ℝ)))
            = ((2*t+1).choose (2*s) : ℝ) * ((2*(t:ℝ)+2)*(2*(t:ℝ)+3)) := by
          have h := wtc_step_cross_two (2*t+1) (2*s) (by omega)
          rw [show 2*t+1+2 = 2*t+3 from by omega] at h
          have e : ((↑(2*t+1):ℝ)+1-↑(2*s)) * ((↑(2*t+1):ℝ)+2-↑(2*s))
              = (2*(t:ℝ)+2-2*(s:ℝ))*(2*(t:ℝ)+3-2*(s:ℝ)) := by push_cast; ring
          have e2 : ((↑(2*t+1):ℝ)+1) * ((↑(2*t+1):ℝ)+2) = (2*(t:ℝ)+2)*(2*(t:ℝ)+3) := by push_cast; ring
          rw [e, e2] at h
          exact h
        have hBB : ((3*t+4).choose (3*s) : ℝ) *
            ((3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ))*(3*(t:ℝ)+4-3*(s:ℝ)))
            = ((3*t+1).choose (3*s) : ℝ) * ((3*(t:ℝ)+2)*(3*(t:ℝ)+3)*(3*(t:ℝ)+4)) := by
          have h := wtc_step_cross_three (3*t+1) (3*s) (by omega)
          rw [show 3*t+1+3 = 3*t+4 from by omega] at h
          have e : ((↑(3*t+1):ℝ)+1-↑(3*s)) * ((↑(3*t+1):ℝ)+2-↑(3*s)) * ((↑(3*t+1):ℝ)+3-↑(3*s))
              = (3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ))*(3*(t:ℝ)+4-3*(s:ℝ)) := by push_cast; ring
          have e2 : ((↑(3*t+1):ℝ)+1) * ((↑(3*t+1):ℝ)+2) * ((↑(3*t+1):ℝ)+3)
              = (3*(t:ℝ)+2)*(3*(t:ℝ)+3)*(3*(t:ℝ)+4) := by push_cast; ring
          rw [e, e2] at h
          exact h
        have hDD : ((6*t+9).choose (6*s) : ℝ) *
            ((6*(t:ℝ)+4-6*(s:ℝ))*(6*(t:ℝ)+5-6*(s:ℝ))*(6*(t:ℝ)+6-6*(s:ℝ))*(6*(t:ℝ)+7-6*(s:ℝ))*(6*(t:ℝ)+8-6*(s:ℝ))*(6*(t:ℝ)+9-6*(s:ℝ)))
            = ((6*t+3).choose (6*s) : ℝ) * ((6*(t:ℝ)+4)*(6*(t:ℝ)+5)*(6*(t:ℝ)+6)*(6*(t:ℝ)+7)*(6*(t:ℝ)+8)*(6*(t:ℝ)+9)) := by
          have h := wtc_step_cross_six (6*t+3) (6*s) (by omega)
          rw [show 6*t+3+6 = 6*t+9 from by omega] at h
          have e : ((↑(6*t+3):ℝ)+1-↑(6*s)) * ((↑(6*t+3):ℝ)+2-↑(6*s)) * ((↑(6*t+3):ℝ)+3-↑(6*s))
                  * ((↑(6*t+3):ℝ)+4-↑(6*s)) * ((↑(6*t+3):ℝ)+5-↑(6*s)) * ((↑(6*t+3):ℝ)+6-↑(6*s))
              = (6*(t:ℝ)+4-6*(s:ℝ))*(6*(t:ℝ)+5-6*(s:ℝ))*(6*(t:ℝ)+6-6*(s:ℝ))*(6*(t:ℝ)+7-6*(s:ℝ))*(6*(t:ℝ)+8-6*(s:ℝ))*(6*(t:ℝ)+9-6*(s:ℝ)) := by push_cast; ring
          have e2 : ((↑(6*t+3):ℝ)+1) * ((↑(6*t+3):ℝ)+2) * ((↑(6*t+3):ℝ)+3) * ((↑(6*t+3):ℝ)+4) * ((↑(6*t+3):ℝ)+5) * ((↑(6*t+3):ℝ)+6)
              = (6*(t:ℝ)+4)*(6*(t:ℝ)+5)*(6*(t:ℝ)+6)*(6*(t:ℝ)+7)*(6*(t:ℝ)+8)*(6*(t:ℝ)+9) := by push_cast; ring
          rw [e, e2] at h
          exact h
  13. Conclude wtc_term(q+2, h) ≤ wtc_term(q, h) when h is even.

    Apply the polynomial inequality wtc_step_poly_even to obtain hQle, verify positivity of all binomial and shift factors, apply wtc_step_pack to bound the rational factor, and multiply by the nonnegative common factor (21/20)^(6s).

    lines 247–279

    uses wtc_step_poly_even, wtc_step_pack, wtc_step_choose_pos, mul_le_mul_of_nonneg_right

        have hQle := wtc_step_poly_even (t:ℝ) (s:ℝ) htR (by positivity) hsleR
        have hP1 : (0:ℝ) < (2*(t:ℝ)+2-2*(s:ℝ))*(2*(t:ℝ)+3-2*(s:ℝ)) := by
          have a : (0:ℝ) < 2*(t:ℝ)+2-2*(s:ℝ) := by nlinarith
          have b : (0:ℝ) < 2*(t:ℝ)+3-2*(s:ℝ) := by nlinarith
          positivity
        have hP2 : (0:ℝ) < (3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ))*(3*(t:ℝ)+4-3*(s:ℝ)) := by
          have a : (0:ℝ) < 3*(t:ℝ)+2-3*(s:ℝ) := by nlinarith
          have b : (0:ℝ) < 3*(t:ℝ)+3-3*(s:ℝ) := by nlinarith
          have c : (0:ℝ) < 3*(t:ℝ)+4-3*(s:ℝ) := by nlinarith
          positivity
        have haux := wtc_step_pack (x := 3*↑(2*s))
          (A := ((2*t+1).choose (2*s) : ℝ)) (A2 := ((2*t+3).choose (2*s) : ℝ))
          (B := ((3*t+1).choose (3*s) : ℝ)) (B2 := ((3*t+4).choose (3*s) : ℝ))
          (D := ((6*t+3).choose (6*s) : ℝ)) (D2 := ((6*t+9).choose (6*s) : ℝ))
          (P1 := (2*(t:ℝ)+2-2*(s:ℝ))*(2*(t:ℝ)+3-2*(s:ℝ)))
          (Q1 := (2*(t:ℝ)+2)*(2*(t:ℝ)+3))
          (P2 := (3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ))*(3*(t:ℝ)+4-3*(s:ℝ)))
          (Q2 := (3*(t:ℝ)+2)*(3*(t:ℝ)+3)*(3*(t:ℝ)+4))
          (P3 := (6*(t:ℝ)+4-6*(s:ℝ))*(6*(t:ℝ)+5-6*(s:ℝ))*(6*(t:ℝ)+6-6*(s:ℝ))*(6*(t:ℝ)+7-6*(s:ℝ))*(6*(t:ℝ)+8-6*(s:ℝ))*(6*(t:ℝ)+9-6*(s:ℝ)))
          (Q3 := (6*(t:ℝ)+4)*(6*(t:ℝ)+5)*(6*(t:ℝ)+6)*(6*(t:ℝ)+7)*(6*(t:ℝ)+8)*(6*(t:ℝ)+9))
          (by positivity)
          (wtc_step_choose_pos (2*t+1) (2*s) (by omega))
          (wtc_step_choose_pos (3*t+1) (3*s) (by omega))
          (wtc_step_choose_pos (6*t+3) (6*s) (by omega))
          (wtc_step_choose_pos (6*t+9) (6*s) (by omega))
          hP1 (by positivity) hP2
          hAA hBB hDD hQle
        have h1 : 3*↑(2*s) * ↑((2*t+3).choose (2*s)) * ↑((3*t+4).choose (3*s)) / ↑((6*t+9).choose (6*s))
            = (3*↑(2*s)) * ((((2*t+3).choose (2*s) : ℝ)) * (((3*t+4).choose (3*s) : ℝ)) / (((6*t+9).choose (6*s) : ℝ))) := by ring
        have h2 : 3*↑(2*s) * ↑((2*t+1).choose (2*s)) * ↑((3*t+1).choose (3*s)) / ↑((6*t+3).choose (6*s))
            = (3*↑(2*s)) * ((((2*t+1).choose (2*s) : ℝ)) * (((3*t+1).choose (3*s) : ℝ)) / (((6*t+3).choose (6*s) : ℝ))) := by ring
        rw [h1, h2]
        exact mul_le_mul_of_nonneg_right haux (by positivity)
  14. In the odd cut size case h = 2s+1, simplify wtc_term and establish shift relations for the three binomial coefficients.

    Writing h = 2s+1, integer divisions in wtc_term simplify to explicit linear functions in t and s. The shift lemmas wtc_step_cross_two, wtc_step_cross_three, and wtc_step_cross_six establish the shift relations hAA, hBB, and hDD over ℝ.

    lines 280–326

    uses Nat.odd_iff.mpr, wtc_term, wtc_step_cross_two, wtc_step_cross_three, wtc_step_cross_six

      · obtain ⟨s, hs⟩ : ∃ s, h = 2*s+1 := by
          have := Nat.odd_iff.mpr hh2
          obtain ⟨s, hs⟩ := this
          exact ⟨s, by omega⟩
        subst hs
        have hsle : 2*(2*s+1) ≤ 2*t+1 := by omega
        have hsleR : 4*(s:ℝ)+2 ≤ 2*(t:ℝ)+1 := by
          have hh : (2*(2*s+1) : ℝ) ≤ (2*t+1 : ℝ) := by exact_mod_cast hsle
          push_cast at hh; linarith
        simp only [wtc_term,
          show 3*(2*t+1+2) = 6*t+9 from by omega,
          show (6*t+9)/2 = 3*t+4 from by omega,
          show 3*(2*t+1) = 6*t+3 from by omega,
          show (6*t+3)/2 = 3*t+1 from by omega,
          show 3*(2*s+1) = 6*s+3 from by omega, show (6*s+3)/2 = 3*s+1 from by omega]
        have hAA : ((2*t+3).choose (2*s+1) : ℝ) * ((2*(t:ℝ)+1-2*(s:ℝ))*(2*(t:ℝ)+2-2*(s:ℝ)))
            = ((2*t+1).choose (2*s+1) : ℝ) * ((2*(t:ℝ)+2)*(2*(t:ℝ)+3)) := by
          have h := wtc_step_cross_two (2*t+1) (2*s+1) (by omega)
          rw [show 2*t+1+2 = 2*t+3 from by omega] at h
          have e : ((↑(2*t+1):ℝ)+1-↑(2*s+1)) * ((↑(2*t+1):ℝ)+2-↑(2*s+1))
              = (2*(t:ℝ)+1-2*(s:ℝ))*(2*(t:ℝ)+2-2*(s:ℝ)) := by push_cast; ring
          have e2 : ((↑(2*t+1):ℝ)+1) * ((↑(2*t+1):ℝ)+2) = (2*(t:ℝ)+2)*(2*(t:ℝ)+3) := by push_cast; ring
          rw [e, e2] at h
          exact h
        have hBB : ((3*t+4).choose (3*s+1) : ℝ) *
            ((3*(t:ℝ)+1-3*(s:ℝ))*(3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ)))
            = ((3*t+1).choose (3*s+1) : ℝ) * ((3*(t:ℝ)+2)*(3*(t:ℝ)+3)*(3*(t:ℝ)+4)) := by
          have h := wtc_step_cross_three (3*t+1) (3*s+1) (by omega)
          rw [show 3*t+1+3 = 3*t+4 from by omega] at h
          have e : ((↑(3*t+1):ℝ)+1-↑(3*s+1)) * ((↑(3*t+1):ℝ)+2-↑(3*s+1)) * ((↑(3*t+1):ℝ)+3-↑(3*s+1))
              = (3*(t:ℝ)+1-3*(s:ℝ))*(3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ)) := by push_cast; ring
          have e2 : ((↑(3*t+1):ℝ)+1) * ((↑(3*t+1):ℝ)+2) * ((↑(3*t+1):ℝ)+3)
              = (3*(t:ℝ)+2)*(3*(t:ℝ)+3)*(3*(t:ℝ)+4) := by push_cast; ring
          rw [e, e2] at h
          exact h
        have hDD : ((6*t+9).choose (6*s+3) : ℝ) *
            ((6*(t:ℝ)+1-6*(s:ℝ))*(6*(t:ℝ)+2-6*(s:ℝ))*(6*(t:ℝ)+3-6*(s:ℝ))*(6*(t:ℝ)+4-6*(s:ℝ))*(6*(t:ℝ)+5-6*(s:ℝ))*(6*(t:ℝ)+6-6*(s:ℝ)))
            = ((6*t+3).choose (6*s+3) : ℝ) * ((6*(t:ℝ)+4)*(6*(t:ℝ)+5)*(6*(t:ℝ)+6)*(6*(t:ℝ)+7)*(6*(t:ℝ)+8)*(6*(t:ℝ)+9)) := by
          have h := wtc_step_cross_six (6*t+3) (6*s+3) (by omega)
          rw [show 6*t+3+6 = 6*t+9 from by omega] at h
          have e : ((↑(6*t+3):ℝ)+1-↑(6*s+3)) * ((↑(6*t+3):ℝ)+2-↑(6*s+3)) * ((↑(6*t+3):ℝ)+3-↑(6*s+3))
                  * ((↑(6*t+3):ℝ)+4-↑(6*s+3)) * ((↑(6*t+3):ℝ)+5-↑(6*s+3)) * ((↑(6*t+3):ℝ)+6-↑(6*s+3))
              = (6*(t:ℝ)+1-6*(s:ℝ))*(6*(t:ℝ)+2-6*(s:ℝ))*(6*(t:ℝ)+3-6*(s:ℝ))*(6*(t:ℝ)+4-6*(s:ℝ))*(6*(t:ℝ)+5-6*(s:ℝ))*(6*(t:ℝ)+6-6*(s:ℝ)) := by push_cast; ring
          have e2 : ((↑(6*t+3):ℝ)+1) * ((↑(6*t+3):ℝ)+2) * ((↑(6*t+3):ℝ)+3) * ((↑(6*t+3):ℝ)+4) * ((↑(6*t+3):ℝ)+5) * ((↑(6*t+3):ℝ)+6)
              = (6*(t:ℝ)+4)*(6*(t:ℝ)+5)*(6*(t:ℝ)+6)*(6*(t:ℝ)+7)*(6*(t:ℝ)+8)*(6*(t:ℝ)+9) := by push_cast; ring
          rw [e, e2] at h
          exact h
  15. Conclude wtc_term(q+2, h) ≤ wtc_term(q, h) when h is odd.

    Apply the polynomial inequality wtc_step_poly_odd to obtain hQle, verify positivity of all denominators and binomial coefficients, pack the inequalities via wtc_step_pack, and multiply by the nonnegative factor (21/20)^(6s+3).

    lines 327–356

    uses wtc_step_poly_odd, wtc_step_pack, wtc_step_choose_pos, mul_le_mul_of_nonneg_right

        have hQle := wtc_step_poly_odd (t:ℝ) (s:ℝ) htR (by positivity) hsleR
        have hP1 : (0:ℝ) < (2*(t:ℝ)+1-2*(s:ℝ))*(2*(t:ℝ)+2-2*(s:ℝ)) := by nlinarith
        have hP2 : (0:ℝ) < (3*(t:ℝ)+1-3*(s:ℝ))*(3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ)) := by
          have a : (0:ℝ) < 3*(t:ℝ)+1-3*(s:ℝ) := by nlinarith
          have b : (0:ℝ) < 3*(t:ℝ)+2-3*(s:ℝ) := by nlinarith
          have c : (0:ℝ) < 3*(t:ℝ)+3-3*(s:ℝ) := by nlinarith
          positivity
        have haux := wtc_step_pack (x := 3*↑(2*s+1))
          (A := ((2*t+1).choose (2*s+1) : ℝ)) (A2 := ((2*t+3).choose (2*s+1) : ℝ))
          (B := ((3*t+1).choose (3*s+1) : ℝ)) (B2 := ((3*t+4).choose (3*s+1) : ℝ))
          (D := ((6*t+3).choose (6*s+3) : ℝ)) (D2 := ((6*t+9).choose (6*s+3) : ℝ))
          (P1 := (2*(t:ℝ)+1-2*(s:ℝ))*(2*(t:ℝ)+2-2*(s:ℝ)))
          (Q1 := (2*(t:ℝ)+2)*(2*(t:ℝ)+3))
          (P2 := (3*(t:ℝ)+1-3*(s:ℝ))*(3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ)))
          (Q2 := (3*(t:ℝ)+2)*(3*(t:ℝ)+3)*(3*(t:ℝ)+4))
          (P3 := (6*(t:ℝ)+1-6*(s:ℝ))*(6*(t:ℝ)+2-6*(s:ℝ))*(6*(t:ℝ)+3-6*(s:ℝ))*(6*(t:ℝ)+4-6*(s:ℝ))*(6*(t:ℝ)+5-6*(s:ℝ))*(6*(t:ℝ)+6-6*(s:ℝ)))
          (Q3 := (6*(t:ℝ)+4)*(6*(t:ℝ)+5)*(6*(t:ℝ)+6)*(6*(t:ℝ)+7)*(6*(t:ℝ)+8)*(6*(t:ℝ)+9))
          (by positivity)
          (wtc_step_choose_pos (2*t+1) (2*s+1) (by omega))
          (wtc_step_choose_pos (3*t+1) (3*s+1) (by omega))
          (wtc_step_choose_pos (6*t+3) (6*s+3) (by omega))
          (wtc_step_choose_pos (6*t+9) (6*s+3) (by omega))
          hP1 (by positivity) hP2
          hAA hBB hDD hQle
        have h1 : 3*↑(2*s+1) * ↑((2*t+3).choose (2*s+1)) * ↑((3*t+4).choose (3*s+1)) / ↑((6*t+9).choose (6*s+3))
            = (3*↑(2*s+1)) * ((((2*t+3).choose (2*s+1) : ℝ)) * (((3*t+4).choose (3*s+1) : ℝ)) / (((6*t+9).choose (6*s+3) : ℝ))) := by ring
        have h2 : 3*↑(2*s+1) * ↑((2*t+1).choose (2*s+1)) * ↑((3*t+1).choose (3*s+1)) / ↑((6*t+3).choose (6*s+3))
            = (3*↑(2*s+1)) * ((((2*t+1).choose (2*s+1) : ℝ)) * (((3*t+1).choose (3*s+1) : ℝ)) / (((6*t+3).choose (6*s+3) : ℝ))) := by ring
        rw [h1, h2]
        exact mul_le_mul_of_nonneg_right haux (by positivity)
Nat.choose_pos
If k ≤ n, the binomial coefficient n.choose k is strictly positive.
Nat.choose_mul_succ_eq
For all n and k, (n.choose k) * (n + 1) = ((n + 1).choose k) * (n + 1 - k).
wtc_step_choose_two
Shift identity by 2: (n + 2).choose k * (n + 1 - k) * (n + 2 - k) = n.choose k * (n + 1) * (n + 2).
wtc_step_choose_three
Shift identity by 3: (n + 3).choose k * (n + 1 - k) * (n + 2 - k) * (n + 3 - k) = n.choose k * (n + 1) * (n + 2) * (n + 3).
wtc_step_choose_six
Shift identity by 6: (n + 6).choose k times 6 downward factors equals n.choose k times 6 upward factors.
congrArg
Equality is preserved under function application: if a₁ = a₂, then f(a₁) = f(a₂).
Nat.cast_sub
The cast of a natural subtraction n - m to a ring equals ↑n - ↑m when m ≤ n.
mul_le_mul_of_nonneg_left
Multiplying an inequality on the left by a nonnegative number preserves the inequality.
le_of_mul_le_mul_right
Dividing or canceling a strictly positive factor on the right of an inequality preserves the inequality.
div_le_div_iff₀
For strictly positive denominators b and d, a / b ≤ c / d is equivalent to a * d ≤ c * b.
mul_pos
The product of two strictly positive real numbers is strictly positive.
mul_nonneg
The product of two nonnegative real numbers is nonnegative.
Nat.odd_iff.mpr
A natural number is odd if and only if its remainder modulo 2 is 1.
Nat.even_iff.mpr
A natural number is even if and only if its remainder modulo 2 is 0.
Nat.mod_two_eq_zero_or_one
Every natural number has remainder modulo 2 equal to either 0 or 1.
wtc_term
The canonical triple-partition resource term wtc_term(q, h).
wtc_step_cross_two
The real-cast shift-by-2 identity for binomial coefficients when k ≤ n.
wtc_step_cross_three
The real-cast shift-by-3 identity for binomial coefficients when k ≤ n.
wtc_step_cross_six
The real-cast shift-by-6 identity for binomial coefficients when k ≤ n.
wtc_step_pack
Ratio packing lemma: given shift relations A2*P1 = A*Q1, B2*P2 = B*Q2, D2*P3 = D*Q3 and Q1*Q2*P3 ≤ P1*P2*Q3 with positive terms, x*(A2*B2/D2) ≤ x*(A*B/D).
wtc_step_poly_even
The degree-11 polynomial inequality establishing Q1*Q2*P3 ≤ P1*P2*Q3 when h is even.
wtc_step_choose_pos
The real-cast binomial coefficient ((n.choose k : ℕ) : ℝ) is strictly positive when k ≤ n.
mul_le_mul_of_nonneg_right
Multiplying an inequality on the right by a nonnegative number preserves the inequality.
wtc_step_poly_odd
The degree-11 polynomial inequality establishing Q1*Q2*P3 ≤ P1*P2*Q3 when h is odd.

Written by a model (gemini-3.8-flash) from the Lean proof and the goal states Lean reported at each step. Lean verified the proof; this explanation is a reading aid and is not itself machine-checked.

Lean source view module on GitHub

private lemma wtc_step_choose_pos (n k : ℕ) (h : k ≤ n) : (0:ℝ) < ((n.choose k : ℕ) : ℝ) := by  have := Nat.choose_pos h  exact_mod_cast thisprivate lemma wtc_step_choose_two (n k : ℕ) :    (n+2).choose k * (n+1-k) * (n+2-k) = n.choose k * (n+1) * (n+2) := by  have h1 : (n+2).choose k * (n+2-k) = (n+1).choose k * (n+2) := (Nat.choose_mul_succ_eq (n+1) k).symm  have h0 : (n+1).choose k * (n+1-k) = n.choose k * (n+1) := (Nat.choose_mul_succ_eq n k).symm  calc (n+2).choose k * (n+1-k) * (n+2-k)      = (n+2).choose k * (n+2-k) * (n+1-k) := by ring    _ = (n+1).choose k * (n+2) * (n+1-k) := by rw [h1]    _ = (n+1).choose k * (n+1-k) * (n+2) := by ring    _ = n.choose k * (n+1) * (n+2) := by rw [h0]private lemma wtc_step_choose_three (n k : ℕ) :    (n+3).choose k * (n+1-k) * (n+2-k) * (n+3-k) = n.choose k * (n+1) * (n+2) * (n+3) := by  have h2 : (n+1).choose k * (n+1-k) = n.choose k * (n+1) := (Nat.choose_mul_succ_eq n k).symm  have h := wtc_step_choose_two (n+1) k  calc (n+3).choose k * (n+1-k) * (n+2-k) * (n+3-k)      = ((n+3).choose k * (n+2-k) * (n+3-k)) * (n+1-k) := by ring    _ = ((n+1).choose k * (n+2) * (n+3)) * (n+1-k) := by rw [h]    _ = ((n+1).choose k * (n+1-k)) * (n+2) * (n+3) := by ring    _ = (n.choose k * (n+1)) * (n+2) * (n+3) := by rw [h2]    _ = n.choose k * (n+1) * (n+2) * (n+3) := by ringprivate lemma wtc_step_choose_six (n k : ℕ) :    (n+6).choose k * (n+1-k) * (n+2-k) * (n+3-k) * (n+4-k) * (n+5-k) * (n+6-k)      = n.choose k * (n+1) * (n+2) * (n+3) * (n+4) * (n+5) * (n+6) := by  have h := wtc_step_choose_three (n+3) k  have h2 := wtc_step_choose_three n k  calc (n+6).choose k * (n+1-k) * (n+2-k) * (n+3-k) * (n+4-k) * (n+5-k) * (n+6-k)      = ((n+6).choose k * (n+4-k) * (n+5-k) * (n+6-k)) * ((n+1-k)*(n+2-k)*(n+3-k)) := by ring    _ = ((n+3).choose k * (n+4) * (n+5) * (n+6)) * ((n+1-k)*(n+2-k)*(n+3-k)) := by rw [h]    _ = ((n+3).choose k * (n+1-k) * (n+2-k) * (n+3-k)) * (n+4) * (n+5) * (n+6) := by ring    _ = (n.choose k * (n+1) * (n+2) * (n+3)) * (n+4) * (n+5) * (n+6) := by rw [h2]    _ = n.choose k * (n+1) * (n+2) * (n+3) * (n+4) * (n+5) * (n+6) := by ringprivate lemma wtc_step_cross_two (n k : ℕ) (hk : k ≤ n) :    ((n+2).choose k : ℝ) * (((n:ℝ)+1-(k:ℝ)) * ((n:ℝ)+2-(k:ℝ)))      = ((n).choose k : ℝ) * (((n:ℝ)+1) * ((n:ℝ)+2)) := by  have h := congrArg (fun x : ℕ => (x:ℝ)) (wtc_step_choose_two n k)  have e1 : (((n+1-k:ℕ)):ℝ) = (n:ℝ)+1-(k:ℝ) := by    rw [Nat.cast_sub (by omega : k ≤ n+1)]; push_cast; ring  have e2 : (((n+2-k:ℕ)):ℝ) = (n:ℝ)+2-(k:ℝ) := by    rw [Nat.cast_sub (by omega : k ≤ n+2)]; push_cast; ring  push_cast at h  rw [e1, e2] at h  linarith [h]private lemma wtc_step_cross_three (n k : ℕ) (hk : k ≤ n) :    ((n+3).choose k : ℝ) * (((n:ℝ)+1-(k:ℝ)) * ((n:ℝ)+2-(k:ℝ)) * ((n:ℝ)+3-(k:ℝ)))      = ((n).choose k : ℝ) * (((n:ℝ)+1) * ((n:ℝ)+2) * ((n:ℝ)+3)) := by  have h := congrArg (fun x : ℕ => (x:ℝ)) (wtc_step_choose_three n k)  have e1 : (((n+1-k:ℕ)):ℝ) = (n:ℝ)+1-(k:ℝ) := by    rw [Nat.cast_sub (by omega : k ≤ n+1)]; push_cast; ring  have e2 : (((n+2-k:ℕ)):ℝ) = (n:ℝ)+2-(k:ℝ) := by    rw [Nat.cast_sub (by omega : k ≤ n+2)]; push_cast; ring  have e3 : (((n+3-k:ℕ)):ℝ) = (n:ℝ)+3-(k:ℝ) := by    rw [Nat.cast_sub (by omega : k ≤ n+3)]; push_cast; ring  push_cast at h  rw [e1, e2, e3] at h  linarith [h]private lemma wtc_step_cross_six (n k : ℕ) (hk : k ≤ n) :    ((n+6).choose k : ℝ) * (((n:ℝ)+1-(k:ℝ)) * ((n:ℝ)+2-(k:ℝ)) * ((n:ℝ)+3-(k:ℝ))      * ((n:ℝ)+4-(k:ℝ)) * ((n:ℝ)+5-(k:ℝ)) * ((n:ℝ)+6-(k:ℝ)))      = ((n).choose k : ℝ) * (((n:ℝ)+1) * ((n:ℝ)+2) * ((n:ℝ)+3) * ((n:ℝ)+4) * ((n:ℝ)+5) * ((n:ℝ)+6)) := by  have h := congrArg (fun x : ℕ => (x:ℝ)) (wtc_step_choose_six n k)  have e1 : (((n+1-k:ℕ)):ℝ) = (n:ℝ)+1-(k:ℝ) := by    rw [Nat.cast_sub (by omega : k ≤ n+1)]; push_cast; ring  have e2 : (((n+2-k:ℕ)):ℝ) = (n:ℝ)+2-(k:ℝ) := by    rw [Nat.cast_sub (by omega : k ≤ n+2)]; push_cast; ring  have e3 : (((n+3-k:ℕ)):ℝ) = (n:ℝ)+3-(k:ℝ) := by    rw [Nat.cast_sub (by omega : k ≤ n+3)]; push_cast; ring  have e4 : (((n+4-k:ℕ)):ℝ) = (n:ℝ)+4-(k:ℝ) := by    rw [Nat.cast_sub (by omega : k ≤ n+4)]; push_cast; ring  have e5 : (((n+5-k:ℕ)):ℝ) = (n:ℝ)+5-(k:ℝ) := by    rw [Nat.cast_sub (by omega : k ≤ n+5)]; push_cast; ring  have e6 : (((n+6-k:ℕ)):ℝ) = (n:ℝ)+6-(k:ℝ) := by    rw [Nat.cast_sub (by omega : k ≤ n+6)]; push_cast; ring  push_cast at h  rw [e1, e2, e3, e4, e5, e6] at h  linarith [h]private lemma wtc_step_pack (x A A2 B B2 D D2 P1 Q1 P2 Q2 P3 Q3 : ℝ)    (hx : 0 ≤ x) (hA : 0 < A) (hB : 0 < B) (hD : 0 < D) (hD2 : 0 < D2)    (hP1 : 0 < P1) (hQ3 : 0 < Q3) (hP2 : 0 < P2)    (hAA : A2 * P1 = A * Q1) (hBB : B2 * P2 = B * Q2) (hDD : D2 * P3 = D * Q3)    (hQle : Q1 * Q2 * P3 ≤ P1 * P2 * Q3) :    x * (A2 * B2 / D2) ≤ x * (A * B / D) := by  have hprod : A2 * B2 * D * (P1*P2*Q3) = A * B * D2 * (Q1*Q2*P3) := by    calc A2 * B2 * D * (P1*P2*Q3) = (A2*P1)*(B2*P2)*(D*Q3) := by ring      _ = (A*Q1)*(B*Q2)*(D2*P3) := by rw [hAA, hBB, hDD]      _ = A * B * D2 * (Q1*Q2*P3) := by ring  have hpos : 0 < P1*P2*Q3 := by positivity  have hle : A2 * B2 * D * (P1*P2*Q3) ≤ A * B * D2 * (P1*P2*Q3) := by    rw [hprod]    exact mul_le_mul_of_nonneg_left hQle (by positivity)  have hm : A2 * B2 * D ≤ A * B * D2 := le_of_mul_le_mul_right hle hpos  have hdiv : A2*B2/D2 ≤ A*B/D := by    rw [div_le_div_iff₀ hD2 hD]    linarith [hm]  exact mul_le_mul_of_nonneg_left hdiv hxprivate lemma wtc_step_poly_even (t s : ℝ) (ht : 1 ≤ t) (hs : 0 ≤ s) (hcon : 4*s ≤ 2*t+1) :    (2*t+2)*(2*t+3) * ((3*t+2)*(3*t+3)*(3*t+4)) *      ((6*t+4-6*s)*(6*t+5-6*s)*(6*t+6-6*s)*(6*t+7-6*s)*(6*t+8-6*s)*(6*t+9-6*s))    ≤ (2*t+2-2*s)*(2*t+3-2*s) * ((3*t+2-3*s)*(3*t+3-3*s)*(3*t+4-3*s)) *      ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)) := by  have hDEN : 0 < (6*t+6-6*s)*(6*t+5)*(6*t+7) := by    have h1 : (0:ℝ) < 6*t+6-6*s := by nlinarith    have h2 : (0:ℝ) < 6*t+5 := by linarith    have h3 : (0:ℝ) < 6*t+7 := by linarith    exact mul_pos (mul_pos h1 h2) h3  have hNUM : (6*t+6)*(6*t+5-6*s)*(6*t+7-6*s) ≤ (6*t+6-6*s)*(6*t+5)*(6*t+7) := by    nlinarith [mul_nonneg (mul_nonneg (by linarith : (0:ℝ) ≤ 6*t+6) (by linarith : (0:ℝ) ≤ 6*t+6-6*s)) (by norm_num : (0:ℝ) ≤ 1)]  have hid : ((2*t+2)*(2*t+3) * ((3*t+2)*(3*t+3)*(3*t+4)) *      ((6*t+4-6*s)*(6*t+5-6*s)*(6*t+6-6*s)*(6*t+7-6*s)*(6*t+8-6*s)*(6*t+9-6*s)))      * ((6*t+6-6*s)*(6*t+5)*(6*t+7))    = ((2*t+2-2*s)*(2*t+3-2*s) * ((3*t+2-3*s)*(3*t+3-3*s)*(3*t+4-3*s)) *      ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)))      * ((6*t+6)*(6*t+5-6*s)*(6*t+7-6*s)) := by ring  have hR : 0 ≤ (2*t+2-2*s)*(2*t+3-2*s) * ((3*t+2-3*s)*(3*t+3-3*s)*(3*t+4-3*s)) *      ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)) := by    have h1 : (0:ℝ) < 2*t+2-2*s := by nlinarith    have h2 : (0:ℝ) < 2*t+3-2*s := by nlinarith    have h3 : (0:ℝ) < 3*t+2-3*s := by nlinarith    have h4 : (0:ℝ) < 3*t+3-3*s := by nlinarith    have h5 : (0:ℝ) < 3*t+4-3*s := by nlinarith    have g1 : (0:ℝ) < 6*t+4 := by linarith    have g2 : (0:ℝ) < 6*t+5 := by linarith    have g3 : (0:ℝ) < 6*t+6 := by linarith    have g4 : (0:ℝ) < 6*t+7 := by linarith    have g5 : (0:ℝ) < 6*t+8 := by linarith    have g6 : (0:ℝ) < 6*t+9 := by linarith    positivity  have hstep : ((2*t+2)*(2*t+3) * ((3*t+2)*(3*t+3)*(3*t+4)) *      ((6*t+4-6*s)*(6*t+5-6*s)*(6*t+6-6*s)*(6*t+7-6*s)*(6*t+8-6*s)*(6*t+9-6*s)))      * ((6*t+6-6*s)*(6*t+5)*(6*t+7))      ≤ ((2*t+2-2*s)*(2*t+3-2*s) * ((3*t+2-3*s)*(3*t+3-3*s)*(3*t+4-3*s)) *      ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)))      * ((6*t+6-6*s)*(6*t+5)*(6*t+7)) := by    rw [hid]    exact mul_le_mul_of_nonneg_left hNUM hR  exact le_of_mul_le_mul_right hstep hDENprivate lemma wtc_step_poly_odd (t s : ℝ) (ht : 1 ≤ t) (hs : 0 ≤ s) (hcon : 4*s+2 ≤ 2*t+1) :    (2*t+2)*(2*t+3) * ((3*t+2)*(3*t+3)*(3*t+4)) *      ((6*t+1-6*s)*(6*t+2-6*s)*(6*t+3-6*s)*(6*t+4-6*s)*(6*t+5-6*s)*(6*t+6-6*s))    ≤ (2*t+1-2*s)*(2*t+2-2*s) * ((3*t+1-3*s)*(3*t+2-3*s)*(3*t+3-3*s)) *      ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)) := by  have hDEN : 0 < (6*t+5)*(6*t+7)*(6*t+6-6*s) := by    have h1 : (0:ℝ) < 6*t+6-6*s := by nlinarith    have h2 : (0:ℝ) < 6*t+5 := by linarith    have h3 : (0:ℝ) < 6*t+7 := by linarith    exact mul_pos (mul_pos h2 h3) h1  have hNUM : (6*t+6)*(6*t+1-6*s)*(6*t+5-6*s) ≤ (6*t+5)*(6*t+7)*(6*t+6-6*s) := by    nlinarith [mul_nonneg (mul_nonneg (by linarith : (0:ℝ) ≤ 6*t+6) (by linarith : (0:ℝ) ≤ 6*t+1-6*s)) (by linarith : (0:ℝ) ≤ 6*t+5-6*s),               mul_nonneg (by linarith : (0:ℝ) ≤ 2*s+1) (mul_nonneg (by linarith : (0:ℝ) ≤ 6*t+6) (by linarith : (0:ℝ) ≤ 6*t+3-6*s))]  have hid : ((2*t+2)*(2*t+3) * ((3*t+2)*(3*t+3)*(3*t+4)) *      ((6*t+1-6*s)*(6*t+2-6*s)*(6*t+3-6*s)*(6*t+4-6*s)*(6*t+5-6*s)*(6*t+6-6*s)))      * ((6*t+5)*(6*t+7)*(6*t+6-6*s))    = ((2*t+1-2*s)*(2*t+2-2*s) * ((3*t+1-3*s)*(3*t+2-3*s)*(3*t+3-3*s)) *      ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)))      * ((6*t+6)*(6*t+1-6*s)*(6*t+5-6*s)) := by ring  have hR : 0 ≤ (2*t+1-2*s)*(2*t+2-2*s) * ((3*t+1-3*s)*(3*t+2-3*s)*(3*t+3-3*s)) *      ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)) := by    have h1 : (0:ℝ) < 2*t+1-2*s := by nlinarith    have h2 : (0:ℝ) < 2*t+2-2*s := by nlinarith    have h3 : (0:ℝ) < 3*t+1-3*s := by nlinarith    have h4 : (0:ℝ) < 3*t+2-3*s := by nlinarith    have h5 : (0:ℝ) < 3*t+3-3*s := by nlinarith    have g1 : (0:ℝ) < 6*t+4 := by linarith    have g2 : (0:ℝ) < 6*t+5 := by linarith    have g3 : (0:ℝ) < 6*t+6 := by linarith    have g4 : (0:ℝ) < 6*t+7 := by linarith    have g5 : (0:ℝ) < 6*t+8 := by linarith    have g6 : (0:ℝ) < 6*t+9 := by linarith    positivity  have hstep : ((2*t+2)*(2*t+3) * ((3*t+2)*(3*t+3)*(3*t+4)) *      ((6*t+1-6*s)*(6*t+2-6*s)*(6*t+3-6*s)*(6*t+4-6*s)*(6*t+5-6*s)*(6*t+6-6*s)))      * ((6*t+5)*(6*t+7)*(6*t+6-6*s))      ≤ ((2*t+1-2*s)*(2*t+2-2*s) * ((3*t+1-3*s)*(3*t+2-3*s)*(3*t+3-3*s)) *      ((6*t+4)*(6*t+5)*(6*t+6)*(6*t+7)*(6*t+8)*(6*t+9)))      * ((6*t+5)*(6*t+7)*(6*t+6-6*s)) := by    rw [hid]    exact mul_le_mul_of_nonneg_left hNUM hR  exact le_of_mul_le_mul_right hstep hDENtheorem wild_triple_partition_term_antitone_odd_step    (q h : ℕ) (hq : 3 ≤ q) (hodd : q%2 = 1)    (hh : 1 ≤ h) (hhq : 2*h ≤ q) :    wtc_term (q+2) h ≤ wtc_term q h := by  obtain ⟨t, ht⟩ : ∃ t, q = 2*t+1 := by    have ho : Odd q := Nat.odd_iff.mpr hodd    obtain ⟨t, ht⟩ := ho    exact ⟨t, by omega⟩  subst ht  have ht1 : 1 ≤ t := by omega  have htR : (1:ℝ) ≤ (t:ℝ) := by exact_mod_cast ht1  rcases Nat.mod_two_eq_zero_or_one h with hh2 | hh2  · obtain ⟨s, hs⟩ : ∃ s, h = 2*s := by      have := Nat.even_iff.mpr hh2      obtain ⟨s, hs⟩ := this      exact ⟨s, by omega⟩    subst hs    have hsle : 4*s ≤ 2*t+1 := by omega    have hsleR : 4*(s:ℝ) ≤ 2*(t:ℝ)+1 := by exact_mod_cast hsle    simp only [wtc_term,      show 3*(2*t+1+2) = 6*t+9 from by omega,      show (6*t+9)/2 = 3*t+4 from by omega,      show 3*(2*t+1) = 6*t+3 from by omega,      show (6*t+3)/2 = 3*t+1 from by omega,      show 3*(2*s) = 6*s from by omega, show (6*s)/2 = 3*s from by omega]    have hAA : ((2*t+3).choose (2*s) : ℝ) * ((2*(t:ℝ)+2-2*(s:ℝ))*(2*(t:ℝ)+3-2*(s:ℝ)))        = ((2*t+1).choose (2*s) : ℝ) * ((2*(t:ℝ)+2)*(2*(t:ℝ)+3)) := by      have h := wtc_step_cross_two (2*t+1) (2*s) (by omega)      rw [show 2*t+1+2 = 2*t+3 from by omega] at h      have e : ((↑(2*t+1):ℝ)+1-↑(2*s)) * ((↑(2*t+1):ℝ)+2-↑(2*s))          = (2*(t:ℝ)+2-2*(s:ℝ))*(2*(t:ℝ)+3-2*(s:ℝ)) := by push_cast; ring      have e2 : ((↑(2*t+1):ℝ)+1) * ((↑(2*t+1):ℝ)+2) = (2*(t:ℝ)+2)*(2*(t:ℝ)+3) := by push_cast; ring      rw [e, e2] at h      exact h    have hBB : ((3*t+4).choose (3*s) : ℝ) *        ((3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ))*(3*(t:ℝ)+4-3*(s:ℝ)))        = ((3*t+1).choose (3*s) : ℝ) * ((3*(t:ℝ)+2)*(3*(t:ℝ)+3)*(3*(t:ℝ)+4)) := by      have h := wtc_step_cross_three (3*t+1) (3*s) (by omega)      rw [show 3*t+1+3 = 3*t+4 from by omega] at h      have e : ((↑(3*t+1):ℝ)+1-↑(3*s)) * ((↑(3*t+1):ℝ)+2-↑(3*s)) * ((↑(3*t+1):ℝ)+3-↑(3*s))          = (3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ))*(3*(t:ℝ)+4-3*(s:ℝ)) := by push_cast; ring      have e2 : ((↑(3*t+1):ℝ)+1) * ((↑(3*t+1):ℝ)+2) * ((↑(3*t+1):ℝ)+3)          = (3*(t:ℝ)+2)*(3*(t:ℝ)+3)*(3*(t:ℝ)+4) := by push_cast; ring      rw [e, e2] at h      exact h    have hDD : ((6*t+9).choose (6*s) : ℝ) *        ((6*(t:ℝ)+4-6*(s:ℝ))*(6*(t:ℝ)+5-6*(s:ℝ))*(6*(t:ℝ)+6-6*(s:ℝ))*(6*(t:ℝ)+7-6*(s:ℝ))*(6*(t:ℝ)+8-6*(s:ℝ))*(6*(t:ℝ)+9-6*(s:ℝ)))        = ((6*t+3).choose (6*s) : ℝ) * ((6*(t:ℝ)+4)*(6*(t:ℝ)+5)*(6*(t:ℝ)+6)*(6*(t:ℝ)+7)*(6*(t:ℝ)+8)*(6*(t:ℝ)+9)) := by      have h := wtc_step_cross_six (6*t+3) (6*s) (by omega)      rw [show 6*t+3+6 = 6*t+9 from by omega] at h      have e : ((↑(6*t+3):ℝ)+1-↑(6*s)) * ((↑(6*t+3):ℝ)+2-↑(6*s)) * ((↑(6*t+3):ℝ)+3-↑(6*s))              * ((↑(6*t+3):ℝ)+4-↑(6*s)) * ((↑(6*t+3):ℝ)+5-↑(6*s)) * ((↑(6*t+3):ℝ)+6-↑(6*s))          = (6*(t:ℝ)+4-6*(s:ℝ))*(6*(t:ℝ)+5-6*(s:ℝ))*(6*(t:ℝ)+6-6*(s:ℝ))*(6*(t:ℝ)+7-6*(s:ℝ))*(6*(t:ℝ)+8-6*(s:ℝ))*(6*(t:ℝ)+9-6*(s:ℝ)) := by push_cast; ring      have e2 : ((↑(6*t+3):ℝ)+1) * ((↑(6*t+3):ℝ)+2) * ((↑(6*t+3):ℝ)+3) * ((↑(6*t+3):ℝ)+4) * ((↑(6*t+3):ℝ)+5) * ((↑(6*t+3):ℝ)+6)          = (6*(t:ℝ)+4)*(6*(t:ℝ)+5)*(6*(t:ℝ)+6)*(6*(t:ℝ)+7)*(6*(t:ℝ)+8)*(6*(t:ℝ)+9) := by push_cast; ring      rw [e, e2] at h      exact h    have hQle := wtc_step_poly_even (t:ℝ) (s:ℝ) htR (by positivity) hsleR    have hP1 : (0:ℝ) < (2*(t:ℝ)+2-2*(s:ℝ))*(2*(t:ℝ)+3-2*(s:ℝ)) := by      have a : (0:ℝ) < 2*(t:ℝ)+2-2*(s:ℝ) := by nlinarith      have b : (0:ℝ) < 2*(t:ℝ)+3-2*(s:ℝ) := by nlinarith      positivity    have hP2 : (0:ℝ) < (3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ))*(3*(t:ℝ)+4-3*(s:ℝ)) := by      have a : (0:ℝ) < 3*(t:ℝ)+2-3*(s:ℝ) := by nlinarith      have b : (0:ℝ) < 3*(t:ℝ)+3-3*(s:ℝ) := by nlinarith      have c : (0:ℝ) < 3*(t:ℝ)+4-3*(s:ℝ) := by nlinarith      positivity    have haux := wtc_step_pack (x := 3*↑(2*s))      (A := ((2*t+1).choose (2*s) : ℝ)) (A2 := ((2*t+3).choose (2*s) : ℝ))      (B := ((3*t+1).choose (3*s) : ℝ)) (B2 := ((3*t+4).choose (3*s) : ℝ))      (D := ((6*t+3).choose (6*s) : ℝ)) (D2 := ((6*t+9).choose (6*s) : ℝ))      (P1 := (2*(t:ℝ)+2-2*(s:ℝ))*(2*(t:ℝ)+3-2*(s:ℝ)))      (Q1 := (2*(t:ℝ)+2)*(2*(t:ℝ)+3))      (P2 := (3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ))*(3*(t:ℝ)+4-3*(s:ℝ)))      (Q2 := (3*(t:ℝ)+2)*(3*(t:ℝ)+3)*(3*(t:ℝ)+4))      (P3 := (6*(t:ℝ)+4-6*(s:ℝ))*(6*(t:ℝ)+5-6*(s:ℝ))*(6*(t:ℝ)+6-6*(s:ℝ))*(6*(t:ℝ)+7-6*(s:ℝ))*(6*(t:ℝ)+8-6*(s:ℝ))*(6*(t:ℝ)+9-6*(s:ℝ)))      (Q3 := (6*(t:ℝ)+4)*(6*(t:ℝ)+5)*(6*(t:ℝ)+6)*(6*(t:ℝ)+7)*(6*(t:ℝ)+8)*(6*(t:ℝ)+9))      (by positivity)      (wtc_step_choose_pos (2*t+1) (2*s) (by omega))      (wtc_step_choose_pos (3*t+1) (3*s) (by omega))      (wtc_step_choose_pos (6*t+3) (6*s) (by omega))      (wtc_step_choose_pos (6*t+9) (6*s) (by omega))      hP1 (by positivity) hP2      hAA hBB hDD hQle    have h1 : 3*↑(2*s) * ↑((2*t+3).choose (2*s)) * ↑((3*t+4).choose (3*s)) / ↑((6*t+9).choose (6*s))        = (3*↑(2*s)) * ((((2*t+3).choose (2*s) : ℝ)) * (((3*t+4).choose (3*s) : ℝ)) / (((6*t+9).choose (6*s) : ℝ))) := by ring    have h2 : 3*↑(2*s) * ↑((2*t+1).choose (2*s)) * ↑((3*t+1).choose (3*s)) / ↑((6*t+3).choose (6*s))        = (3*↑(2*s)) * ((((2*t+1).choose (2*s) : ℝ)) * (((3*t+1).choose (3*s) : ℝ)) / (((6*t+3).choose (6*s) : ℝ))) := by ring    rw [h1, h2]    exact mul_le_mul_of_nonneg_right haux (by positivity)  · obtain ⟨s, hs⟩ : ∃ s, h = 2*s+1 := by      have := Nat.odd_iff.mpr hh2      obtain ⟨s, hs⟩ := this      exact ⟨s, by omega⟩    subst hs    have hsle : 2*(2*s+1) ≤ 2*t+1 := by omega    have hsleR : 4*(s:ℝ)+2 ≤ 2*(t:ℝ)+1 := by      have hh : (2*(2*s+1) : ℝ) ≤ (2*t+1 : ℝ) := by exact_mod_cast hsle      push_cast at hh; linarith    simp only [wtc_term,      show 3*(2*t+1+2) = 6*t+9 from by omega,      show (6*t+9)/2 = 3*t+4 from by omega,      show 3*(2*t+1) = 6*t+3 from by omega,      show (6*t+3)/2 = 3*t+1 from by omega,      show 3*(2*s+1) = 6*s+3 from by omega, show (6*s+3)/2 = 3*s+1 from by omega]    have hAA : ((2*t+3).choose (2*s+1) : ℝ) * ((2*(t:ℝ)+1-2*(s:ℝ))*(2*(t:ℝ)+2-2*(s:ℝ)))        = ((2*t+1).choose (2*s+1) : ℝ) * ((2*(t:ℝ)+2)*(2*(t:ℝ)+3)) := by      have h := wtc_step_cross_two (2*t+1) (2*s+1) (by omega)      rw [show 2*t+1+2 = 2*t+3 from by omega] at h      have e : ((↑(2*t+1):ℝ)+1-↑(2*s+1)) * ((↑(2*t+1):ℝ)+2-↑(2*s+1))          = (2*(t:ℝ)+1-2*(s:ℝ))*(2*(t:ℝ)+2-2*(s:ℝ)) := by push_cast; ring      have e2 : ((↑(2*t+1):ℝ)+1) * ((↑(2*t+1):ℝ)+2) = (2*(t:ℝ)+2)*(2*(t:ℝ)+3) := by push_cast; ring      rw [e, e2] at h      exact h    have hBB : ((3*t+4).choose (3*s+1) : ℝ) *        ((3*(t:ℝ)+1-3*(s:ℝ))*(3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ)))        = ((3*t+1).choose (3*s+1) : ℝ) * ((3*(t:ℝ)+2)*(3*(t:ℝ)+3)*(3*(t:ℝ)+4)) := by      have h := wtc_step_cross_three (3*t+1) (3*s+1) (by omega)      rw [show 3*t+1+3 = 3*t+4 from by omega] at h      have e : ((↑(3*t+1):ℝ)+1-↑(3*s+1)) * ((↑(3*t+1):ℝ)+2-↑(3*s+1)) * ((↑(3*t+1):ℝ)+3-↑(3*s+1))          = (3*(t:ℝ)+1-3*(s:ℝ))*(3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ)) := by push_cast; ring      have e2 : ((↑(3*t+1):ℝ)+1) * ((↑(3*t+1):ℝ)+2) * ((↑(3*t+1):ℝ)+3)          = (3*(t:ℝ)+2)*(3*(t:ℝ)+3)*(3*(t:ℝ)+4) := by push_cast; ring      rw [e, e2] at h      exact h    have hDD : ((6*t+9).choose (6*s+3) : ℝ) *        ((6*(t:ℝ)+1-6*(s:ℝ))*(6*(t:ℝ)+2-6*(s:ℝ))*(6*(t:ℝ)+3-6*(s:ℝ))*(6*(t:ℝ)+4-6*(s:ℝ))*(6*(t:ℝ)+5-6*(s:ℝ))*(6*(t:ℝ)+6-6*(s:ℝ)))        = ((6*t+3).choose (6*s+3) : ℝ) * ((6*(t:ℝ)+4)*(6*(t:ℝ)+5)*(6*(t:ℝ)+6)*(6*(t:ℝ)+7)*(6*(t:ℝ)+8)*(6*(t:ℝ)+9)) := by      have h := wtc_step_cross_six (6*t+3) (6*s+3) (by omega)      rw [show 6*t+3+6 = 6*t+9 from by omega] at h      have e : ((↑(6*t+3):ℝ)+1-↑(6*s+3)) * ((↑(6*t+3):ℝ)+2-↑(6*s+3)) * ((↑(6*t+3):ℝ)+3-↑(6*s+3))              * ((↑(6*t+3):ℝ)+4-↑(6*s+3)) * ((↑(6*t+3):ℝ)+5-↑(6*s+3)) * ((↑(6*t+3):ℝ)+6-↑(6*s+3))          = (6*(t:ℝ)+1-6*(s:ℝ))*(6*(t:ℝ)+2-6*(s:ℝ))*(6*(t:ℝ)+3-6*(s:ℝ))*(6*(t:ℝ)+4-6*(s:ℝ))*(6*(t:ℝ)+5-6*(s:ℝ))*(6*(t:ℝ)+6-6*(s:ℝ)) := by push_cast; ring      have e2 : ((↑(6*t+3):ℝ)+1) * ((↑(6*t+3):ℝ)+2) * ((↑(6*t+3):ℝ)+3) * ((↑(6*t+3):ℝ)+4) * ((↑(6*t+3):ℝ)+5) * ((↑(6*t+3):ℝ)+6)          = (6*(t:ℝ)+4)*(6*(t:ℝ)+5)*(6*(t:ℝ)+6)*(6*(t:ℝ)+7)*(6*(t:ℝ)+8)*(6*(t:ℝ)+9) := by push_cast; ring      rw [e, e2] at h      exact h    have hQle := wtc_step_poly_odd (t:ℝ) (s:ℝ) htR (by positivity) hsleR    have hP1 : (0:ℝ) < (2*(t:ℝ)+1-2*(s:ℝ))*(2*(t:ℝ)+2-2*(s:ℝ)) := by nlinarith    have hP2 : (0:ℝ) < (3*(t:ℝ)+1-3*(s:ℝ))*(3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ)) := by      have a : (0:ℝ) < 3*(t:ℝ)+1-3*(s:ℝ) := by nlinarith      have b : (0:ℝ) < 3*(t:ℝ)+2-3*(s:ℝ) := by nlinarith      have c : (0:ℝ) < 3*(t:ℝ)+3-3*(s:ℝ) := by nlinarith      positivity    have haux := wtc_step_pack (x := 3*↑(2*s+1))      (A := ((2*t+1).choose (2*s+1) : ℝ)) (A2 := ((2*t+3).choose (2*s+1) : ℝ))      (B := ((3*t+1).choose (3*s+1) : ℝ)) (B2 := ((3*t+4).choose (3*s+1) : ℝ))      (D := ((6*t+3).choose (6*s+3) : ℝ)) (D2 := ((6*t+9).choose (6*s+3) : ℝ))      (P1 := (2*(t:ℝ)+1-2*(s:ℝ))*(2*(t:ℝ)+2-2*(s:ℝ)))      (Q1 := (2*(t:ℝ)+2)*(2*(t:ℝ)+3))      (P2 := (3*(t:ℝ)+1-3*(s:ℝ))*(3*(t:ℝ)+2-3*(s:ℝ))*(3*(t:ℝ)+3-3*(s:ℝ)))      (Q2 := (3*(t:ℝ)+2)*(3*(t:ℝ)+3)*(3*(t:ℝ)+4))      (P3 := (6*(t:ℝ)+1-6*(s:ℝ))*(6*(t:ℝ)+2-6*(s:ℝ))*(6*(t:ℝ)+3-6*(s:ℝ))*(6*(t:ℝ)+4-6*(s:ℝ))*(6*(t:ℝ)+5-6*(s:ℝ))*(6*(t:ℝ)+6-6*(s:ℝ)))      (Q3 := (6*(t:ℝ)+4)*(6*(t:ℝ)+5)*(6*(t:ℝ)+6)*(6*(t:ℝ)+7)*(6*(t:ℝ)+8)*(6*(t:ℝ)+9))      (by positivity)      (wtc_step_choose_pos (2*t+1) (2*s+1) (by omega))      (wtc_step_choose_pos (3*t+1) (3*s+1) (by omega))      (wtc_step_choose_pos (6*t+3) (6*s+3) (by omega))      (wtc_step_choose_pos (6*t+9) (6*s+3) (by omega))      hP1 (by positivity) hP2      hAA hBB hDD hQle    have h1 : 3*↑(2*s+1) * ↑((2*t+3).choose (2*s+1)) * ↑((3*t+4).choose (3*s+1)) / ↑((6*t+9).choose (6*s+3))        = (3*↑(2*s+1)) * ((((2*t+3).choose (2*s+1) : ℝ)) * (((3*t+4).choose (3*s+1) : ℝ)) / (((6*t+9).choose (6*s+3) : ℝ))) := by ring    have h2 : 3*↑(2*s+1) * ↑((2*t+1).choose (2*s+1)) * ↑((3*t+1).choose (3*s+1)) / ↑((6*t+3).choose (6*s+3))        = (3*↑(2*s+1)) * ((((2*t+1).choose (2*s+1) : ℝ)) * (((3*t+1).choose (3*s+1) : ℝ)) / (((6*t+3).choose (6*s+3) : ℝ))) := by ring    rw [h1, h2]    exact mul_le_mul_of_nonneg_right haux (by positivity)
See it in the graphDiscuss this resultChallenge it