1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.snormEssSup_const_smul_le
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: simp [nnnorm_smul_le]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedAddCommGroup F
inst✝⁵ : NormedAddCommGroup G
𝕜 : Type u_5
inst✝⁴ : NormedRing 𝕜
inst✝³ : MulActionWithZero 𝕜 E
inst✝² : MulActionWithZero 𝕜 F
inst✝¹ : BoundedSMul 𝕜 E
inst✝ : BoundedSMul 𝕜 F
c : 𝕜
f : α → F
x✝ : α
⊢ ‖(c • f) x✝‖₊ ≤ ‖c‖₊ * ‖f x✝‖₊
state_after: no goals
Theorem: Real.rpow_le_rpow_of_exponent_le
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: repeat' rw [rpow_def_of_pos (lt_of_lt_of_le zero_lt_one hx)]
state_before: x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ x ^ y ≤ x ^ z
state_after: x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ rexp (log x * y) ≤ rexp (log x * z)

tactic: rw [exp_le_exp]
state_before: x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ rexp (log x * y) ≤ rexp (log x * z)
state_after: x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ log x * y ≤ log x * z

tactic: exact mul_le_mul_of_nonneg_left hyz (log_nonneg hx)
state_before: x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ log x * y ≤ log x * z
state_after: no goals

tactic: rw [rpow_def_of_pos (lt_of_lt_of_le zero_lt_one hx)]
state_before: x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ rexp (log x * y) ≤ x ^ z
state_after: x y z : ℝ
n : ℕ
hx : 1 ≤ x
hyz : y ≤ z
⊢ rexp (log x * y) ≤ rexp (log x * z)
Theorem: List.permutations'Aux_get_zero
File: Mathlib/Data/List/Perm.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ : List α
a : α
s : List α
x : α
⊢ 0 < (permutations'Aux x s).length
state_after: no goals
Theorem: Zsqrtd.intCast_re
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

tactic: cases n <;> rfl
state_before: d n : ℤ
⊢ (↑n).re = n
state_after: no goals
Theorem: CategoryTheory.Limits.Cocone.w
File: Mathlib/CategoryTheory/Limits/Cones.lean

tactic: rw [c.ι.naturality f]
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cocone F
j j' : J
f : j ⟶ j'
⊢ F.map f ≫ c.ι.app j' = c.ι.app j
state_after: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cocone F
j j' : J
f : j ⟶ j'
⊢ c.ι.app j ≫ ((const J).obj c.pt).map f = c.ι.app j

tactic: apply comp_id
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cocone F
j j' : J
f : j ⟶ j'
⊢ c.ι.app j ≫ ((const J).obj c.pt).map f = c.ι.app j
state_after: no goals
Theorem: List.dropLast_append_getLast
File: Mathlib/Data/List/Basic.lean

tactic: rw [dropLast_cons₂, cons_append, getLast_cons (cons_ne_nil _ _)]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
h : a :: b :: l ≠ []
⊢ (a :: b :: l).dropLast ++ [(a :: b :: l).getLast h] = a :: b :: l
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
h : a :: b :: l ≠ []
⊢ a :: ((b :: l).dropLast ++ [(b :: l).getLast ⋯]) = a :: b :: l

tactic: congr
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
h : a :: b :: l ≠ []
⊢ a :: ((b :: l).dropLast ++ [(b :: l).getLast ⋯]) = a :: b :: l
state_after: case e_tail
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
h : a :: b :: l ≠ []
⊢ (b :: l).dropLast ++ [(b :: l).getLast ⋯] = b :: l

tactic: exact dropLast_append_getLast (cons_ne_nil b l)
state_before: case e_tail
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b : α
l : List α
h : a :: b :: l ≠ []
⊢ (b :: l).dropLast ++ [(b :: l).getLast ⋯] = b :: l
state_after: no goals
Theorem: Homotopy.nullHomotopicMap'_f
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: simp only [nullHomotopicMap']
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : c.Rel k₂ k₁
r₁₀ : c.Rel k₁ k₀
h : (i j : ι) → c.Rel j i → (C.X i ⟶ D.X j)
⊢ (nullHomotopicMap' h).f k₁ = C.d k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ D.d k₂ k₁
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : c.Rel k₂ k₁
r₁₀ : c.Rel k₁ k₀
h : (i j : ι) → c.Rel j i → (C.X i ⟶ D.X j)
⊢ (nullHomotopicMap fun i j => dite (c.Rel j i) (h i j) fun x => 0).f k₁ =
    C.d k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ D.d k₂ k₁

tactic: rw [nullHomotopicMap_f r₂₁ r₁₀]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : c.Rel k₂ k₁
r₁₀ : c.Rel k₁ k₀
h : (i j : ι) → c.Rel j i → (C.X i ⟶ D.X j)
⊢ (nullHomotopicMap fun i j => dite (c.Rel j i) (h i j) fun x => 0).f k₁ =
    C.d k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ D.d k₂ k₁
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : c.Rel k₂ k₁
r₁₀ : c.Rel k₁ k₀
h : (i j : ι) → c.Rel j i → (C.X i ⟶ D.X j)
⊢ (C.d k₁ k₀ ≫ dite (c.Rel k₁ k₀) (h k₀ k₁) fun x => 0) + (dite (c.Rel k₂ k₁) (h k₁ k₂) fun x => 0) ≫ D.d k₂ k₁ =
    C.d k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ D.d k₂ k₁

tactic: split_ifs
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : c.Rel k₂ k₁
r₁₀ : c.Rel k₁ k₀
h : (i j : ι) → c.Rel j i → (C.X i ⟶ D.X j)
⊢ (C.d k₁ k₀ ≫ dite (c.Rel k₁ k₀) (h k₀ k₁) fun x => 0) + (dite (c.Rel k₂ k₁) (h k₁ k₂) fun x => 0) ≫ D.d k₂ k₁ =
    C.d k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ D.d k₂ k₁
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : c.Rel k₂ k₁
r₁₀ : c.Rel k₁ k₀
h : (i j : ι) → c.Rel j i → (C.X i ⟶ D.X j)
⊢ C.d k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ D.d k₂ k₁ = C.d k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ D.d k₂ k₁

tactic: rfl
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h✝ k : D ⟶ E
i k₂ k₁ k₀ : ι
r₂₁ : c.Rel k₂ k₁
r₁₀ : c.Rel k₁ k₀
h : (i j : ι) → c.Rel j i → (C.X i ⟶ D.X j)
⊢ C.d k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ D.d k₂ k₁ = C.d k₁ k₀ ≫ h k₀ k₁ r₁₀ + h k₁ k₂ r₂₁ ≫ D.d k₂ k₁
state_after: no goals
Theorem: Submodule.toAffineSubspace_direction
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: ext x
state_before: k : Type u_1
V : Type u_2
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
s : Submodule k V
⊢ s.toAffineSubspace.direction = s
state_after: case h
k : Type u_1
V : Type u_2
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
s : Submodule k V
x : V
⊢ x ∈ s.toAffineSubspace.direction ↔ x ∈ s

tactic: simp [← s.toAffineSubspace.vadd_mem_iff_mem_direction _ s.zero_mem]
state_before: case h
k : Type u_1
V : Type u_2
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
s : Submodule k V
x : V
⊢ x ∈ s.toAffineSubspace.direction ↔ x ∈ s
state_after: no goals
Theorem: Valued.norm_add_le
File: Mathlib/Topology/Algebra/NormedValued.lean

tactic: simp only [norm, NNReal.coe_le_coe, le_max_iff, StrictMono.le_iff_le hv.strictMono]
state_before: K : Type u_1
hK : NormedField K
h : IsNonarchimedean (sorryAx (K → ℝ) true)
L : Type u_2
inst✝¹ : Field L
Γ₀ : Type u_3
inst✝ : LinearOrderedCommGroupWithZero Γ₀
val : Valued L Γ₀
hv : v.RankOne
x y : L
⊢ norm (x + y) ≤ max (norm x) (norm y)
state_after: K : Type u_1
hK : NormedField K
h : IsNonarchimedean (sorryAx (K → ℝ) true)
L : Type u_2
inst✝¹ : Field L
Γ₀ : Type u_3
inst✝ : LinearOrderedCommGroupWithZero Γ₀
val : Valued L Γ₀
hv : v.RankOne
x y : L
⊢ v (x + y) ≤ v x ∨ v (x + y) ≤ v y

tactic: exact le_max_iff.mp (Valuation.map_add_le_max' val.v _ _)
state_before: K : Type u_1
hK : NormedField K
h : IsNonarchimedean (sorryAx (K → ℝ) true)
L : Type u_2
inst✝¹ : Field L
Γ₀ : Type u_3
inst✝ : LinearOrderedCommGroupWithZero Γ₀
val : Valued L Γ₀
hv : v.RankOne
x y : L
⊢ v (x + y) ≤ v x ∨ v (x + y) ≤ v y
state_after: no goals
Theorem: Set.image2_singleton_left
File: Mathlib/Data/Set/NAry.lean

tactic: simp
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f' : α → β → γ
g g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
x : γ
⊢ x ∈ image2 f {a} t ↔ x ∈ f a '' t
state_after: no goals
Theorem: Matrix.add_dotProduct
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct, add_mul, Finset.sum_add_distrib]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x y : n → α
⊢ (u + v) ⬝ᵥ w = u ⬝ᵥ w + v ⬝ᵥ w
state_after: no goals
Theorem: RingHom.FiniteType.of_surjective
File: Mathlib/RingTheory/FiniteType.lean

tactic: rw [← f.comp_id]
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
hf : Surjective ⇑f
⊢ f.FiniteType
state_after: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
hf : Surjective ⇑f
⊢ (f.comp (RingHom.id A)).FiniteType

tactic: exact (id A).comp_surjective hf
state_before: A : Type u_1
B : Type u_2
C : Type u_3
inst✝² : CommRing A
inst✝¹ : CommRing B
inst✝ : CommRing C
f : A →+* B
hf : Surjective ⇑f
⊢ (f.comp (RingHom.id A)).FiniteType
state_after: no goals
Theorem: Nat.choose_le_add
File: Mathlib/Data/Nat/Choose/Basic.lean

tactic: induction' b with b_n b_ih
state_before: a b c : ℕ
⊢ a.choose c ≤ (a + b).choose c
state_after: case zero
a c : ℕ
⊢ a.choose c ≤ (a + 0).choose c

case succ
a c b_n : ℕ
b_ih : a.choose c ≤ (a + b_n).choose c
⊢ a.choose c ≤ (a + (b_n + 1)).choose c

tactic: exact le_trans b_ih (choose_le_succ (a + b_n) c)
state_before: case succ
a c b_n : ℕ
b_ih : a.choose c ≤ (a + b_n).choose c
⊢ a.choose c ≤ (a + (b_n + 1)).choose c
state_after: no goals

tactic: simp
state_before: case zero
a c : ℕ
⊢ a.choose c ≤ (a + 0).choose c
state_after: no goals
Theorem: MeasureTheory.ite_ae_eq_of_measure_compl_zero
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

tactic: rw [← mem_ae_iff] at hs_zero
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : μ sᶜ = 0
⊢ (fun x => if x ∈ s then f x else g x) =ᶠ[ae μ] f
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
⊢ (fun x => if x ∈ s then f x else g x) =ᶠ[ae μ] f

tactic: filter_upwards [hs_zero]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
⊢ (fun x => if x ∈ s then f x else g x) =ᶠ[ae μ] f
state_after: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
⊢ ∀ a ∈ s, (if a ∈ s then f a else g a) = f a

tactic: intros
state_before: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
⊢ ∀ a ∈ s, (if a ∈ s then f a else g a) = f a
state_after: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
a✝¹ : α
a✝ : a✝¹ ∈ s
⊢ (if a✝¹ ∈ s then f a✝¹ else g a✝¹) = f a✝¹

tactic: split_ifs
state_before: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
a✝¹ : α
a✝ : a✝¹ ∈ s
⊢ (if a✝¹ ∈ s then f a✝¹ else g a✝¹) = f a✝¹
state_after: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
a✝¹ : α
a✝ : a✝¹ ∈ s
⊢ f a✝¹ = f a✝¹

tactic: rfl
state_before: case h
α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t : Set α
γ : Type u_5
f g : α → γ
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
hs_zero : s ∈ ae μ
a✝¹ : α
a✝ : a✝¹ ∈ s
⊢ f a✝¹ = f a✝¹
state_after: no goals
Theorem: ball_pi'
File: Mathlib/Topology/MetricSpace/Pseudo/Constructions.lean

tactic: simp [ball_eq_empty.2 hr]
state_before: α : Type u_1
β : Type u_2
inst✝³ : PseudoMetricSpace α
π : β → Type u_3
inst✝² : Fintype β
inst✝¹ : (b : β) → PseudoMetricSpace (π b)
inst✝ : Nonempty β
x : (b : β) → π b
r : ℝ
hr : r ≤ 0
⊢ ball x r = Set.univ.pi fun b => ball (x b) r
state_after: no goals
Theorem: Batteries.HashMap.Imp.Buckets.exists_of_update
File: .lake/packages/batteries/Batteries/Data/HashMap/WF.lean

tactic: simp only [Array.data_length, Array.ugetElem_eq_getElem, Array.getElem_eq_data_getElem]
state_before: α : Type u_1
β : Type u_2
self : Buckets α β
i : USize
d : AssocList α β
h : i.toNat < self.val.size
⊢ ∃ l₁ l₂, self.val.data = l₁ ++ self.val[i] :: l₂ ∧ l₁.length = i.toNat ∧ (self.update i d h).val.data = l₁ ++ d :: l₂
state_after: α : Type u_1
β : Type u_2
self : Buckets α β
i : USize
d : AssocList α β
h : i.toNat < self.val.size
⊢ ∃ l₁ l₂,
    self.val.data = l₁ ++ self.val.data[i.toNat] :: l₂ ∧
      l₁.length = i.toNat ∧ (self.update i d h).val.data = l₁ ++ d :: l₂

tactic: exact List.exists_of_set' h
state_before: α : Type u_1
β : Type u_2
self : Buckets α β
i : USize
d : AssocList α β
h : i.toNat < self.val.size
⊢ ∃ l₁ l₂,
    self.val.data = l₁ ++ self.val.data[i.toNat] :: l₂ ∧
      l₁.length = i.toNat ∧ (self.update i d h).val.data = l₁ ++ d :: l₂
state_after: no goals
Theorem: inner_product_apply_eigenvector
File: Mathlib/Analysis/InnerProductSpace/Spectrum.lean

tactic: simp only [mem_eigenspace_iff.mp h, inner_smul_right, inner_self_eq_norm_sq_to_K]
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
μ : 𝕜
v : E
T : E →ₗ[𝕜] E
h : v ∈ eigenspace T μ
⊢ ⟪v, T v⟫_𝕜 = μ * ↑‖v‖ ^ 2
state_after: no goals
Theorem: ENNReal.rpow_add_rpow_le
File: Mathlib/Analysis/MeanInequalitiesPow.lean

tactic: have h_rpow : ∀ a : ℝ≥0∞, a ^ q = (a ^ p) ^ (q / p) := fun a => by
  rw [← ENNReal.rpow_mul, mul_div_cancel₀ _ hp_pos.ne']
state_before: ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
⊢ (a ^ q + b ^ q) ^ (1 / q) ≤ (a ^ p + b ^ p) ^ (1 / p)
state_after: ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
⊢ (a ^ q + b ^ q) ^ (1 / q) ≤ (a ^ p + b ^ p) ^ (1 / p)

tactic: have h_rpow_add_rpow_le_add :
  ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p := by
  refine rpow_add_rpow_le_add (a ^ p) (b ^ p) ?_
  rwa [one_le_div hp_pos]
state_before: ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
⊢ (a ^ q + b ^ q) ^ (1 / q) ≤ (a ^ p + b ^ p) ^ (1 / p)
state_after: ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
h_rpow_add_rpow_le_add : ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p
⊢ (a ^ q + b ^ q) ^ (1 / q) ≤ (a ^ p + b ^ p) ^ (1 / p)

tactic: rw [h_rpow a, h_rpow b, ENNReal.le_rpow_one_div_iff hp_pos, ← ENNReal.rpow_mul, mul_comm,
  mul_one_div]
state_before: ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
h_rpow_add_rpow_le_add : ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p
⊢ (a ^ q + b ^ q) ^ (1 / q) ≤ (a ^ p + b ^ p) ^ (1 / p)
state_after: ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
h_rpow_add_rpow_le_add : ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p
⊢ ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (p / q) ≤ a ^ p + b ^ p

tactic: rwa [one_div_div] at h_rpow_add_rpow_le_add
state_before: ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
h_rpow_add_rpow_le_add : ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p
⊢ ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (p / q) ≤ a ^ p + b ^ p
state_after: no goals

tactic: rw [← ENNReal.rpow_mul, mul_div_cancel₀ _ hp_pos.ne']
state_before: ι : Type u
s : Finset ι
p q : ℝ
a✝ b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
a : ℝ≥0∞
⊢ a ^ q = (a ^ p) ^ (q / p)
state_after: no goals

tactic: refine rpow_add_rpow_le_add (a ^ p) (b ^ p) ?_
state_before: ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
⊢ ((a ^ p) ^ (q / p) + (b ^ p) ^ (q / p)) ^ (1 / (q / p)) ≤ a ^ p + b ^ p
state_after: ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
⊢ 1 ≤ q / p

tactic: rwa [one_le_div hp_pos]
state_before: ι : Type u
s : Finset ι
p q : ℝ
a b : ℝ≥0∞
hp_pos : 0 < p
hpq : p ≤ q
h_rpow : ∀ (a : ℝ≥0∞), a ^ q = (a ^ p) ^ (q / p)
⊢ 1 ≤ q / p
state_after: no goals
Theorem: Ideal.comap_ne_top
File: Mathlib/RingTheory/Ideal/Maps.lean

tactic: rw [mem_comap, map_one]
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
hK : K ≠ ⊤
⊢ 1 ∉ comap f K
state_after: R : Type u
S : Type v
F : Type u_1
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
hK : K ≠ ⊤
⊢ 1 ∉ K

tactic: exact (ne_top_iff_one _).1 hK
state_before: R : Type u
S : Type v
F : Type u_1
inst✝² : Semiring R
inst✝¹ : Semiring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
I J : Ideal R
K L : Ideal S
hK : K ≠ ⊤
⊢ 1 ∉ K
state_after: no goals
Theorem: Nat.le_iff_ne_zero_of_dvd
File: Mathlib/Data/Nat/Defs.lean

tactic: rw [← Nat.pos_iff_ne_zero] at ha ⊢
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
ha : a ≠ 0
hab : a ∣ b
⊢ a ≤ b → b ≠ 0
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
ha : 0 < a
hab : a ∣ b
⊢ a ≤ b → 0 < b

tactic: exact Nat.lt_of_lt_of_le ha
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
ha : 0 < a
hab : a ∣ b
⊢ a ≤ b → 0 < b
state_after: no goals
Theorem: UniqueMul.set_subsingleton
File: Mathlib/Algebra/Group/UniqueProds.lean

tactic: rintro ⟨x1, y1⟩ (hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = a0 * b0) ⟨x2, y2⟩
  (hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = a0 * b0)
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
⊢ {ab | ab.1 ∈ A ∧ ab.2 ∈ B ∧ ab.1 * ab.2 = a0 * b0}.Subsingleton
state_after: case mk.mk
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
x1 y1 : G
hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = a0 * b0
x2 y2 : G
hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = a0 * b0
⊢ (x1, y1) = (x2, y2)

tactic: rcases h hx.1 hx.2.1 hx.2.2 with ⟨rfl, rfl⟩
state_before: case mk.mk
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
x1 y1 : G
hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = a0 * b0
x2 y2 : G
hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = a0 * b0
⊢ (x1, y1) = (x2, y2)
state_after: case mk.mk.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
x1 y1 x2 y2 : G
h : UniqueMul A B x1 y1
hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = x1 * y1
hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = x1 * y1
⊢ (x1, y1) = (x2, y2)

tactic: rcases h hy.1 hy.2.1 hy.2.2 with ⟨rfl, rfl⟩
state_before: case mk.mk.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
x1 y1 x2 y2 : G
h : UniqueMul A B x1 y1
hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = x1 * y1
hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = x1 * y1
⊢ (x1, y1) = (x2, y2)
state_after: case mk.mk.intro.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
x2 y2 : G
h : UniqueMul A B x2 y2
hx hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = x2 * y2
⊢ (x2, y2) = (x2, y2)

tactic: rfl
state_before: case mk.mk.intro.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
x2 y2 : G
h : UniqueMul A B x2 y2
hx hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = x2 * y2
⊢ (x2, y2) = (x2, y2)
state_after: no goals
Theorem: CategoryTheory.Abelian.epiWithInjectiveKernel_of_iso
File: Mathlib/CategoryTheory/Abelian/EpiWithInjectiveKernel.lean

tactic: rw [epiWithInjectiveKernel_iff]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Abelian C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ epiWithInjectiveKernel f
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Abelian C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ ∃ I, ∃ (_ : Injective I), ∃ f_1, ∃ (w : f_1 ≫ f = 0), Nonempty (ShortComplex.mk f_1 f w).Splitting

tactic: exact ⟨0, inferInstance, 0, by simp,
  ⟨ShortComplex.Splitting.ofIsZeroOfIsIso _ (isZero_zero C) (by dsimp; infer_instance)⟩⟩
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Abelian C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ ∃ I, ∃ (_ : Injective I), ∃ f_1, ∃ (w : f_1 ≫ f = 0), Nonempty (ShortComplex.mk f_1 f w).Splitting
state_after: no goals

tactic: simp
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Abelian C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ 0 ≫ f = 0
state_after: no goals

tactic: dsimp
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Abelian C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ IsIso (ShortComplex.mk 0 f ⋯).g
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Abelian C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ IsIso f

tactic: infer_instance
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Abelian C
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ IsIso f
state_after: no goals