zzhisthebest/LeanBenchmark huggingface dataset:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_54.{u_5, u_4} {α : Type u_4} {β : Type u_5} [inst : NormedAddCommGroup α]
  [inst_1 : NormedAddCommGroup β] [inst_2 : InnerProductSpace ℝ α] [inst_3 : InnerProductSpace ℝ β]
  [inst_4 : CompleteSpace α] [inst_5 : CompleteSpace β] (A : α →L[ℝ] β) (s : α) (ε : ℝ) (εpos : ε > 0) (h : 0 < ‖A‖)
  (x : α) (hx : ‖s - x‖ ≤ ε / ‖A‖ ^ 2) (hzero : 0 < ‖A‖ ^ 2) :
  let t := x - s;
  s + t = x →
    ⟪A x, A x⟫_ℝ - ⟪A s, A s⟫_ℝ - ⟪2 • (ContinuousLinearMap.adjoint A) (A s), x - s⟫_ℝ = ⟪A (x - s), A (x - s)⟫_ℝ →
      0 < ‖s - x‖ → 0 ≤ ‖A‖ ^ 2 * ‖s - x‖ → ‖A‖ ^ 2 * ‖s - x‖ * ‖s - x‖ ≤ ‖A‖ ^ 2 * ‖s - x‖ * (ε / ‖A‖ ^ 2) := sorry

Tactic state before:
α : Type u_4
β : Type u_5
inst✝⁵ : NormedAddCommGroup α
inst✝⁴ : NormedAddCommGroup β
inst✝³ : InnerProductSpace ℝ α
inst✝² : InnerProductSpace ℝ β
inst✝¹ : CompleteSpace α
inst✝ : CompleteSpace β
A : α →L[ℝ] β
s : α
ε : ℝ
εpos : ε > 0
h : 0 < ‖A‖
x : α
hx : ‖s - x‖ ≤ ε / ‖A‖ ^ 2
hzero : 0 < ‖A‖ ^ 2
t : α := x - s
t1 : s + t = x
this✝ : ⟪A x, A x⟫_ℝ - ⟪A s, A s⟫_ℝ - ⟪2 • (ContinuousLinearMap.adjoint A) (A s), x - s⟫_ℝ = ⟪A (x - s), A (x - s)⟫_ℝ
h✝ : 0 < ‖s - x‖
this : 0 ≤ ‖A‖ ^ 2 * ‖s - x‖
⊢ ‖A‖ ^ 2 * ‖s - x‖ * ‖s - x‖ ≤ ‖A‖ ^ 2 * ‖s - x‖ * (ε / ‖A‖ ^ 2)

Tactic:
apply mul_le_mul_of_nonneg_left hx this

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_56.{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} (n : ℕ+) :
  let c := (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂;
  ((fun x =>
        ADMM.ρ E₁ E₂ F / 2 *
          ‖(OptProblem.A₁ E₂) x + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂‖ ^ 2) =
      fun x =>
      ADMM.ρ E₁ E₂ F / 2 *
        ‖(OptProblem.A₁ E₂) x + ((OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂)‖ ^ 2) →
    ((fun x => ADMM.ρ E₁ E₂ F / 2 * ‖(OptProblem.A₁ E₂) x + c‖ ^ 2) = fun x =>
        ADMM.ρ E₁ E₂ F / 2 *
          (⟪(OptProblem.A₁ E₂) x, (OptProblem.A₁ E₂) x⟫_ℝ + 2 * ⟪c, (OptProblem.A₁ E₂) x⟫_ℝ + ⟪c, c⟫_ℝ)) →
      ADMM.ρ E₁ E₂ F • (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂)) ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + c) =
        (ADMM.ρ E₁ E₂ F / 2 * 2) •
          (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂)) ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + c) := 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
n : ℕ+
c : F := (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂
h1 :
  (fun x =>
      ADMM.ρ E₁ E₂ F / 2 *
        ‖(OptProblem.A₁ E₂) x + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂‖ ^ 2) =
    fun x =>
    ADMM.ρ E₁ E₂ F / 2 * ‖(OptProblem.A₁ E₂) x + ((OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂)‖ ^ 2
h2 :
  (fun x => ADMM.ρ E₁ E₂ F / 2 * ‖(OptProblem.A₁ E₂) x + c‖ ^ 2) = fun x =>
    ADMM.ρ E₁ E₂ F / 2 * (⟪(OptProblem.A₁ E₂) x, (OptProblem.A₁ E₂) x⟫_ℝ + 2 * ⟪c, (OptProblem.A₁ E₂) x⟫_ℝ + ⟪c, c⟫_ℝ)
⊢ ADMM.ρ E₁ E₂ F • (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂)) ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + c) =
    (ADMM.ρ E₁ E₂ F / 2 * 2) •
      (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂)) ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + c)

Tactic:
simp only [map_add, smul_add, isUnit_iff_ne_zero, ne_eq, OfNat.ofNat_ne_zero, not_false_eq_true,
  IsUnit.div_mul_cancel]

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_66.{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} (n : ℕ+)
  (h_original_goal :
    SubderivAt
        (fun x =>
          ADMM.ρ E₁ E₂ F / 2 *
            ‖(OptProblem.A₁ E₂) x + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂‖ ^ 2)
        (ADMM.x₁ E₂ F ↑n) =
      {ADMM.ρ E₁ E₂ F •
          (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂))
            ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) -
              OptProblem.b E₁ E₂)}) :
  HasGradientAt
    (fun x =>
      ADMM.ρ E₁ E₂ F / 2 *
        ‖(OptProblem.A₁ E₂) x + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂‖ ^ 2)
    (ADMM.ρ E₁ E₂ F •
      (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂))
        ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂))
    (ADMM.x₁ E₂ F ↑n) := 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
n : ℕ+
⊢ SubderivAt
      (fun x =>
        ADMM.ρ E₁ E₂ F / 2 *
          ‖(OptProblem.A₁ E₂) x + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂‖ ^ 2)
      (ADMM.x₁ E₂ F ↑n) =
    {ADMM.ρ E₁ E₂ F •
        (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂))
          ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂)}

Tactic:
apply SubderivAt_eq_gradient (norm_covex1 n)

Tactic state after:
[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 : ℕ+
 ⊢ HasGradientAt
     (fun x =>
       ADMM.ρ E₁ E₂ F / 2 *
         ‖(OptProblem.A₁ E₂) x + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂‖ ^ 2)
     (ADMM.ρ E₁ E₂ F •
       (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂))
         ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂))
     (ADMM.x₁ E₂ F ↑n)]
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_67.{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} (n : ℕ+) :
  HasGradientAt
    (fun x =>
      ADMM.ρ E₁ E₂ F / 2 *
        ‖(OptProblem.A₁ E₂) x + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂‖ ^ 2)
    (ADMM.ρ E₁ E₂ F •
      (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂))
        ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂))
    (ADMM.x₁ E₂ F ↑n) := 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
n : ℕ+
⊢ HasGradientAt
    (fun x =>
      ADMM.ρ E₁ E₂ F / 2 *
        ‖(OptProblem.A₁ E₂) x + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂‖ ^ 2)
    (ADMM.ρ E₁ E₂ F •
      (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂))
        ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F n.natPred) - OptProblem.b E₁ E₂))
    (ADMM.x₁ E₂ F ↑n)

Tactic:
apply ADMM_iter_process₁'_eq3_3'

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_68.{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} (n : ℕ+)
  (this :
    IsMinOn
        (fun x =>
          Augmented_Lagrangian_Function E₁ E₂ F ADMM.toOptProblem (ADMM.ρ E₁ E₂ F)
            (x, ADMM.x₂ E₁ F n.natPred, ADMM.y E₁ E₂ n.natPred))
        univ (ADMM.x₁ E₂ F ↑n) ↔
      0 ∈
        SubderivAt
          (fun x =>
            Augmented_Lagrangian_Function E₁ E₂ F ADMM.toOptProblem (ADMM.ρ E₁ E₂ F)
              (x, ADMM.x₂ E₁ F n.natPred, ADMM.y E₁ E₂ n.natPred))
          (ADMM.x₁ E₂ F ↑n))
  (h :
    IsMinOn
      (fun «x₁» =>
        Augmented_Lagrangian_Function E₁ E₂ F ADMM.toOptProblem (ADMM.ρ E₁ E₂ F)
          («x₁», ADMM.x₂ E₁ F n.natPred, ADMM.y E₁ E₂ n.natPred))
      univ (ADMM.x₁ E₂ F (n.natPred + 1))) :
  n.natPred + 1 = ↑n := 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
n : ℕ+
this :
  IsMinOn
      (fun x =>
        Augmented_Lagrangian_Function E₁ E₂ F ADMM.toOptProblem (ADMM.ρ E₁ E₂ F)
          (x, ADMM.x₂ E₁ F n.natPred, ADMM.y E₁ E₂ n.natPred))
      univ (ADMM.x₁ E₂ F ↑n) ↔
    0 ∈
      SubderivAt
        (fun x =>
          Augmented_Lagrangian_Function E₁ E₂ F ADMM.toOptProblem (ADMM.ρ E₁ E₂ F)
            (x, ADMM.x₂ E₁ F n.natPred, ADMM.y E₁ E₂ n.natPred))
        (ADMM.x₁ E₂ F ↑n)
h :
  IsMinOn
    (fun «x₁» =>
      Augmented_Lagrangian_Function E₁ E₂ F ADMM.toOptProblem (ADMM.ρ E₁ E₂ F)
        («x₁», ADMM.x₂ E₁ F n.natPred, ADMM.y E₁ E₂ n.natPred))
    univ (ADMM.x₁ E₂ F (n.natPred + 1))
⊢ n.natPred + 1 = ↑n

Tactic:
apply PNat.natPred_add_one

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_70.{u_4} {E : Type u_4} [inst : NormedAddCommGroup E] (p q r : Set E) ⦃x : E⦄ (px : E)
  (hpx : px ∈ p) (py : E) (h1 : px + py = x) (qy : E) (hqy : qy ∈ q) (rz : E) (hrz : rz ∈ r) (h2 : qy + rz = py) :
  px + qy + rz = px + (qy + rz) := sorry

Tactic state before:
case right
E : Type u_4
inst✝ : NormedAddCommGroup E
p q r : Set E
x px : E
hpx : px ∈ p
py : E
h1 : px + py = x
qy : E
hqy : qy ∈ q
rz : E
hrz : rz ∈ r
h2 : qy + rz = py
⊢ px + qy + rz = px + (qy + rz)

Tactic:
exact add_assoc px qy rz

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_71.{u_4} {E : Type u_4} [inst : NormedAddCommGroup E] (p q r : Set E) ⦃x : E⦄
  (px py : E) (hpy : py ∈ r) (h1 : px + py = x) (qy : E) (hqy : qy ∈ p) (rz : E) (hrz : rz ∈ q) (h2 : qy + rz = px) :
  qy + (rz + py) = qy + rz + py := sorry

Tactic state before:
case right
E : Type u_4
inst✝ : NormedAddCommGroup E
p q r : Set E
x px py : E
hpy : py ∈ r
h1 : px + py = x
qy : E
hqy : qy ∈ p
rz : E
hrz : rz ∈ q
h2 : qy + rz = px
⊢ qy + (rz + py) = qy + rz + py

Tactic:
exact Eq.symm (add_assoc qy rz py)

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_72.{u_4} {E : Type u_4} [inst : NormedAddCommGroup E] {a : E} {s : Set E} (h : -a ∈ s) :
  -a ∈ s := sorry

Tactic state before:
E : Type u_4
inst✝ : NormedAddCommGroup E
a : E
s : Set E
h : -a ∈ s
⊢ -a ∈ s

Tactic:
exact h

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_73.{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} (n : ℕ+) :
  let S := SubderivAt (OptProblem.f₁ E₂ F) (ADMM.x₁ E₂ F ↑n);
  let p := (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂)) (ADMM.y E₁ E₂ (↑n - 1));
  let q :=
    ADMM.ρ E₁ E₂ F •
      (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂))
        ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F (↑n - 1)) - OptProblem.b E₁ E₂);
  0 ∈ S + {p} + {q} → -p - q ∈ S := 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
n : ℕ+
S : Set E₁ := SubderivAt (OptProblem.f₁ E₂ F) (ADMM.x₁ E₂ F ↑n)
p : E₁ := (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂)) (ADMM.y E₁ E₂ (↑n - 1))
q : E₁ :=
  ADMM.ρ E₁ E₂ F •
    (ContinuousLinearMap.adjoint (OptProblem.A₁ E₂))
      ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + (OptProblem.A₂ E₁) (ADMM.x₂ E₁ F (↑n - 1)) - OptProblem.b E₁ E₂)
this : 0 ∈ S + {p} + {q}
⊢ -p - q ∈ S

Tactic:
apply change_item this

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_74.{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} (n : ℕ+) :
  HasGradientAt (fun x => OptProblem.f₁ E₂ F (ADMM.x₁ E₂ F ↑n)) 0 (ADMM.x₂ E₁ F ↑n) := 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
n : ℕ+
⊢ HasGradientAt (fun x => OptProblem.f₁ E₂ F (ADMM.x₁ E₂ F ↑n)) 0 (ADMM.x₂ E₁ F ↑n)

Tactic:
apply hasGradientAt_const

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_75.{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} (n : ℕ+)
  (h_original_goal : SubderivAt (fun x => OptProblem.f₁ E₂ F (ADMM.x₁ E₂ F ↑n)) (ADMM.x₂ E₁ F ↑n) = 0) :
  HasGradientAt (fun x => OptProblem.f₁ E₂ F (ADMM.x₁ E₂ F ↑n)) 0 (ADMM.x₂ E₁ F ↑n) := 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
n : ℕ+
⊢ SubderivAt (fun x => OptProblem.f₁ E₂ F (ADMM.x₁ E₂ F ↑n)) (ADMM.x₂ E₁ F ↑n) = 0

Tactic:
apply SubderivAt_eq_gradient (convexOn_const (f₁ (x₁ n)) (convex_univ))

Tactic state after:
[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 : ℕ+
 ⊢ HasGradientAt (fun x => OptProblem.f₁ E₂ F (ADMM.x₁ E₂ F ↑n)) 0 (ADMM.x₂ E₁ F ↑n)]
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_76.{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} (n : ℕ+) :
  HasGradientAt (fun x => OptProblem.f₁ E₂ F (ADMM.x₁ E₂ F ↑n)) 0 (ADMM.x₂ E₁ F ↑n) := 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
n : ℕ+
⊢ HasGradientAt (fun x => OptProblem.f₁ E₂ F (ADMM.x₁ E₂ F ↑n)) 0 (ADMM.x₂ E₁ F ↑n)

Tactic:
apply ADMM_iter_process₂'_eq3_1'

Tactic state after:
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_77.{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} (n : ℕ+) (x : E₂)
  (h_original_goal :
    ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + (OptProblem.A₂ E₁) x - OptProblem.b E₁ E₂⟫_ℝ =
      ((fun x => ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₂ E₁) x⟫_ℝ) + fun x =>
          ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) - OptProblem.b E₁ E₂⟫_ℝ)
        x) :
  ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + (OptProblem.A₂ E₁) x - OptProblem.b E₁ E₂⟫_ℝ =
    ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₂ E₁) x⟫_ℝ +
      ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) - OptProblem.b E₁ E₂⟫_ℝ := sorry

Tactic state before:
case 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
inst✝ : Setting E₁ E₂ F admm admm_kkt
n : ℕ+
x✝ : E₂
c : F := ADMM.y E₁ E₂ n.natPred
c₁ : ℝ := ⟪c, (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) - OptProblem.b E₁ E₂⟫_ℝ
x : E₂
⊢ ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + (OptProblem.A₂ E₁) x - OptProblem.b E₁ E₂⟫_ℝ =
    ((fun x => ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₂ E₁) x⟫_ℝ) + fun x =>
        ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) - OptProblem.b E₁ E₂⟫_ℝ)
      x

Tactic:
simp only [Pi.add_apply]

Tactic state after:
[case 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
 inst✝ : Setting E₁ E₂ F admm admm_kkt
 n : ℕ+
 x✝ : E₂
 c : F := ADMM.y E₁ E₂ n.natPred
 c₁ : ℝ := ⟪c, (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) - OptProblem.b E₁ E₂⟫_ℝ
 x : E₂
 ⊢ ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) + (OptProblem.A₂ E₁) x - OptProblem.b E₁ E₂⟫_ℝ =
     ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₂ E₁) x⟫_ℝ +
       ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) - OptProblem.b E₁ E₂⟫_ℝ]
import Mathlib
import Optlib


open Set InnerProductSpace Topology Filter InnerProduct

open scoped Pointwise

theorem extracted_formal_statement_78.{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} (n : ℕ+) (x : E₂) :
  ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₂ E₁) x + ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) - OptProblem.b E₁ E₂)⟫_ℝ =
    ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₂ E₁) x⟫_ℝ +
      ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) - OptProblem.b E₁ E₂⟫_ℝ := sorry

Tactic state before:
case 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
inst✝ : Setting E₁ E₂ F admm admm_kkt
n : ℕ+
x✝ : E₂
c : F := ADMM.y E₁ E₂ n.natPred
c₁ : ℝ := ⟪c, (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) - OptProblem.b E₁ E₂⟫_ℝ
x : E₂
⊢ ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₂ E₁) x + ((OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) - OptProblem.b E₁ E₂)⟫_ℝ =
    ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₂ E₁) x⟫_ℝ +
      ⟪ADMM.y E₁ E₂ n.natPred, (OptProblem.A₁ E₂) (ADMM.x₁ E₂ F ↑n) - OptProblem.b E₁ E₂⟫_ℝ

Tactic:
exact inner_add_right (y n.natPred) (A₂ x) (A₁ (x₁ n) - b)

Tactic state after: