zzhisthebest/LeanBenchmark huggingface dataset:
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_11 {n : ℕ+} {t μ : ℝ} {h : EuclideanSpace ℝ (Fin ↑n) → ℝ}
  (lasso : h = fun y => μ • ∑ i, ‖y i‖) (x xm : EuclideanSpace ℝ (Fin ↑n)) (tpos : 0 < t) (μpos : 0 < μ)
  (minpoint : ∀ (i : Fin ↑n), xm i = sign (x i) * ((|x i| - t * μ) ⊔ 0)) :
  let g := (t * μ) • fun x => ∑ i, ‖x i‖;
  g = t • h →
    0 < t * μ →
      ∀ (y : EuclideanSpace ℝ (Fin ↑n)),
        ∀ i ∈ Finset.univ,
          let abs_subg := SubderivAt_abs (xm i);
          ¬xm i = 0 →
            |xm i| + (y i - xm i) * (μ⁻¹ * t⁻¹ * (x i - xm i)) ≤ |y i| →
              ¬(xm i = 0 ∧ SubderivAt abs (xm i) = Set.Icc (-1) 1) := sorry

Tactic state before:
case neg
n : ℕ+
t μ : ℝ
h : EuclideanSpace ℝ (Fin ↑n) → ℝ
lasso : h = fun y => μ • ∑ i, ‖y i‖
x xm : EuclideanSpace ℝ (Fin ↑n)
tpos : 0 < t
μpos : 0 < μ
minpoint : ∀ (i : Fin ↑n), xm i = sign (x i) * ((|x i| - t * μ) ⊔ 0)
g : EuclideanSpace ℝ (Fin ↑n) → ℝ := (t * μ) • fun x => ∑ i, ‖x i‖
geqth : g = t • h
tμpos : 0 < t * μ
y : EuclideanSpace ℝ (Fin ↑n)
i : Fin ↑n
a✝ : i ∈ Finset.univ
abs_subg : SubderivAt abs (xm i) = if xm i = 0 then Set.Icc (-1) 1 else {sign (xm i)} := SubderivAt_abs (xm i)
hxm : ¬xm i = 0
⊢ |xm i| + (y i - xm i) * (μ⁻¹ * t⁻¹ * (x i - xm i)) ≤ |y i|

Tactic:
rw [eq_ite_iff, or_iff_right] at abs_subg
    rcases abs_subg with ⟨_, abs_subg⟩
    let sgnxm := sign (xm i)
    have aux : sgnxm ∈ SubderivAt abs (xm i) := by rw [abs_subg]; simp [sgnxm]
    rw [← mem_SubderivAt, HasSubgradientAt] at aux

Tactic state after:
[case neg.intro
 n : ℕ+
 t μ : ℝ
 h : EuclideanSpace ℝ (Fin ↑n) → ℝ
 lasso : h = fun y => μ • ∑ i, ‖y i‖
 x xm : EuclideanSpace ℝ (Fin ↑n)
 tpos : 0 < t
 μpos : 0 < μ
 minpoint : ∀ (i : Fin ↑n), xm i = sign (x i) * ((|x i| - t * μ) ⊔ 0)
 g : EuclideanSpace ℝ (Fin ↑n) → ℝ := (t * μ) • fun x => ∑ i, ‖x i‖
 geqth : g = t • h
 tμpos : 0 < t * μ
 y : EuclideanSpace ℝ (Fin ↑n)
 i : Fin ↑n
 a✝ : i ∈ Finset.univ
 hxm : ¬xm i = 0
 left✝ : ¬xm i = 0
 abs_subg : SubderivAt abs (xm i) = {sign (xm i)}
 sgnxm : ℝ := sign (xm i)
 aux : ∀ (y : ℝ), |y| ≥ |xm i| + inner sgnxm (y - xm i)
 ⊢ |xm i| + (y i - xm i) * (μ⁻¹ * t⁻¹ * (x i - xm i)) ≤ |y i|,
 case neg
 n : ℕ+
 t μ : ℝ
 h : EuclideanSpace ℝ (Fin ↑n) → ℝ
 lasso : h = fun y => μ • ∑ i, ‖y i‖
 x xm : EuclideanSpace ℝ (Fin ↑n)
 tpos : 0 < t
 μpos : 0 < μ
 minpoint : ∀ (i : Fin ↑n), xm i = sign (x i) * ((|x i| - t * μ) ⊔ 0)
 g : EuclideanSpace ℝ (Fin ↑n) → ℝ := (t * μ) • fun x => ∑ i, ‖x i‖
 geqth : g = t • h
 tμpos : 0 < t * μ
 y : EuclideanSpace ℝ (Fin ↑n)
 i : Fin ↑n
 a✝ : i ∈ Finset.univ
 abs_subg : xm i = 0 ∧ SubderivAt abs (xm i) = Set.Icc (-1) 1 ∨ ¬xm i = 0 ∧ SubderivAt abs (xm i) = {sign (xm i)}
 hxm : ¬xm i = 0
 ⊢ ¬(xm i = 0 ∧ SubderivAt abs (xm i) = Set.Icc (-1) 1)]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_12 {n : ℕ+} {t μ : ℝ} {h : EuclideanSpace ℝ (Fin ↑n) → ℝ}
  (lasso : h = fun y => μ • ∑ i, ‖y i‖) (x xm : EuclideanSpace ℝ (Fin ↑n)) (tpos : 0 < t) (μpos : 0 < μ)
  (minpoint : ∀ (i : Fin ↑n), xm i = sign (x i) * ((|x i| - t * μ) ⊔ 0)) :
  let g := (t * μ) • fun x => ∑ i, ‖x i‖;
  g = t • h →
    0 < t * μ →
      ∀ (y : EuclideanSpace ℝ (Fin ↑n)),
        ∀ i ∈ Finset.univ,
          ¬xm i = 0 →
            ¬xm i = 0 →
              SubderivAt abs (xm i) = {sign (xm i)} →
                let sgnxm := sign (xm i);
                |y i| ≥ |xm i| + inner sgnxm (y i - xm i) →
                  inner sgnxm (y i - xm i) = μ⁻¹ * t⁻¹ * (x i - xm i) * (y i - xm i) →
                    (y i - sign (x i) * ((|x i| - t * μ) ⊔ 0)) * (sign (x i) * ((|x i| - t * μ) ⊔ 0)).sign =
                      μ⁻¹ * t⁻¹ * (x i - sign (x i) * ((|x i| - t * μ) ⊔ 0)) *
                        (y i - sign (x i) * ((|x i| - t * μ) ⊔ 0)) := sorry

Tactic state before:
n : ℕ+
t μ : ℝ
h : EuclideanSpace ℝ (Fin ↑n) → ℝ
lasso : h = fun y => μ • ∑ i, ‖y i‖
x xm : EuclideanSpace ℝ (Fin ↑n)
tpos : 0 < t
μpos : 0 < μ
minpoint : ∀ (i : Fin ↑n), xm i = sign (x i) * ((|x i| - t * μ) ⊔ 0)
g : EuclideanSpace ℝ (Fin ↑n) → ℝ := (t * μ) • fun x => ∑ i, ‖x i‖
geqth : g = t • h
tμpos : 0 < t * μ
y : EuclideanSpace ℝ (Fin ↑n)
i : Fin ↑n
a✝ : i ∈ Finset.univ
hxm : ¬xm i = 0
left✝ : ¬xm i = 0
abs_subg : SubderivAt abs (xm i) = {sign (xm i)}
sgnxm : ℝ := sign (xm i)
aux : |y i| ≥ |xm i| + inner sgnxm (y i - xm i)
⊢ inner sgnxm (y i - xm i) = μ⁻¹ * t⁻¹ * (x i - xm i) * (y i - xm i)

Tactic:
simp [sgnxm]
    rw [minpoint]
    simp
    rw [minpoint] at hxm
    simp at hxm

Tactic state after:
[n : ℕ+
 t μ : ℝ
 h : EuclideanSpace ℝ (Fin ↑n) → ℝ
 lasso : h = fun y => μ • ∑ i, ‖y i‖
 x xm : EuclideanSpace ℝ (Fin ↑n)
 tpos : 0 < t
 μpos : 0 < μ
 minpoint : ∀ (i : Fin ↑n), xm i = sign (x i) * ((|x i| - t * μ) ⊔ 0)
 g : EuclideanSpace ℝ (Fin ↑n) → ℝ := (t * μ) • fun x => ∑ i, ‖x i‖
 geqth : g = t • h
 tμpos : 0 < t * μ
 y : EuclideanSpace ℝ (Fin ↑n)
 i : Fin ↑n
 a✝ : i ∈ Finset.univ
 left✝ : ¬xm i = 0
 abs_subg : SubderivAt abs (xm i) = {sign (xm i)}
 sgnxm : ℝ := sign (xm i)
 aux : |y i| ≥ |xm i| + inner sgnxm (y i - xm i)
 hxm : ¬x i = 0 ∧ t * μ < |x i|
 ⊢ (y i - sign (x i) * ((|x i| - t * μ) ⊔ 0)) * (sign (x i) * ((|x i| - t * μ) ⊔ 0)).sign =
     μ⁻¹ * t⁻¹ * (x i - sign (x i) * ((|x i| - t * μ) ⊔ 0)) * (y i - sign (x i) * ((|x i| - t * μ) ⊔ 0))]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_16 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {μ : ℝ} {μpos : 0 < μ} {Ane0 : A ≠ 0}
  (x : EuclideanSpace ℝ (Fin ↑n)) (a : x ∈ Set.univ) (ε : ℝ) (εpos : ε > 0) : 0 < ε / ↑↑n / μ := sorry

Tactic state before:
n m : ℕ+
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
b : Fin ↑m → ℝ
μ : ℝ
μpos : 0 < μ
Ane0 : A ≠ 0
x₀ : EuclideanSpace ℝ (Fin ↑n)
p : LASSO A b μ μpos Ane0 x₀
x : EuclideanSpace ℝ (Fin ↑n)
a✝ : x ∈ Set.univ
ε : ℝ
εpos : ε > 0
⊢ 0 < ε / ↑↑n / μ

Tactic:
apply div_pos
    apply div_pos
    linarith
    simp
    linarith

Tactic state after:
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_17 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {b : Fin ↑m → ℝ} {μ : ℝ} {μpos : 0 < μ}
  {Ane0 : A ≠ 0} {x₀ : EuclideanSpace ℝ (Fin ↑n)} (p : LASSO A b μ μpos Ane0 x₀) (x : EuclideanSpace ℝ (Fin ↑n))
  (a : x ∈ Set.univ) (ε : ℝ) (εpos : ε > 0) (y : EuclideanSpace ℝ (Fin ↑n)) (ydist : ‖x - y‖ ≤ ε / ↑↑n / μ)
  (h_original_goal : ‖p.h y - p.h x‖ ≤ ε) : |μ| * |∑ x_1, (|y x_1| - |x x_1|)| ≤ ε := sorry

Tactic state before:
case h.right
n m : ℕ+
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
b : Fin ↑m → ℝ
μ : ℝ
μpos : 0 < μ
Ane0 : A ≠ 0
x₀ : EuclideanSpace ℝ (Fin ↑n)
p : LASSO A b μ μpos Ane0 x₀
x : EuclideanSpace ℝ (Fin ↑n)
a✝ : x ∈ Set.univ
ε : ℝ
εpos : ε > 0
y : EuclideanSpace ℝ (Fin ↑n)
ydist : ‖x - y‖ ≤ ε / ↑↑n / μ
⊢ ‖p.h y - p.h x‖ ≤ ε

Tactic:
rw [p.heq]
    simp
    rw [← mul_sub, ← sum_sub_distrib]
    have le (i : Fin n) : |(|y i|) - (|x i|)| ≤ ε / n / μ :=
  by
  rw [EuclideanSpace.norm_eq] at ydist; rw [Real.sqrt_le_iff] at ydist
  have aux : ‖(x - y) i‖ ^ 2 ≤ (ε / n / μ) ^ 2 := by
    calc
      ‖(x - y) i‖ ^ 2 = Finset.sum { i } fun i ↦ ‖(x - y) i‖ ^ 2 := by simp
      _ ≤ Finset.sum Finset.univ fun i ↦ ‖(x - y) i‖ ^ 2 :=
        by
        apply sum_le_sum_of_subset_of_nonneg; simp
        intro j _ _; apply sq_nonneg
      _ ≤ (ε / n / μ) ^ 2 := ydist.2
  calc
    |(|y i|) - (|x i|)| ≤ ‖(x - y) i‖ := by simp; rw [abs_sub_comm]; apply abs_abs_sub_abs_le_abs_sub
    _ ≤ (ε / n / μ) := by
      rw [sq_le_sq] at aux
      have : |ε / n / μ| = ε / n / μ := by rw [abs_eq_self]; linarith
      rw [← this]; simp at aux; exact aux
    rw [abs_mul]

Tactic state after:
[case h.right
 n m : ℕ+
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 b : Fin ↑m → ℝ
 μ : ℝ
 μpos : 0 < μ
 Ane0 : A ≠ 0
 x₀ : EuclideanSpace ℝ (Fin ↑n)
 p : LASSO A b μ μpos Ane0 x₀
 x : EuclideanSpace ℝ (Fin ↑n)
 a✝ : x ∈ Set.univ
 ε : ℝ
 εpos : ε > 0
 y : EuclideanSpace ℝ (Fin ↑n)
 ydist : ‖x - y‖ ≤ ε / ↑↑n / μ
 le : ∀ (i : Fin ↑n), ||y i| - |x i|| ≤ ε / ↑↑n / μ
 ⊢ |μ| * |∑ x_1, (|y x_1| - |x x_1|)| ≤ ε]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_18 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {b : Fin ↑m → ℝ} {μ : ℝ} {μpos : 0 < μ}
  {Ane0 : A ≠ 0} {x₀ : EuclideanSpace ℝ (Fin ↑n)} (p : LASSO A b μ μpos Ane0 x₀) (h_original_goal : 0 < p.t) :
  ¬A = 0 := sorry

Tactic state before:
n m : ℕ+
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
b : Fin ↑m → ℝ
μ : ℝ
μpos : 0 < μ
Ane0 : A ≠ 0
x₀ : EuclideanSpace ℝ (Fin ↑n)
p : LASSO A b μ μpos Ane0 x₀
⊢ 0 < p.t

Tactic:
rw [p.teq]
    simp
    rw [p.Leq]
    simp
    rw [Transpose_mul_self_eq_zero]

Tactic state after:
[n m : ℕ+
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 b : Fin ↑m → ℝ
 μ : ℝ
 μpos : 0 < μ
 Ane0 : A ≠ 0
 x₀ : EuclideanSpace ℝ (Fin ↑n)
 p : LASSO A b μ μpos Ane0 x₀
 ⊢ ¬A = 0]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_19 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {b : Fin ↑m → ℝ} {μ : ℝ} {μpos : 0 < μ}
  {Ane0 : A ≠ 0} {x₀ : EuclideanSpace ℝ (Fin ↑n)} (p : LASSO A b μ μpos Ane0 x₀) (k : ℕ) :
  prox_prop (p.t • p.h) (p.x k - p.t • p.f' (p.x k)) (p.x (k + 1)) := sorry

Tactic state before:
n m : ℕ+
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
b : Fin ↑m → ℝ
μ : ℝ
μpos : 0 < μ
Ane0 : A ≠ 0
x₀ : EuclideanSpace ℝ (Fin ↑n)
p : LASSO A b μ μpos Ane0 x₀
k : ℕ
⊢ prox_prop (p.t • p.h) (p.x k - p.t • p.f' (p.x k)) (p.x (k + 1))

Tactic:
apply norm_one_proximal
    · rw [p.heq]
    ·
  rw [p.teq]; simp
  rw [p.Leq]; simp
  rw [Transpose_mul_self_eq_zero]
  exact Ane0
    · linarith
    · intro i; rw [p.update2 k, p.update1 k]

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter Bornology Metric Real

theorem extracted_formal_statement_0.{u_3, u_2, u_1} {E₁ : Type u_1} {E₂ : Type u_2} {F : Type u_3}
  [inst : NormedAddCommGroup E₁] [inst_1 : InnerProductSpace ℝ E₁] [inst_2 : FiniteDimensional ℝ E₁]
  [inst_3 : NormedAddCommGroup E₂] [inst_4 : InnerProductSpace ℝ E₂] [inst_5 : FiniteDimensional ℝ E₂]
  [inst_6 : NormedAddCommGroup F] [inst_7 : InnerProductSpace ℝ F] [inst_8 : FiniteDimensional ℝ F]
  {admm : ADMM E₁ E₂ F} {admm_kkt : Existance_of_kkt admm} (h1 : 0 < ADMM.τ E₁ E₂ F)
  (right : ADMM.τ E₁ E₂ F < (1 + √5) / 2)
  (h0 : 1 + ADMM.τ E₁ E₂ F - ADMM.τ E₁ E₂ F ^ 2 = -(ADMM.τ E₁ E₂ F - 1 / 2) ^ 2 + 5 / 4)
  (h_original_goal : 1 + ADMM.τ E₁ E₂ F - ADMM.τ E₁ E₂ F ^ 2 > 0) : |ADMM.τ E₁ E₂ F - 2⁻¹| < |(|√5 / 2|)| := sorry

Tactic state before:
case intro
E₁ : Type u_1
E₂ : Type u_2
F : Type u_3
inst✝⁹ : NormedAddCommGroup E₁
inst✝⁸ : InnerProductSpace ℝ E₁
inst✝⁷ : FiniteDimensional ℝ E₁
inst✝⁶ : NormedAddCommGroup E₂
inst✝⁵ : InnerProductSpace ℝ E₂
inst✝⁴ : FiniteDimensional ℝ E₂
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
inst✝¹ : FiniteDimensional ℝ F
admm : ADMM E₁ E₂ F
admm_kkt : Existance_of_kkt admm
inst✝ : Setting E₁ E₂ F admm admm_kkt
h1 : 0 < ADMM.τ E₁ E₂ F
right✝ : ADMM.τ E₁ E₂ F < (1 + √5) / 2
h0 : 1 + ADMM.τ E₁ E₂ F - ADMM.τ E₁ E₂ F ^ 2 = -(ADMM.τ E₁ E₂ F - 1 / 2) ^ 2 + 5 / 4
⊢ 1 + ADMM.τ E₁ E₂ F - ADMM.τ E₁ E₂ F ^ 2 > 0

Tactic:
rw [h0]
    simp only [one_div, gt_iff_lt, lt_neg_add_iff_add_lt, add_zero]
    have h2 : 5 / 4 = |√5 / 2| ^ 2 := by rw [sq_abs]; field_simp; norm_num
    rw [h2]
    apply sq_lt_sq.mpr

Tactic state after:
[case intro
 E₁ : Type u_1
 E₂ : Type u_2
 F : Type u_3
 inst✝⁹ : NormedAddCommGroup E₁
 inst✝⁸ : InnerProductSpace ℝ E₁
 inst✝⁷ : FiniteDimensional ℝ E₁
 inst✝⁶ : NormedAddCommGroup E₂
 inst✝⁵ : InnerProductSpace ℝ E₂
 inst✝⁴ : FiniteDimensional ℝ E₂
 inst✝³ : NormedAddCommGroup F
 inst✝² : InnerProductSpace ℝ F
 inst✝¹ : FiniteDimensional ℝ F
 admm : ADMM E₁ E₂ F
 admm_kkt : Existance_of_kkt admm
 inst✝ : Setting E₁ E₂ F admm admm_kkt
 h1 : 0 < ADMM.τ E₁ E₂ F
 right✝ : ADMM.τ E₁ E₂ F < (1 + √5) / 2
 h0 : 1 + ADMM.τ E₁ E₂ F - ADMM.τ E₁ E₂ F ^ 2 = -(ADMM.τ E₁ E₂ F - 1 / 2) ^ 2 + 5 / 4
 h2 : 5 / 4 = |√5 / 2| ^ 2
 ⊢ |ADMM.τ E₁ E₂ F - 2⁻¹| < |(|√5 / 2|)|]
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter Bornology Metric Real

theorem extracted_formal_statement_1.{u_3, u_2, u_1} {E₁ : Type u_1} {E₂ : Type u_2} {F : Type u_3}
  [inst : NormedAddCommGroup E₁] [inst_1 : InnerProductSpace ℝ E₁] [inst_2 : FiniteDimensional ℝ E₁]
  [inst_3 : NormedAddCommGroup E₂] [inst_4 : InnerProductSpace ℝ E₂] [inst_5 : FiniteDimensional ℝ E₂]
  [inst_6 : NormedAddCommGroup F] [inst_7 : InnerProductSpace ℝ F] [inst_8 : FiniteDimensional ℝ F]
  {admm : ADMM E₁ E₂ F} {admm_kkt : Existance_of_kkt admm} (h : ADMM.τ E₁ E₂ F > 1)
  (hb : 1 - 1 / ADMM.τ E₁ E₂ F ≥ 1 - ADMM.τ E₁ E₂ F) : (1 - ADMM.τ E₁ E₂ F) ⊔ (1 - 1 / ADMM.τ E₁ E₂ F) ≥ 0 := sorry

Tactic state before:
E₁ : Type u_1
E₂ : Type u_2
F : Type u_3
inst✝⁹ : NormedAddCommGroup E₁
inst✝⁸ : InnerProductSpace ℝ E₁
inst✝⁷ : FiniteDimensional ℝ E₁
inst✝⁶ : NormedAddCommGroup E₂
inst✝⁵ : InnerProductSpace ℝ E₂
inst✝⁴ : FiniteDimensional ℝ E₂
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
inst✝¹ : FiniteDimensional ℝ F
admm : ADMM E₁ E₂ F
admm_kkt : Existance_of_kkt admm
inst✝ : Setting E₁ E₂ F admm admm_kkt
h : ADMM.τ E₁ E₂ F > 1
hb : 1 - 1 / ADMM.τ E₁ E₂ F ≥ 1 - ADMM.τ E₁ E₂ F
⊢ (1 - ADMM.τ E₁ E₂ F) ⊔ (1 - 1 / ADMM.τ E₁ E₂ F) ≥ 0

Tactic:
rw [max_eq_right hb]
    apply sub_nonneg_of_le
    rw [one_div]
    apply inv_le_one_of_one_le₀
    linarith

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter Bornology Metric Real

theorem extracted_formal_statement_2.{u_3, u_2, u_1} {E₁ : Type u_1} {E₂ : Type u_2} {F : Type u_3}
  [inst : NormedAddCommGroup E₁] [inst_1 : InnerProductSpace ℝ E₁] [inst_2 : FiniteDimensional ℝ E₁]
  [inst_3 : NormedAddCommGroup E₂] [inst_4 : InnerProductSpace ℝ E₂] [inst_5 : FiniteDimensional ℝ E₂]
  [inst_6 : NormedAddCommGroup F] [inst_7 : InnerProductSpace ℝ F] [inst_8 : FiniteDimensional ℝ F]
  {admm : ADMM E₁ E₂ F} {admm_kkt : Existance_of_kkt admm} [inst_9 : Setting E₁ E₂ F admm admm_kkt] (n : ℕ)
  (h1 : 0 < ADMM.τ E₁ E₂ F) (right : ADMM.τ E₁ E₂ F < (1 + √5) / 2) : Φ n ≥ 0 := sorry

Tactic state before:
case intro
E₁ : Type u_1
E₂ : Type u_2
F : Type u_3
inst✝⁹ : NormedAddCommGroup E₁
inst✝⁸ : InnerProductSpace ℝ E₁
inst✝⁷ : FiniteDimensional ℝ E₁
inst✝⁶ : NormedAddCommGroup E₂
inst✝⁵ : InnerProductSpace ℝ E₂
inst✝⁴ : FiniteDimensional ℝ E₂
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
inst✝¹ : FiniteDimensional ℝ F
admm : ADMM E₁ E₂ F
admm_kkt : Existance_of_kkt admm
inst✝ : Setting E₁ E₂ F admm admm_kkt
n : ℕ
h1 : 0 < ADMM.τ E₁ E₂ F
right✝ : ADMM.τ E₁ E₂ F < (1 + √5) / 2
⊢ Φ n ≥ 0

Tactic:
simp [Φ]
    have h2 : Ψ n ≥ 0 := by
  simp [Ψ]; apply add_nonneg; repeat apply mul_nonneg
  apply inv_nonneg_of_nonneg; apply le_of_lt admm.hrho
  apply inv_nonneg_of_nonneg; apply le_of_lt h1
  apply pow_two_nonneg; apply mul_nonneg; apply le_of_lt admm.hrho; apply pow_two_nonneg
    have h3 : ((max (1 - τ) (1 - 1 / τ)) * ρ) * ‖A₁ ((e₁) n) + A₂ ((e₂) n)‖ ^ 2 ≥ 0 :=
  by
  repeat apply mul_nonneg
  apply nonneg₃
  apply le_of_lt admm.hrho
  apply pow_two_nonneg
    rw [← one_div]
    apply add_nonneg h2 h3

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter Bornology Metric Real

theorem extracted_formal_statement_5.{u_3, u_2, u_1} {E₁ : Type u_1} {E₂ : Type u_2} {F : Type u_3}
  [inst : NormedAddCommGroup E₁] [inst_1 : InnerProductSpace ℝ E₁] [inst_2 : FiniteDimensional ℝ E₁]
  [inst_3 : NormedAddCommGroup E₂] [inst_4 : InnerProductSpace ℝ E₂] [inst_5 : FiniteDimensional ℝ E₂]
  [inst_6 : NormedAddCommGroup F] [inst_7 : InnerProductSpace ℝ F] [inst_8 : FiniteDimensional ℝ F]
  {admm : ADMM E₁ E₂ F} {admm_kkt : Existance_of_kkt admm} [inst_9 : Setting E₁ E₂ F admm admm_kkt] (c : ℝ)
  (hn : ∀ (n : ℕ), ∑ i ∈ Finset.range n, (Φ i.succ - Φ (i.succ + 1)) ≤ c) :
  Summable fun n => Φ (n + 1) - Φ (n + 1 + 1) := sorry

Tactic state before:
case intro
E₁ : Type u_1
E₂ : Type u_2
F : Type u_3
inst✝⁹ : NormedAddCommGroup E₁
inst✝⁸ : InnerProductSpace ℝ E₁
inst✝⁷ : FiniteDimensional ℝ E₁
inst✝⁶ : NormedAddCommGroup E₂
inst✝⁵ : InnerProductSpace ℝ E₂
inst✝⁴ : FiniteDimensional ℝ E₂
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
inst✝¹ : FiniteDimensional ℝ F
admm : ADMM E₁ E₂ F
admm_kkt : Existance_of_kkt admm
inst✝ : Setting E₁ E₂ F admm admm_kkt
c : ℝ
hn : ∀ (n : ℕ), ∑ i ∈ Finset.range n, (Φ i.succ - Φ (i.succ + 1)) ≤ c
⊢ Summable fun n => Φ (n + 1) - Φ (n + 1 + 1)

Tactic:
apply summable_of_sum_range_le (c := c)
    intro n
    have : n + 1 > 0 := by linarith
    apply Φ_sub_nonneg (n + 1).toPNat'
    exact hn

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter Bornology Metric Real

theorem extracted_formal_statement_6.{u_3, u_2, u_1} {E₁ : Type u_1} {E₂ : Type u_2} {F : Type u_3}
  [inst : NormedAddCommGroup E₁] [inst_1 : InnerProductSpace ℝ E₁] [inst_2 : FiniteDimensional ℝ E₁]
  [inst_3 : NormedAddCommGroup E₂] [inst_4 : InnerProductSpace ℝ E₂] [inst_5 : FiniteDimensional ℝ E₂]
  [inst_6 : NormedAddCommGroup F] [inst_7 : InnerProductSpace ℝ F] [inst_8 : FiniteDimensional ℝ F]
  {admm : ADMM E₁ E₂ F} {admm_kkt : Existance_of_kkt admm} (fullrank₁ : Function.Injective ⇑(OptProblem.A₁ E₂))
  (fullrank₂ : Function.Injective ⇑(OptProblem.A₂ E₁)) [inst_9 : Setting E₁ E₂ F admm admm_kkt]
  (h_original_goal : Tendsto (fun n => (OptProblem.A₁ E₂) (e₁ ↑(φ₁ n)) + (OptProblem.A₂ E₁) (e₂ ↑(φ₁ n))) atTop (𝓝 0)) :
  StrictMono fun n => φ (n + 1) := sorry

Tactic state before:
E₁ : Type u_1
E₂ : Type u_2
F : Type u_3
inst✝⁹ : NormedAddCommGroup E₁
inst✝⁸ : InnerProductSpace ℝ E₁
inst✝⁷ : FiniteDimensional ℝ E₁
inst✝⁶ : NormedAddCommGroup E₂
inst✝⁵ : InnerProductSpace ℝ E₂
inst✝⁴ : FiniteDimensional ℝ E₂
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
inst✝¹ : FiniteDimensional ℝ F
admm : ADMM E₁ E₂ F
admm_kkt : Existance_of_kkt admm
fullrank₁ : Function.Injective ⇑(OptProblem.A₁ E₂)
fullrank₂ : Function.Injective ⇑(OptProblem.A₂ E₁)
inst✝ : Setting E₁ E₂ F admm admm_kkt
⊢ Tendsto (fun n => (OptProblem.A₁ E₂) (e₁ ↑(φ₁ n)) + (OptProblem.A₂ E₁) (e₂ ↑(φ₁ n))) atTop (𝓝 0)

Tactic:
apply Filter.tendsto_iff_seq_tendsto.1 Seq_converge_zero₁
    apply StrictMono.tendsto_atTop
    have : (fun n => (Int.toNat (φ₁ n))) = (fun n => (φ (n + 1))) := by ext n; rw [φ₁_equ fullrank₁ fullrank₂ n]; simp
    simp at this
    rw [this]

Tactic state after:
[case a.h
 E₁ : Type u_1
 E₂ : Type u_2
 F : Type u_3
 inst✝⁹ : NormedAddCommGroup E₁
 inst✝⁸ : InnerProductSpace ℝ E₁
 inst✝⁷ : FiniteDimensional ℝ E₁
 inst✝⁶ : NormedAddCommGroup E₂
 inst✝⁵ : InnerProductSpace ℝ E₂
 inst✝⁴ : FiniteDimensional ℝ E₂
 inst✝³ : NormedAddCommGroup F
 inst✝² : InnerProductSpace ℝ F
 inst✝¹ : FiniteDimensional ℝ F
 admm : ADMM E₁ E₂ F
 admm_kkt : Existance_of_kkt admm
 fullrank₁ : Function.Injective ⇑(OptProblem.A₁ E₂)
 fullrank₂ : Function.Injective ⇑(OptProblem.A₂ E₁)
 inst✝ : Setting E₁ E₂ F admm admm_kkt
 this : (fun n => ↑(φ₁ n)) = fun n => φ (n + 1)
 ⊢ StrictMono fun n => φ (n + 1)]
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter Bornology Metric Real

theorem extracted_formal_statement_7.{u_3, u_2, u_1} {E₁ : Type u_1} {E₂ : Type u_2} {F : Type u_3}
  [inst : NormedAddCommGroup E₁] [inst_1 : InnerProductSpace ℝ E₁] [inst_2 : FiniteDimensional ℝ E₁]
  [inst_3 : NormedAddCommGroup E₂] [inst_4 : InnerProductSpace ℝ E₂] [inst_5 : FiniteDimensional ℝ E₂]
  [inst_6 : NormedAddCommGroup F] [inst_7 : InnerProductSpace ℝ F] [inst_8 : FiniteDimensional ℝ F]
  {admm : ADMM E₁ E₂ F} {admm_kkt : Existance_of_kkt admm} (fullrank₁ : Function.Injective ⇑(OptProblem.A₁ E₂))
  (fullrank₂ : Function.Injective ⇑(OptProblem.A₂ E₁)) [inst_9 : Setting E₁ E₂ F admm admm_kkt]
  (h_original_goal :
    Tendsto
      (fun n =>
        (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑(φ₁ n)) + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F ↑(φ₁ n)) - OptProblem.b E₁ E₂)
      atTop (𝓝 0)) :
  StrictMono fun n => φ (n + 1) := sorry

Tactic state before:
E₁ : Type u_1
E₂ : Type u_2
F : Type u_3
inst✝⁹ : NormedAddCommGroup E₁
inst✝⁸ : InnerProductSpace ℝ E₁
inst✝⁷ : FiniteDimensional ℝ E₁
inst✝⁶ : NormedAddCommGroup E₂
inst✝⁵ : InnerProductSpace ℝ E₂
inst✝⁴ : FiniteDimensional ℝ E₂
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
inst✝¹ : FiniteDimensional ℝ F
admm : ADMM E₁ E₂ F
admm_kkt : Existance_of_kkt admm
fullrank₁ : Function.Injective ⇑(OptProblem.A₁ E₂)
fullrank₂ : Function.Injective ⇑(OptProblem.A₂ E₁)
inst✝ : Setting E₁ E₂ F admm admm_kkt
⊢ Tendsto
    (fun n =>
      (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑(φ₁ n)) + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F ↑(φ₁ n)) - OptProblem.b E₁ E₂)
    atTop (𝓝 0)

Tactic:
apply Filter.tendsto_iff_seq_tendsto.1 Seq_converge_zero₂
    apply StrictMono.tendsto_atTop
    have : (fun n => (Int.toNat (φ₁ n))) = (fun n => (φ (n + 1))) := by ext n; rw [φ₁_equ fullrank₁ fullrank₂ n]; simp
    simp at this
    rw [this]

Tactic state after:
[case a.h
 E₁ : Type u_1
 E₂ : Type u_2
 F : Type u_3
 inst✝⁹ : NormedAddCommGroup E₁
 inst✝⁸ : InnerProductSpace ℝ E₁
 inst✝⁷ : FiniteDimensional ℝ E₁
 inst✝⁶ : NormedAddCommGroup E₂
 inst✝⁵ : InnerProductSpace ℝ E₂
 inst✝⁴ : FiniteDimensional ℝ E₂
 inst✝³ : NormedAddCommGroup F
 inst✝² : InnerProductSpace ℝ F
 inst✝¹ : FiniteDimensional ℝ F
 admm : ADMM E₁ E₂ F
 admm_kkt : Existance_of_kkt admm
 fullrank₁ : Function.Injective ⇑(OptProblem.A₁ E₂)
 fullrank₂ : Function.Injective ⇑(OptProblem.A₂ E₁)
 inst✝ : Setting E₁ E₂ F admm admm_kkt
 this : (fun n => ↑(φ₁ n)) = fun n => φ (n + 1)
 ⊢ StrictMono fun n => φ (n + 1)]
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter Bornology Metric Real

theorem extracted_formal_statement_8.{u_3, u_2, u_1} {E₁ : Type u_1} {E₂ : Type u_2} {F : Type u_3}
  [inst : NormedAddCommGroup E₁] [inst_1 : InnerProductSpace ℝ E₁] [inst_2 : FiniteDimensional ℝ E₁]
  [inst_3 : NormedAddCommGroup E₂] [inst_4 : InnerProductSpace ℝ E₂] [inst_5 : FiniteDimensional ℝ E₂]
  [inst_6 : NormedAddCommGroup F] [inst_7 : InnerProductSpace ℝ F] [inst_8 : FiniteDimensional ℝ F]
  {admm : ADMM E₁ E₂ F} {admm_kkt : Existance_of_kkt admm} (fullrank₁ : Function.Injective ⇑(OptProblem.A₁ E₂))
  (fullrank₂ : Function.Injective ⇑(OptProblem.A₂ E₁)) [inst_9 : Setting E₁ E₂ F admm admm_kkt]
  (h_original_goal :
    Tendsto (fun n => (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F (↑(φ₁ n) + 1) - ADMM.x₂ E₁ F ↑(φ₁ n))) atTop (𝓝 0)) :
  StrictMono fun n => φ (n + 1) := sorry

Tactic state before:
E₁ : Type u_1
E₂ : Type u_2
F : Type u_3
inst✝⁹ : NormedAddCommGroup E₁
inst✝⁸ : InnerProductSpace ℝ E₁
inst✝⁷ : FiniteDimensional ℝ E₁
inst✝⁶ : NormedAddCommGroup E₂
inst✝⁵ : InnerProductSpace ℝ E₂
inst✝⁴ : FiniteDimensional ℝ E₂
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace ℝ F
inst✝¹ : FiniteDimensional ℝ F
admm : ADMM E₁ E₂ F
admm_kkt : Existance_of_kkt admm
fullrank₁ : Function.Injective ⇑(OptProblem.A₁ E₂)
fullrank₂ : Function.Injective ⇑(OptProblem.A₂ E₁)
inst✝ : Setting E₁ E₂ F admm admm_kkt
⊢ Tendsto (fun n => (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F (↑(φ₁ n) + 1) - ADMM.x₂ E₁ F ↑(φ₁ n))) atTop (𝓝 0)

Tactic:
apply Filter.tendsto_iff_seq_tendsto.1 Seq_converge_zero₃
    apply StrictMono.tendsto_atTop
    have : (fun n => (Int.toNat (φ₁ n))) = (fun n => (φ (n + 1))) := by ext n; rw [φ₁_equ fullrank₁ fullrank₂ n]; simp
    simp at this
    rw [this]

Tactic state after:
[case a.h
 E₁ : Type u_1
 E₂ : Type u_2
 F : Type u_3
 inst✝⁹ : NormedAddCommGroup E₁
 inst✝⁸ : InnerProductSpace ℝ E₁
 inst✝⁷ : FiniteDimensional ℝ E₁
 inst✝⁶ : NormedAddCommGroup E₂
 inst✝⁵ : InnerProductSpace ℝ E₂
 inst✝⁴ : FiniteDimensional ℝ E₂
 inst✝³ : NormedAddCommGroup F
 inst✝² : InnerProductSpace ℝ F
 inst✝¹ : FiniteDimensional ℝ F
 admm : ADMM E₁ E₂ F
 admm_kkt : Existance_of_kkt admm
 fullrank₁ : Function.Injective ⇑(OptProblem.A₁ E₂)
 fullrank₂ : Function.Injective ⇑(OptProblem.A₂ E₁)
 inst✝ : Setting E₁ E₂ F admm admm_kkt
 this : (fun n => ↑(φ₁ n)) = fun n => φ (n + 1)
 ⊢ StrictMono fun n => φ (n + 1)]