AFTD Auto-Formalizing Theoretical Domains

two_qubit_candidate_fidelity_bound_at_zero

theoremverifiedformalization

At adjusted entropy deficit ε = 0, the candidate fidelity bound equals 1.

Statement

theorem two_qubit_candidate_fidelity_bound_at_zero :
    two_qubit_candidate_fidelity_bound 0 = 1
Formalizes
OP-1552; arXiv:2409.01966
Verified
12 Nov 2026
Axioms
Classical.choiceQuot.soundpropext
Built on 2
  • two_qubit_candidate_fidelity_boundFor ε ≥ 0, two_qubit_candidate_fidelity_bound ε is the infimum over 0 ≤ p, q ≤ 1 of max{ p(1 + 2 sqrt(q(1 - q)))/2, (1 - p)/2 } subject to…
  • binary_entropy_natsThe binary entropy function in natural units (nats) is -x ln x - (1 - x) ln (1 - x) with the convention 0 ln 0 = 0.

Read back from the Lean

The value two_qubit_candidate_fidelity_bound 0 is equal to 1. That is, the infimum (sInf) over all real numbers F for which there exist real numbers p and q such that: 1. 0 ≤ p ≤ 1, 2. 0 ≤ q ≤ 1, 3. Real.log 2 + binary_entropy_nats p - binary_entropy_nats (p * q) ≤ 0, and 4. F = max (p * (1 + 2 * Real.sqrt (q * (1 - q))) / 2) ((1 - p) / 2) is equal to 1.

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 theorem proves that at zero deficit ε = 0, the two-qubit candidate fidelity bound equals 1. The bound is defined as the infimum of fidelities F achievable under the entropy deficit constraint log 2 + H(p) - H(pq) ≤ 0 for p, q ∈ [0, 1]. Because binary entropy is non-negative and bounded above by log 2, this constraint forces H(p) = 0 and H(pq) = log 2, which uniquely fixes p = 1 and q = 1/2 (since p = 0 would contradict pq = 1/2). Evaluating the fidelity formula at these parameters yields F = 1, showing the set of feasible fidelities is the singleton {1}, whose infimum is 1.

  1. The binary entropy function `binary_entropy_nats` coincides with Mathlib's `Real.binEntropy`.

    Rewriting with the definition of `binary_entropy_nats` and the library characterization `Real.binEntropy_eq_negMulLog_add_negMulLog_one_sub` shows both represent the function x ↦ -x log x - (1 - x) log(1 - x).

    lines 1–4

    uses Real.binEntropy_eq_negMulLog_add_negMulLog_one_sub

    lemma two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq (x : ℝ) :
        binary_entropy_nats x = Real.binEntropy x := by
      rw [binary_entropy_nats, Real.binEntropy_eq_negMulLog_add_negMulLog_one_sub]
    
  2. The binary entropy in nats at 1 is 0.

    This follows by converting `binary_entropy_nats` to `Real.binEntropy` and using the standard evaluation `Real.binEntropy 1 = 0`.

    lines 5–8

    uses two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq, Real.binEntropy_one

    lemma two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_one :
        binary_entropy_nats 1 = 0 := by
      rw [two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq, Real.binEntropy_one]
    
  3. The binary entropy in nats at 1/2 is log 2.

    Rewriting 1/2 as 2⁻¹ and using the library result `Real.binEntropy 2⁻¹ = log 2` gives the value.

    lines 9–14

    uses two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq, Real.binEntropy_two_inv

    lemma two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_half :
        binary_entropy_nats (1 / 2) = Real.log 2 := by
      rw [two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq]
      have h : (1 : ℝ) / 2 = 2⁻¹ := by norm_num
      rw [h, Real.binEntropy_two_inv]
    
  4. Unfold the candidate fidelity bound definition and reduce the theorem to showing that the feasible set is the singleton {1}.

    Unfolding `two_qubit_candidate_fidelity_bound` at deficit ε = 0 expresses it as the infimum of the set of fidelities F = max (p(1 + 2√(q(1 - q)))/2) ((1 - p)/2) subject to p, q ∈ [0, 1] and log 2 + H(p) - H(pq) ≤ 0. By extensionality, showing this set equals {1} reduces to two directions: every feasible fidelity must be 1, and 1 is achievable.

    lines 15–25

    uses Set.mem_ofPred_eq, Set.mem_singleton_iff

    /-- At zero deficit epsilon = 0, the candidate fidelity bound achieves the maximally entangled Bell state fidelity of 1. -/
    theorem two_qubit_candidate_fidelity_bound_at_zero :
        two_qubit_candidate_fidelity_bound 0 = 1 := by
      unfold two_qubit_candidate_fidelity_bound
      have hS : { F : ℝ | ∃ p q : ℝ,
          0 ≤ p ∧ p ≤ 1 ∧ 0 ≤ q ∧ q ≤ 1 ∧
          Real.log 2 + binary_entropy_nats p - binary_entropy_nats (p * q) ≤ 0 ∧
          F = max (p * (1 + 2 * Real.sqrt (q * (1 - q))) / 2) ((1 - p) / 2) } = {1} := by
        ext F
        simp only [Set.mem_ofPred_eq, Set.mem_singleton_iff]
        constructor
  5. Any feasible parameters (p, q) satisfy p ∈ {0, 1} and pq = 1/2.

    Rewriting `binary_entropy_nats` as `Real.binEntropy`, the entropy inequality is log 2 + H(p) - H(pq) ≤ 0. Because H(p) ≥ 0 for p ∈ [0, 1] and H(pq) ≤ log 2 universally, linear arithmetic forces H(p) = 0 and H(pq) = log 2. The only roots of H are p = 0 and p = 1, and the unique maximum of H is at pq = 1/2.

    lines 26–34

    uses two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq, Real.binEntropy_nonneg, Real.binEntropy_le_log_two, Real.binEntropy_eq_zero.mp, Real.binEntropy_eq_log_two.mp

        · rintro ⟨p, q, hp0, hp1, -, -, h_entropy, rfl⟩
          rw [two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq,
              two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq] at h_entropy
          have hp_nonneg : 0 ≤ Real.binEntropy p := Real.binEntropy_nonneg hp0 hp1
          have hpq_le : Real.binEntropy (p * q) ≤ Real.log 2 := Real.binEntropy_le_log_two
          have h_eq : Real.binEntropy p = 0 ∧ Real.binEntropy (p * q) = Real.log 2 := by
            constructor <;> linarith
          have hp_cases : p = 0 ∨ p = 1 := Real.binEntropy_eq_zero.mp h_eq.1
          have hpq_eq : p * q = 2⁻¹ := Real.binEntropy_eq_log_two.mp h_eq.2
  6. The case p = 0 is impossible, while p = 1 uniquely determines q = 1/2 and yields fidelity F = 1.

    If p = 0, then pq = 0, contradicting pq = 1/2. Hence p = 1, which implies 1 * q = q = 1/2. Substituting p = 1 and q = 1/2 into the fidelity formula, q(1 - q) = (1/2)², so √(q(1 - q)) = 1/2, making the first term max (1 * (1 + 2(1/2)) / 2) = 1 and the second term (1 - 1)/2 = 0. Therefore F = max 1 0 = 1.

    lines 35–48

    uses zero_mul, one_mul, Real.sqrt_sq

          cases hp_cases with
          | inl hp0' =>
            subst hp0'
            simp only [zero_mul] at hpq_eq
            have : (0 : ℝ) ≠ 2⁻¹ := by norm_num
            contradiction
          | inr hp1' =>
            subst hp1'
            simp only [one_mul] at hpq_eq
            have hq : q = 1 / 2 := by linarith
            subst hq
            have hs : (1 / 2 : ℝ) * (1 - 1 / 2) = (1 / 2) ^ 2 := by ring
            rw [hs, Real.sqrt_sq (by norm_num)]
            norm_num
  7. The candidate fidelity 1 is feasible, achieved by p = 1 and q = 1/2.

    For p = 1 and q = 1/2, the bounds 0 ≤ p ≤ 1 and 0 ≤ q ≤ 1 hold trivially. The entropy difference log 2 + H(1) - H(1/2) equals log 2 + 0 - log 2 = 0 ≤ 0. Finally, evaluating the formula with √(1/4) = 1/2 gives fidelity 1.

    lines 49–56

    uses one_mul, two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_one, two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_half, Real.sqrt_sq

        · rintro rfl
          refine ⟨1, 1 / 2, by norm_num, by norm_num, by norm_num, by norm_num, ?_, ?_⟩
          · rw [one_mul, two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_one,
                two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_half]
            linarith
          · have hs : (1 / 2 : ℝ) * (1 - 1 / 2) = (1 / 2) ^ 2 := by ring
            rw [hs, Real.sqrt_sq (by norm_num)]
            norm_num
  8. The candidate fidelity bound at ε = 0 equals 1.

    Substituting the set equality {F | ...} = {1} into the goal, the infimum sInf {1} evaluates to 1 by `csInf_singleton`.

    lines 57–58

    uses csInf_singleton

      rw [hS]
      exact csInf_singleton 1
Real.binEntropy_eq_negMulLog_add_negMulLog_one_sub
The binary entropy of p is p.negMulLog + (1 - p).negMulLog.
two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq
The binary entropy in nats binary_entropy_nats x equals Mathlib's Real.binEntropy x.
Real.binEntropy_one
The binary entropy of 1 is 0.
Real.binEntropy_two_inv
The binary entropy of 2⁻¹ = 1/2 is log 2.
Set.mem_ofPred_eq
Membership of x in a set-builder defined set {y | P y} is equivalent to P x.
Set.mem_singleton_iff
An element x is in {a} if and only if x = a.
Real.binEntropy_nonneg
For 0 ≤ p ≤ 1, the binary entropy binEntropy p is non-negative.
Real.binEntropy_le_log_two
For any real p, the binary entropy binEntropy p is at most log 2.
Real.binEntropy_eq_zero.mp
If binEntropy p = 0, then p = 0 or p = 1.
Real.binEntropy_eq_log_two.mp
If binEntropy p = log 2, then p = 2⁻¹.
zero_mul
Multiplication of zero by any element gives zero (0 * b = 0).
one_mul
Multiplication of any element by one on the left preserves it (1 * a = a).
Real.sqrt_sq
For x ≥ 0, √(x²) = x.
two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_one
The binary entropy in nats evaluated at 1 is 0.
two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_half
The binary entropy in nats evaluated at 1/2 is log 2.
csInf_singleton
The infimum of a singleton set {a} in a conditionally complete lattice is a.

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

lemma two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq (x : ℝ) :    binary_entropy_nats x = Real.binEntropy x := by  rw [binary_entropy_nats, Real.binEntropy_eq_negMulLog_add_negMulLog_one_sub]lemma two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_one :    binary_entropy_nats 1 = 0 := by  rw [two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq, Real.binEntropy_one]lemma two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_half :    binary_entropy_nats (1 / 2) = Real.log 2 := by  rw [two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq]  have h : (1 : ℝ) / 2 = 2⁻¹ := by norm_num  rw [h, Real.binEntropy_two_inv]/-- At zero deficit epsilon = 0, the candidate fidelity bound achieves the maximally entangled Bell state fidelity of 1. -/theorem two_qubit_candidate_fidelity_bound_at_zero :    two_qubit_candidate_fidelity_bound 0 = 1 := by  unfold two_qubit_candidate_fidelity_bound  have hS : { F : ℝ | ∃ p q : ℝ,      0 ≤ p ∧ p ≤ 1 ∧ 0 ≤ q ∧ q ≤ 1 ∧      Real.log 2 + binary_entropy_nats p - binary_entropy_nats (p * q) ≤ 0 ∧      F = max (p * (1 + 2 * Real.sqrt (q * (1 - q))) / 2) ((1 - p) / 2) } = {1} := by    ext F    simp only [Set.mem_ofPred_eq, Set.mem_singleton_iff]    constructor    · rintro ⟨p, q, hp0, hp1, -, -, h_entropy, rfl⟩      rw [two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq,          two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq] at h_entropy      have hp_nonneg : 0 ≤ Real.binEntropy p := Real.binEntropy_nonneg hp0 hp1      have hpq_le : Real.binEntropy (p * q) ≤ Real.log 2 := Real.binEntropy_le_log_two      have h_eq : Real.binEntropy p = 0 ∧ Real.binEntropy (p * q) = Real.log 2 := by        constructor <;> linarith      have hp_cases : p = 0 ∨ p = 1 := Real.binEntropy_eq_zero.mp h_eq.1      have hpq_eq : p * q = 2⁻¹ := Real.binEntropy_eq_log_two.mp h_eq.2      cases hp_cases with      | inl hp0' =>        subst hp0'        simp only [zero_mul] at hpq_eq        have : (0 : ℝ) ≠ 2⁻¹ := by norm_num        contradiction      | inr hp1' =>        subst hp1'        simp only [one_mul] at hpq_eq        have hq : q = 1 / 2 := by linarith        subst hq        have hs : (1 / 2 : ℝ) * (1 - 1 / 2) = (1 / 2) ^ 2 := by ring        rw [hs, Real.sqrt_sq (by norm_num)]        norm_num    · rintro rfl      refine ⟨1, 1 / 2, by norm_num, by norm_num, by norm_num, by norm_num, ?_, ?_⟩      · rw [one_mul, two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_one,            two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_half]        linarith      · have hs : (1 / 2 : ℝ) * (1 - 1 / 2) = (1 / 2) ^ 2 := by ring        rw [hs, Real.sqrt_sq (by norm_num)]        norm_num  rw [hS]  exact csInf_singleton 1
See it in the graphDiscuss this resultChallenge it