AFTD Auto-Formalizing Theoretical Domains

parity_effect_quantum_network_bounds

theoremverifiedformalization

For every natural number n with 1 <= n, and all real numbers p, q with 0 <= p, 0 <= q, p <= 1, and q <= 1, if ¬ Even n implies p^2 + q^2 <= 1, then Real.sqrt (p ^ (2 / (n : ℝ)) + q ^ (2 / (n : ℝ))) ≤ closed_network_bound n and p ^ (1 / (n : ℝ)) + q ^ (1 / (n : ℝ)) ≤ open_network_bound n.

Statement

theorem parity_effect_quantum_network_bounds
    (n : ℕ) (hn : 1 ≤ n) (p q : ℝ) (hp : 0 ≤ p) (hq : 0 ≤ q)
    (hp1 : p ≤ 1) (hq1 : q ≤ 1)
    (h_odd : ¬ Even n → p ^ 2 + q ^ 2 ≤ 1) :
    Real.sqrt (p ^ (2 / (n : ℝ)) + q ^ (2 / (n : ℝ))) ≤ closed_network_bound n ∧
    p ^ (1 / (n : ℝ)) + q ^ (1 / (n : ℝ)) ≤ open_network_bound n
Formalizes
arXiv:2610.35838 Theorem 4
Verified
01 Nov 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 3
  • closed_network_boundThe function closed_network_bound maps each natural number n to a real number, defined by cases: if n is even, it equals Real.sqrt 2;…
  • open_network_boundThe function open_network_bound maps each natural number n to a real number, defined by cases: if n is even, it equals 2; otherwise (if n…
  • concave_power_sum_leFor non-negative real numbers p and q such that p^2 + q^2 <= 1, and any real r with 0 < r <= 1, the sum of powers satisfies p^r + q^r <=…

Read back from the Lean

For every natural number $n \ge 1$ and all real numbers $p, q \in [0, 1]$, if $n$ is odd implies $p^2 + q^2 \le 1$, then both of the following bounds hold: 1. $\sqrt{p^{2/n} + q^{2/n}} \le \text{closed\_network\_bound}(n)$ 2. $p^{1/n} + q^{1/n} \le \text{open\_network\_bound}(n)$

Written by a model that saw only the Lean, never the English above. If the two disagree, that is worth a challenge.

The proof, explained

The proof analyzes the parity and value of n. When n is even, the closed and open network bounds evaluate to √2 and 2 respectively, and the inequalities follow immediately because p, q ≤ 1 implies p^r, q^r ≤ 1 for any positive exponent r. When n is odd, the hypothesis provides p^2 + q^2 ≤ 1. For n = 1, the bounds reduce to √(p^2 + q^2) ≤ 1 and p + q ≤ √2, verified directly using (p + q)^2 ≤ 2(p^2 + q^2). For odd n ≥ 2, the exponents 2/n and 1/n lie in (0, 1], allowing the lemma concave_power_sum_le to bound the power sums by the required expressions.

  1. n > 0 as a real number, and n is either even or odd.

    We cast the hypothesis 1 ≤ n to the real numbers to obtain 0 < n. We then split the proof into two cases depending on the parity of n via Nat.even_or_odd.

    lines 8–9

    uses Nat.even_or_odd

      have hnpos : (0:ℝ) < (n:ℝ) := by exact_mod_cast hn
      rcases Nat.even_or_odd n with hev | hod
  2. If n is even, closed_network_bound n = √2 and open_network_bound n = 2.

    Unfolding the definitions of closed_network_bound and open_network_bound, the condition Even n holds, so if_pos reduces each conditional expression to its true-branch value: √2 and 2, respectively.

    lines 10–15

    uses if_pos

      · have hcl : closed_network_bound n = Real.sqrt 2 := by
          simp only [closed_network_bound]
          rw [if_pos hev]
        have hop : open_network_bound n = 2 := by
          simp only [open_network_bound]
          rw [if_pos hev]
  3. If n is even, √(p^(2/n) + q^(2/n)) ≤ closed_network_bound n.

    Substituting closed_network_bound n = √2, we must show √(p^(2/n) + q^(2/n)) ≤ √2. Since 0 ≤ p, q ≤ 1 and 2/n > 0, Real.rpow_le_one yields p^(2/n) ≤ 1 and q^(2/n) ≤ 1. Summing them gives p^(2/n) + q^(2/n) ≤ 2, and applying monotonicity of square roots (Real.sqrt_le_sqrt) closes the goal.

    lines 16–21

    uses Real.sqrt_le_sqrt, Real.rpow_le_one

        constructor
        · rw [hcl]
          apply Real.sqrt_le_sqrt
          have h1 : p ^ (2/(n:ℝ)) ≤ 1 := Real.rpow_le_one hp hp1 (by positivity)
          have h2 : q ^ (2/(n:ℝ)) ≤ 1 := Real.rpow_le_one hq hq1 (by positivity)
          linarith
  4. If n is even, p^(1/n) + q^(1/n) ≤ open_network_bound n.

    Substituting open_network_bound n = 2, we apply Real.rpow_le_one with exponent 1/n > 0 to obtain p^(1/n) ≤ 1 and q^(1/n) ≤ 1. Adding these inequalities yields p^(1/n) + q^(1/n) ≤ 2.

    lines 22–25

    uses Real.rpow_le_one

        · rw [hop]
          have h1 : p ^ (1/(n:ℝ)) ≤ 1 := Real.rpow_le_one hp hp1 (by positivity)
          have h2 : q ^ (1/(n:ℝ)) ≤ 1 := Real.rpow_le_one hq hq1 (by positivity)
          linarith
  5. If n is odd, either n = 1 or n > 1; in the case n = 1, p^2 + q^2 ≤ 1.

    From 1 ≤ n, eq_or_lt_of_le separates the cases n = 1 and 1 < n. For n = 1, since 1 is not even, the hypothesis h_odd directly implies p^2 + q^2 ≤ 1.

    lines 26–30

    uses eq_or_lt_of_le

      · rcases eq_or_lt_of_le hn with h1 | h2
        · have hn1 : n = 1 := h1.symm
          subst hn1
          have h1odd : ¬ Even 1 := by rintro ⟨k, hk⟩; omega
          have hpq : p^2 + q^2 ≤ 1 := h_odd h1odd
  6. For n = 1, closed_network_bound 1 = 1 and open_network_bound 1 = √2.

    Since 1 is not even, if_neg selects the else-branch in both definitions: the closed bound becomes 2^(1/2 - 1/(2·1)) = 2^0 = 1, and the open bound becomes 2^(1 - 1/(2·1)) = 2^(1/2) = √2 by Real.sqrt_eq_rpow.

    lines 31–38

    uses if_neg, Real.sqrt_eq_rpow

          have hcl1 : closed_network_bound 1 = 1 := by
            simp only [closed_network_bound]
            rw [if_neg h1odd]
            norm_num
          have hop1 : open_network_bound 1 = Real.sqrt 2 := by
            simp only [open_network_bound]
            rw [if_neg h1odd, Real.sqrt_eq_rpow]
            norm_num
  7. For n = 1, √(p^(2/1) + q^(2/1)) ≤ closed_network_bound 1.

    For n = 1, the powers p^(2/1) and q^(2/1) simplify to p^2 and q^2 using Nat.cast_one, div_one, and Real.rpow_two. Since p^2 + q^2 ≤ 1, applying Real.sqrt_le_one gives √(p^2 + q^2) ≤ 1.

    lines 39–44

    uses Nat.cast_one, div_one, Real.rpow_two, Real.sqrt_le_one

          constructor
          · rw [hcl1]
            have hp2 : p ^ (2 / ((1:ℕ):ℝ)) = p^2 := by rw [Nat.cast_one, div_one, Real.rpow_two]
            have hq2 : q ^ (2 / ((1:ℕ):ℝ)) = q^2 := by rw [Nat.cast_one, div_one, Real.rpow_two]
            rw [hp2, hq2, Real.sqrt_le_one]
            exact hpq
  8. For n = 1, p^(1/1) + q^(1/1) ≤ open_network_bound 1.

    Using Real.rpow_one, the sum p^(1/1) + q^(1/1) simplifies to p + q. Since (p - q)^2 ≥ 0 (by sq_nonneg), expanding yields (p + q)^2 ≤ 2(p^2 + q^2) ≤ 2. By Real.le_sqrt, this is equivalent to p + q ≤ √2.

    lines 45–51

    uses Nat.cast_one, div_one, Real.rpow_one, sq_nonneg, Real.le_sqrt

          · rw [hop1]
            have hp1' : p ^ (1 / ((1:ℕ):ℝ)) = p := by rw [Nat.cast_one, div_one, Real.rpow_one]
            have hq1' : q ^ (1 / ((1:ℕ):ℝ)) = q := by rw [Nat.cast_one, div_one, Real.rpow_one]
            rw [hp1', hq1']
            have hsq : (p+q)^2 ≤ 2 := by nlinarith [sq_nonneg (p - q)]
            rw [Real.le_sqrt (by positivity) (by norm_num)]
            exact hsq
  9. For odd n ≥ 2, p^2 + q^2 ≤ 1 holds, and the network bounds simplify to 2^(1/2 - 1/(2n)) and 2^(1 - 1/(2n)).

    Since n > 1, we have 2 ≤ n. Because n is odd, it is not even (Nat.not_even_iff_odd.mpr), which triggers the hypothesis p^2 + q^2 ≤ 1. Applying if_neg to both definitions simplifies closed_network_bound n to 2^(1/2 - 1/(2n)) and open_network_bound n to 2^(1 - 1/(2n)).

    lines 52–61

    uses Nat.not_even_iff_odd.mpr, if_neg

        · have hn2 : 2 ≤ n := by omega
          have hne : ¬ Even n := Nat.not_even_iff_odd.mpr hod
          have hpq : p^2 + q^2 ≤ 1 := h_odd hne
          have hn0 : (n:ℝ) ≠ 0 := by positivity
          have hcl : closed_network_bound n = (2:ℝ)^(1/2 - 1/(2*(n:ℝ))) := by
            simp only [closed_network_bound]
            rw [if_neg hne]
          have hop : open_network_bound n = (2:ℝ)^(1 - 1/(2*(n:ℝ))) := by
            simp only [open_network_bound]
            rw [if_neg hne]
  10. For odd n ≥ 2, p^(2/n) + q^(2/n) ≤ 2^(1 - 1/n).

    Since n ≥ 2, the exponent r = 2/n satisfies 0 < r ≤ 1 by div_le_one. Applying the lemma concave_power_sum_le with r = 2/n and p^2 + q^2 ≤ 1 gives p^(2/n) + q^(2/n) ≤ 2^(1 - (2/n)/2) = 2^(1 - 1/n).

    lines 62–71

    uses div_le_one, concave_power_sum_le

          have hr1pos : 0 < 2/(n:ℝ) := by positivity
          have hr1le : 2/(n:ℝ) ≤ 1 := by
            rw [div_le_one (by positivity)]
            exact_mod_cast hn2
          have hconc1 := concave_power_sum_le p q (2/(n:ℝ)) hp hq hpq hr1pos hr1le
          have hkey : (1:ℝ) - (2/(n:ℝ))/2 = 1 - 1/(n:ℝ) := by
            field_simp
          have hsum : p ^ (2/(n:ℝ)) + q ^ (2/(n:ℝ)) ≤ (2:ℝ)^(1 - 1/(n:ℝ)) := by
            rw [hkey] at hconc1
            exact hconc1
  11. The exponent 1/n satisfies 0 < 1/n ≤ 1.

    The fraction 1/n is strictly positive because n > 0, and 1/n ≤ 1 follows from 1 ≤ n via div_le_one.

    lines 72–75

    uses div_le_one

          have hr2pos : 0 < 1/(n:ℝ) := by positivity
          have hr2le : 1/(n:ℝ) ≤ 1 := by
            rw [div_le_one (by positivity)]
            exact_mod_cast (show 1 ≤ n by omega)
  12. For odd n ≥ 2, √(p^(2/n) + q^(2/n)) ≤ closed_network_bound n.

    Taking the square root of both sides of p^(2/n) + q^(2/n) ≤ 2^(1 - 1/n) via Real.sqrt_le_sqrt, we rewrite √(2^(1 - 1/n)) as (2^(1 - 1/n))^(1/2) = 2^((1 - 1/n) * (1/2)) using Real.sqrt_eq_rpow and Real.rpow_mul. The exponent simplifies algebraically to 1/2 - 1/(2n), which matches closed_network_bound n.

    lines 76–82

    uses Real.sqrt_le_sqrt, Real.sqrt_eq_rpow, Real.rpow_mul

          constructor
          · rw [hcl]
            calc Real.sqrt (p^(2/(n:ℝ))+q^(2/(n:ℝ))) ≤ Real.sqrt ((2:ℝ)^(1-1/(n:ℝ))) := Real.sqrt_le_sqrt hsum
              _ = (2:ℝ)^(1/2 - 1/(2*(n:ℝ))) := by
                  rw [Real.sqrt_eq_rpow, ← Real.rpow_mul (by norm_num : (0:ℝ) ≤ 2)]
                  congr 1
                  field_simp
  13. For odd n ≥ 2, p^(1/n) + q^(1/n) ≤ open_network_bound n.

    Applying concave_power_sum_le with exponent r = 1/n directly gives p^(1/n) + q^(1/n) ≤ 2^(1 - (1/n)/2) = 2^(1 - 1/(2n)), which equals open_network_bound n.

    lines 83–88

    uses concave_power_sum_le

          · rw [hop]
            calc p^(1/(n:ℝ))+q^(1/(n:ℝ)) ≤ (2:ℝ)^(1 - (1/(n:ℝ))/2) :=
                  concave_power_sum_le p q (1/(n:ℝ)) hp hq hpq hr2pos hr2le
              _ = (2:ℝ)^(1 - 1/(2*(n:ℝ))) := by
                  congr 1
                  field_simp
Nat.even_or_odd
For any natural number n, n is either even or odd.
if_pos
If a condition c is true, then if c then t else e evaluates to t.
Real.sqrt_le_sqrt
The square root function on real numbers is order-preserving: x ≤ y implies √x ≤ √y.
Real.rpow_le_one
If 0 ≤ x ≤ 1 and z ≥ 0, then x^z ≤ 1.
eq_or_lt_of_le
In a partial order, a ≤ b implies a = b or a < b.
if_neg
If a condition c is false, then if c then t else e evaluates to e.
Real.sqrt_eq_rpow
For any real number x, √x = x^(1/2).
Nat.cast_one
The natural number 1 cast to a ring equals 1.
div_one
Dividing any element by 1 leaves it unchanged: a / 1 = a.
Real.rpow_two
For any real number x, the real power x^2 coincides with the squaring operation x^2.
Real.sqrt_le_one
For any real number x, √x ≤ 1 if and only if x ≤ 1.
Real.rpow_one
Raising a real number to the power 1 leaves it unchanged: x^1 = x.
sq_nonneg
The square of any real number is non-negative: a^2 ≥ 0.
Real.le_sqrt
For non-negative real numbers x and y, x ≤ √y if and only if x^2 ≤ y.
Nat.not_even_iff_odd.mpr
If a natural number is odd, then it is not even.
div_le_one
For b > 0, a / b ≤ 1 if and only if a ≤ b.
concave_power_sum_le
For non-negative p, q with p^2 + q^2 ≤ 1 and 0 < r ≤ 1, the sum of powers satisfies p^r + q^r ≤ 2^(1 - r/2).
Real.rpow_mul
For a non-negative real number x and real numbers y, z, x^(y * z) = (x^y)^z.

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

/-- Parity effect and tight quantum bounds for n-source networks (Theorem 4). -/theorem parity_effect_quantum_network_bounds    (n : ℕ) (hn : 1 ≤ n) (p q : ℝ) (hp : 0 ≤ p) (hq : 0 ≤ q)    (hp1 : p ≤ 1) (hq1 : q ≤ 1)    (h_odd : ¬ Even n → p ^ 2 + q ^ 2 ≤ 1) :    Real.sqrt (p ^ (2 / (n : ℝ)) + q ^ (2 / (n : ℝ))) ≤ closed_network_bound n ∧    p ^ (1 / (n : ℝ)) + q ^ (1 / (n : ℝ)) ≤ open_network_bound n := by  have hnpos : (0:ℝ) < (n:ℝ) := by exact_mod_cast hn  rcases Nat.even_or_odd n with hev | hod  · have hcl : closed_network_bound n = Real.sqrt 2 := by      simp only [closed_network_bound]      rw [if_pos hev]    have hop : open_network_bound n = 2 := by      simp only [open_network_bound]      rw [if_pos hev]    constructor    · rw [hcl]      apply Real.sqrt_le_sqrt      have h1 : p ^ (2/(n:ℝ)) ≤ 1 := Real.rpow_le_one hp hp1 (by positivity)      have h2 : q ^ (2/(n:ℝ)) ≤ 1 := Real.rpow_le_one hq hq1 (by positivity)      linarith    · rw [hop]      have h1 : p ^ (1/(n:ℝ)) ≤ 1 := Real.rpow_le_one hp hp1 (by positivity)      have h2 : q ^ (1/(n:ℝ)) ≤ 1 := Real.rpow_le_one hq hq1 (by positivity)      linarith  · rcases eq_or_lt_of_le hn with h1 | h2    · have hn1 : n = 1 := h1.symm      subst hn1      have h1odd : ¬ Even 1 := by rintro ⟨k, hk⟩; omega      have hpq : p^2 + q^2 ≤ 1 := h_odd h1odd      have hcl1 : closed_network_bound 1 = 1 := by        simp only [closed_network_bound]        rw [if_neg h1odd]        norm_num      have hop1 : open_network_bound 1 = Real.sqrt 2 := by        simp only [open_network_bound]        rw [if_neg h1odd, Real.sqrt_eq_rpow]        norm_num      constructor      · rw [hcl1]        have hp2 : p ^ (2 / ((1:ℕ):ℝ)) = p^2 := by rw [Nat.cast_one, div_one, Real.rpow_two]        have hq2 : q ^ (2 / ((1:ℕ):ℝ)) = q^2 := by rw [Nat.cast_one, div_one, Real.rpow_two]        rw [hp2, hq2, Real.sqrt_le_one]        exact hpq      · rw [hop1]        have hp1' : p ^ (1 / ((1:ℕ):ℝ)) = p := by rw [Nat.cast_one, div_one, Real.rpow_one]        have hq1' : q ^ (1 / ((1:ℕ):ℝ)) = q := by rw [Nat.cast_one, div_one, Real.rpow_one]        rw [hp1', hq1']        have hsq : (p+q)^2 ≤ 2 := by nlinarith [sq_nonneg (p - q)]        rw [Real.le_sqrt (by positivity) (by norm_num)]        exact hsq    · have hn2 : 2 ≤ n := by omega      have hne : ¬ Even n := Nat.not_even_iff_odd.mpr hod      have hpq : p^2 + q^2 ≤ 1 := h_odd hne      have hn0 : (n:ℝ) ≠ 0 := by positivity      have hcl : closed_network_bound n = (2:ℝ)^(1/2 - 1/(2*(n:ℝ))) := by        simp only [closed_network_bound]        rw [if_neg hne]      have hop : open_network_bound n = (2:ℝ)^(1 - 1/(2*(n:ℝ))) := by        simp only [open_network_bound]        rw [if_neg hne]      have hr1pos : 0 < 2/(n:ℝ) := by positivity      have hr1le : 2/(n:ℝ) ≤ 1 := by        rw [div_le_one (by positivity)]        exact_mod_cast hn2      have hconc1 := concave_power_sum_le p q (2/(n:ℝ)) hp hq hpq hr1pos hr1le      have hkey : (1:ℝ) - (2/(n:ℝ))/2 = 1 - 1/(n:ℝ) := by        field_simp      have hsum : p ^ (2/(n:ℝ)) + q ^ (2/(n:ℝ)) ≤ (2:ℝ)^(1 - 1/(n:ℝ)) := by        rw [hkey] at hconc1        exact hconc1      have hr2pos : 0 < 1/(n:ℝ) := by positivity      have hr2le : 1/(n:ℝ) ≤ 1 := by        rw [div_le_one (by positivity)]        exact_mod_cast (show 1 ≤ n by omega)      constructor      · rw [hcl]        calc Real.sqrt (p^(2/(n:ℝ))+q^(2/(n:ℝ))) ≤ Real.sqrt ((2:ℝ)^(1-1/(n:ℝ))) := Real.sqrt_le_sqrt hsum          _ = (2:ℝ)^(1/2 - 1/(2*(n:ℝ))) := by              rw [Real.sqrt_eq_rpow, ← Real.rpow_mul (by norm_num : (0:ℝ) ≤ 2)]              congr 1              field_simp      · rw [hop]        calc p^(1/(n:ℝ))+q^(1/(n:ℝ)) ≤ (2:ℝ)^(1 - (1/(n:ℝ))/2) :=              concave_power_sum_le p q (1/(n:ℝ)) hp hq hpq hr2pos hr2le          _ = (2:ℝ)^(1 - 1/(2*(n:ℝ))) := by              congr 1              field_simp
See it in the graphDiscuss this resultChallenge it