zzhisthebest/LeanBenchmark huggingface dataset:
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_186 {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.L) :
  0 < ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) (Aᵀ * A)‖₊ := 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.L

Tactic:
rw [p.Leq]

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₀
 ⊢ 0 < ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) (Aᵀ * A)‖₊]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_187 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {Ane0 : A ≠ 0}
  (h_original_goal : 0 < ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) (Aᵀ * A)‖₊) : ¬Aᵀ * 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 < ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) (Aᵀ * A)‖₊

Tactic:
simp

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ᵀ * A = 0]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_188 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {Ane0 : A ≠ 0}
  (h_original_goal : ¬Aᵀ * A = 0) : ¬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₀
⊢ ¬Aᵀ * A = 0

Tactic:
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_189 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {Ane0 : A ≠ 0} : ¬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₀
⊢ ¬A = 0

Tactic:
exact Ane0

Tactic state after:
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_190 {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₀) : p.t ≤ 1 / ↑p.L := 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₀
⊢ p.t ≤ 1 / ↑p.L

Tactic:
rw [p.teq]

Tactic state after:
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_191 {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 : ↑p.L > 0) :
  ↑‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) (Aᵀ * 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₀
⊢ ↑p.L > 0

Tactic:
rw [p.Leq]

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₀
 ⊢ ↑‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) (Aᵀ * A)‖₊ > 0]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_192 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {Ane0 : A ≠ 0}
  (h_original_goal : ↑‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) (Aᵀ * A)‖₊ > 0) : ¬Aᵀ * 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₀
⊢ ↑‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) (Aᵀ * A)‖₊ > 0

Tactic:
simp

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ᵀ * A = 0]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_193 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {Ane0 : A ≠ 0}
  (h_original_goal : ¬Aᵀ * A = 0) : ¬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₀
⊢ ¬Aᵀ * A = 0

Tactic:
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_194 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {Ane0 : A ≠ 0} : ¬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₀
⊢ ¬A = 0

Tactic:
exact Ane0

Tactic state after:
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_195 {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 : ℕ)
  (h_original_goal : prox_prop (p.t • p.h) (p.x k - p.t • p.f' (p.x k)) (p.x (k + 1))) : 0 < p.t := 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

Tactic state after:
[case lasso
 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 : ℕ
 ⊢ p.h = fun y => ?μ • ∑ i, ‖y i‖,
 case tpos
 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 : ℕ
 ⊢ 0 < p.t,
 case μpos
 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 : ℕ
 ⊢ 0 < ?μ,
 case minpoint
 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 : ℕ
 ⊢ ∀ (i : Fin ↑n),
     p.x (k + 1) i = sign ((p.x k - p.t • p.f' (p.x k)) i) * ((|(p.x k - p.t • p.f' (p.x k)) i| - p.t * ?μ) ⊔ 0),
 case μ
 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 : ℕ
 ⊢ ℝ]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_196 {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₀) :
  p.h = fun y => μ • ∑ i, ‖y i‖ := sorry

Tactic state before:
case lasso
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 : ℕ
⊢ p.h = fun y => ?μ • ∑ i, ‖y i‖

Tactic:
rw [p.heq]

Tactic state after:
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_197 {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) :
  0 < 1 / ↑p.L := sorry

Tactic state before:
case tpos
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 : ℕ
⊢ 0 < p.t

Tactic:
rw [p.teq]

Tactic state after:
[case tpos
 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 : ℕ
 ⊢ 0 < 1 / ↑p.L]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_198 {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 < 1 / ↑p.L) :
  0 < p.L := sorry

Tactic state before:
case tpos
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 : ℕ
⊢ 0 < 1 / ↑p.L

Tactic:
simp

Tactic state after:
[case tpos
 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 : ℕ
 ⊢ 0 < p.L]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_199 {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.L) :
  0 < ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) (Aᵀ * A)‖₊ := sorry

Tactic state before:
case tpos
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 : ℕ
⊢ 0 < p.L

Tactic:
rw [p.Leq]

Tactic state after:
[case tpos
 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 : ℕ
 ⊢ 0 < ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) (Aᵀ * A)‖₊]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_200 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {Ane0 : A ≠ 0}
  (h_original_goal : 0 < ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) (Aᵀ * A)‖₊) : ¬Aᵀ * A = 0 := sorry

Tactic state before:
case tpos
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 : ℕ
⊢ 0 < ‖(toEuclideanLin ≪≫ₗ LinearMap.toContinuousLinearMap) (Aᵀ * A)‖₊

Tactic:
simp

Tactic state after:
[case tpos
 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 : ℕ
 ⊢ ¬Aᵀ * A = 0]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_201 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {Ane0 : A ≠ 0}
  (h_original_goal : ¬Aᵀ * A = 0) : ¬A = 0 := sorry

Tactic state before:
case tpos
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 : ℕ
⊢ ¬Aᵀ * A = 0

Tactic:
rw [Transpose_mul_self_eq_zero]

Tactic state after:
[case tpos
 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 : ℕ
 ⊢ ¬A = 0]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_202 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {Ane0 : A ≠ 0} : ¬A = 0 := sorry

Tactic state before:
case tpos
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 : ℕ
⊢ ¬A = 0

Tactic:
exact Ane0

Tactic state after:
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_203 {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 : ℕ) (i : Fin ↑n) :
  p.x (k + 1) i = sign ((p.x k - p.t • p.f' (p.x k)) i) * ((|(p.x k - p.t • p.f' (p.x k)) i| - p.t * μ) ⊔ 0) := sorry

Tactic state before:
case minpoint
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 : ℕ
i : Fin ↑n
⊢ p.x (k + 1) i = sign ((p.x k - p.t • p.f' (p.x k)) i) * ((|(p.x k - p.t • p.f' (p.x k)) i| - p.t * μ) ⊔ 0)

Tactic:
rw [p.update2 k, p.update1 k]

Tactic state after:
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_204 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {b : Fin ↑m → ℝ} {μ : ℝ} {μpos : 0 < μ}
  {Ane0 : A ≠ 0} {x₀ : EuclideanSpace ℝ (Fin ↑n)} {alg : LASSO A b μ μpos Ane0 x₀} (k : ℕ+)
  (h₁ :
    alg.f (alg.x ↑k) + alg.h (alg.x ↑k) - alg.f alg.xm - alg.h alg.xm =
      alg.f (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) +
            alg.h (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) -
          alg.f (proximal_gradient_method.xm alg.f alg.h alg.f' x₀) -
        alg.h (proximal_gradient_method.xm alg.f alg.h alg.f' x₀))
  (h₂ :
    1 / (2 * ↑↑k * alg.t) * ‖x₀ - alg.xm‖ ^ 2 =
      1 / (2 * ↑↑k * proximal_gradient_method.t alg.f alg.h alg.f' x₀) *
        ‖x₀ - proximal_gradient_method.xm alg.f alg.h alg.f' x₀‖ ^ 2)
  (h_original_goal : ↑alg.L / (2 * ↑↑k) = 1 / (2 * ↑↑k * alg.t)) :
  ↑alg.L / (2 * ↑↑k) = 1 / (2 * ↑↑k * (1 / ↑alg.L)) := sorry

Tactic state before:
n m : ℕ+
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
b : Fin ↑m → ℝ
μ : ℝ
μpos : 0 < μ
Ane0 : A ≠ 0
x₀ : EuclideanSpace ℝ (Fin ↑n)
alg : LASSO A b μ μpos Ane0 x₀
k : ℕ+
h₁ :
  alg.f (alg.x ↑k) + alg.h (alg.x ↑k) - alg.f alg.xm - alg.h alg.xm =
    alg.f (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) +
          alg.h (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) -
        alg.f (proximal_gradient_method.xm alg.f alg.h alg.f' x₀) -
      alg.h (proximal_gradient_method.xm alg.f alg.h alg.f' x₀)
h₂ :
  1 / (2 * ↑↑k * alg.t) * ‖x₀ - alg.xm‖ ^ 2 =
    1 / (2 * ↑↑k * proximal_gradient_method.t alg.f alg.h alg.f' x₀) *
      ‖x₀ - proximal_gradient_method.xm alg.f alg.h alg.f' x₀‖ ^ 2
⊢ ↑alg.L / (2 * ↑↑k) = 1 / (2 * ↑↑k * alg.t)

Tactic:
rw [alg.teq]

Tactic state after:
[n m : ℕ+
 A : Matrix (Fin ↑m) (Fin ↑n) ℝ
 b : Fin ↑m → ℝ
 μ : ℝ
 μpos : 0 < μ
 Ane0 : A ≠ 0
 x₀ : EuclideanSpace ℝ (Fin ↑n)
 alg : LASSO A b μ μpos Ane0 x₀
 k : ℕ+
 h₁ :
   alg.f (alg.x ↑k) + alg.h (alg.x ↑k) - alg.f alg.xm - alg.h alg.xm =
     alg.f (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) +
           alg.h (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) -
         alg.f (proximal_gradient_method.xm alg.f alg.h alg.f' x₀) -
       alg.h (proximal_gradient_method.xm alg.f alg.h alg.f' x₀)
 h₂ :
   1 / (2 * ↑↑k * alg.t) * ‖x₀ - alg.xm‖ ^ 2 =
     1 / (2 * ↑↑k * proximal_gradient_method.t alg.f alg.h alg.f' x₀) *
       ‖x₀ - proximal_gradient_method.xm alg.f alg.h alg.f' x₀‖ ^ 2
 ⊢ ↑alg.L / (2 * ↑↑k) = 1 / (2 * ↑↑k * (1 / ↑alg.L))]
import Mathlib
import Optlib


open Set Real Matrix Finset

open Set Real Matrix Finset NNReal

theorem extracted_formal_statement_206 {n m : ℕ+} {A : Matrix (Fin ↑m) (Fin ↑n) ℝ} {b : Fin ↑m → ℝ} {μ : ℝ} {μpos : 0 < μ}
  {Ane0 : A ≠ 0} {x₀ : EuclideanSpace ℝ (Fin ↑n)} {alg : LASSO A b μ μpos Ane0 x₀} (k : ℕ+)
  (h₁ :
    alg.f (alg.x ↑k) + alg.h (alg.x ↑k) - alg.f alg.xm - alg.h alg.xm =
      alg.f (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) +
            alg.h (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) -
          alg.f (proximal_gradient_method.xm alg.f alg.h alg.f' x₀) -
        alg.h (proximal_gradient_method.xm alg.f alg.h alg.f' x₀))
  (h₂ :
    1 / (2 * ↑↑k * alg.t) * ‖x₀ - alg.xm‖ ^ 2 =
      1 / (2 * ↑↑k * proximal_gradient_method.t alg.f alg.h alg.f' x₀) *
        ‖x₀ - proximal_gradient_method.xm alg.f alg.h alg.f' x₀‖ ^ 2)
  (h₃ : ↑alg.L / (2 * ↑↑k) = 1 / (2 * ↑↑k * alg.t)) :
  alg.f (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) +
          alg.h (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) -
        alg.f (proximal_gradient_method.xm alg.f alg.h alg.f' x₀) -
      alg.h (proximal_gradient_method.xm alg.f alg.h alg.f' x₀) ≤
    1 / (2 * ↑↑k * proximal_gradient_method.t alg.f alg.h alg.f' x₀) *
      ‖x₀ - proximal_gradient_method.xm alg.f alg.h alg.f' x₀‖ ^ 2 := sorry

Tactic state before:
n m : ℕ+
A : Matrix (Fin ↑m) (Fin ↑n) ℝ
b : Fin ↑m → ℝ
μ : ℝ
μpos : 0 < μ
Ane0 : A ≠ 0
x₀ : EuclideanSpace ℝ (Fin ↑n)
alg : LASSO A b μ μpos Ane0 x₀
k : ℕ+
h₁ :
  alg.f (alg.x ↑k) + alg.h (alg.x ↑k) - alg.f alg.xm - alg.h alg.xm =
    alg.f (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) +
          alg.h (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) -
        alg.f (proximal_gradient_method.xm alg.f alg.h alg.f' x₀) -
      alg.h (proximal_gradient_method.xm alg.f alg.h alg.f' x₀)
h₂ :
  1 / (2 * ↑↑k * alg.t) * ‖x₀ - alg.xm‖ ^ 2 =
    1 / (2 * ↑↑k * proximal_gradient_method.t alg.f alg.h alg.f' x₀) *
      ‖x₀ - proximal_gradient_method.xm alg.f alg.h alg.f' x₀‖ ^ 2
h₃ : ↑alg.L / (2 * ↑↑k) = 1 / (2 * ↑↑k * alg.t)
⊢ alg.f (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) +
          alg.h (proximal_gradient_method.x alg.f alg.h alg.f' x₀ ↑k) -
        alg.f (proximal_gradient_method.xm alg.f alg.h alg.f' x₀) -
      alg.h (proximal_gradient_method.xm alg.f alg.h alg.f' x₀) ≤
    1 / (2 * ↑↑k * proximal_gradient_method.t alg.f alg.h alg.f' x₀) *
      ‖x₀ - proximal_gradient_method.xm alg.f alg.h alg.f' x₀‖ ^ 2

Tactic:
apply proximal_gradient_method_converge k

Tactic state after: