ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ProbabilityTheory.Kernel.iIndepFun.indepFun_add_left
File: Mathlib/Probability/Independence/Kernel.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
β✝ : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
f✝ : Ω → β✝
g : Ω → β'
β : Type u_8
m : MeasurableSpace β
inst✝² : Mul β
inst✝¹ : MeasurableMul₂ β
f : ι → Ω → β
inst✝ : IsMarkovKernel κ
hf_indep : iIndepFun (fun x => m) f κ μ
hf_meas : ∀ (i : ι), Measurable (f i)
i j k : ι
hik : i ≠ k
hjk : j ≠ k
⊢ IndepFun (f i * f j) (f k) κ μ
state_after: α : Type u_1
Ω : Type u_2
ι : Type u_3
β✝ : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
f✝ : Ω → β✝
g : Ω → β'
β : Type u_8
m : MeasurableSpace β
inst✝² : Mul β
inst✝¹ : MeasurableMul₂ β
f : ι → Ω → β
inst✝ : IsMarkovKernel κ
hf_indep : iIndepFun (fun x => m) f κ μ
hf_meas : ∀ (i : ι), Measurable (f i)
i j k : ι
hik : i ≠ k
hjk : j ≠ k
this : IndepFun (fun ω => (f i ω, f j ω)) (f k) κ μ
⊢ IndepFun (f i * f j) (f k) κ μ
tactic: have : IndepFun (fun ω => (f i ω, f j ω)) (f k) κ μ :=
    hf_indep.indepFun_prod_mk hf_meas i j k hik hjk
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
β✝ : Type u_4
β' : Type u_5
γ : Type u_6
γ' : Type u_7
_mα : MeasurableSpace α
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
f✝ : Ω → β✝
g : Ω → β'
β : Type u_8
m : MeasurableSpace β
inst✝² : Mul β
inst✝¹ : MeasurableMul₂ β
f : ι → Ω → β
inst✝ : IsMarkovKernel κ
hf_indep : iIndepFun (fun x => m) f κ μ
hf_meas : ∀ (i : ι), Measurable (f i)
i j k : ι
hik : i ≠ k
hjk : j ≠ k
this : IndepFun (fun ω => (f i ω, f j ω)) (f k) κ μ
⊢ IndepFun (f i * f j) (f k) κ μ
state_after: no goals
tactic: simpa using this.comp (measurable_fst.mul measurable_snd) measurable_id
Theorem: Matroid.dual_base_iff
File: Mathlib/Data/Matroid/Dual.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
I B X : Set α
hB : autoParam (B ⊆ M.E) _auto✝
⊢ M✶.Base B ↔ M.Base (M.E \ B)
state_after: α : Type u_1
M : Matroid α
I B X : Set α
hB : autoParam (B ⊆ M.E) _auto✝
⊢ ((B ⊆ M.E ∧ ∃ B_1, M.Base B_1 ∧ Disjoint B B_1) ∧ ∀ (I : Set α), M✶.Indep I → B ⊆ I → B = I) ↔
    (B ⊆ M.E ∧ ∃ B_1, M.Base B_1 ∧ Disjoint B B_1) ∧
      ∀ ⦃y : Set α⦄, (y ⊆ M.E ∧ ∃ B, M.Base B ∧ Disjoint y B) → B ⊆ y → B = y
tactic: rw [base_compl_iff_mem_maximals_disjoint_base, base_iff_maximal_indep, dual_indep_iff_exists',
    mem_maximals_setOf_iff]
state_before: α : Type u_1
M : Matroid α
I B X : Set α
hB : autoParam (B ⊆ M.E) _auto✝
⊢ ((B ⊆ M.E ∧ ∃ B_1, M.Base B_1 ∧ Disjoint B B_1) ∧ ∀ (I : Set α), M✶.Indep I → B ⊆ I → B = I) ↔
    (B ⊆ M.E ∧ ∃ B_1, M.Base B_1 ∧ Disjoint B B_1) ∧
      ∀ ⦃y : Set α⦄, (y ⊆ M.E ∧ ∃ B, M.Base B ∧ Disjoint y B) → B ⊆ y → B = y
state_after: no goals
tactic: simp [dual_indep_iff_exists']
Theorem: Real.one_lt_exp_iff
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y x : ℝ
⊢ 1 < rexp x ↔ 0 < x
state_after: no goals
tactic: rw [← exp_zero, exp_lt_exp]
Theorem: Array.mem_singleton
File: .lake/packages/batteries/Batteries/Data/Array/Lemmas.lean

Proof steps:
state_before: α✝ : Type u_1
a b : α✝
⊢ a ∈ #[b] ↔ a = b
state_after: no goals
tactic: simp
Theorem: PadicInt.norm_mul
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

Proof steps:
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
z1 z2 : ℤ_[p]
⊢ ‖z1 * z2‖ = ‖z1‖ * ‖z2‖
state_after: no goals
tactic: simp [norm_def]
Theorem: convexHull_pair
File: Mathlib/Analysis/Convex/Hull.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
x✝ y✝ x y : E
⊢ (convexHull 𝕜) {x, y} = segment 𝕜 x y
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
x✝ y✝ x y : E
⊢ {x, y} ⊆ segment 𝕜 x y
tactic: refine (convexHull_min ?_ <| convex_segment _ _).antisymm
    (segment_subset_convexHull (mem_insert _ _) <| subset_insert _ _ <| mem_singleton _)
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
x✝ y✝ x y : E
⊢ {x, y} ⊆ segment 𝕜 x y
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
x✝ y✝ x y : E
⊢ x ∈ segment 𝕜 x y ∧ y ∈ segment 𝕜 x y
tactic: rw [insert_subset_iff, singleton_subset_iff]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
x✝ y✝ x y : E
⊢ x ∈ segment 𝕜 x y ∧ y ∈ segment 𝕜 x y
state_after: no goals
tactic: exact ⟨left_mem_segment _ _ _, right_mem_segment _ _ _⟩
Theorem: CategoryTheory.ShortComplex.quasiIso_iff_comp_right
File: Mathlib/Algebra/Homology/ShortComplex/QuasiIso.lean

Proof steps:
state_before: C : Type u_2
inst✝⁵ : Category.{u_1, u_2} C
inst✝⁴ : HasZeroMorphisms C
S₁ S₂ S₃ S₄ : ShortComplex C
inst✝³ : S₁.HasHomology
inst✝² : S₂.HasHomology
inst✝¹ : S₃.HasHomology
inst✝ : S₄.HasHomology
φ : S₁ ⟶ S₂
φ' : S₂ ⟶ S₃
hφ' : QuasiIso φ'
⊢ QuasiIso (φ ≫ φ') ↔ QuasiIso φ
state_after: case mp
C : Type u_2
inst✝⁵ : Category.{u_1, u_2} C
inst✝⁴ : HasZeroMorphisms C
S₁ S₂ S₃ S₄ : ShortComplex C
inst✝³ : S₁.HasHomology
inst✝² : S₂.HasHomology
inst✝¹ : S₃.HasHomology
inst✝ : S₄.HasHomology
φ : S₁ ⟶ S₂
φ' : S₂ ⟶ S₃
hφ' : QuasiIso φ'
⊢ QuasiIso (φ ≫ φ') → QuasiIso φ

case mpr
C : Type u_2
inst✝⁵ : Category.{u_1, u_2} C
inst✝⁴ : HasZeroMorphisms C
S₁ S₂ S₃ S₄ : ShortComplex C
inst✝³ : S₁.HasHomology
inst✝² : S₂.HasHomology
inst✝¹ : S₃.HasHomology
inst✝ : S₄.HasHomology
φ : S₁ ⟶ S₂
φ' : S₂ ⟶ S₃
hφ' : QuasiIso φ'
⊢ QuasiIso φ → QuasiIso (φ ≫ φ')
tactic: constructor
Theorem: TrivSqZeroExt.inl_mul_eq_smul
File: Mathlib/Algebra/TrivSqZeroExt.lean

Proof steps:
state_before: R : Type u
M : Type v
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module Rᵐᵒᵖ M
r : R
x : tsze R M
⊢ (inl r * x).snd = (r •> x).snd
state_after: R : Type u
M : Type v
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module Rᵐᵒᵖ M
r : R
x : tsze R M
⊢ r •> x.snd + 0 <• x.fst = r •> x.snd
tactic: dsimp
state_before: R : Type u
M : Type v
inst✝³ : Semiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : Module Rᵐᵒᵖ M
r : R
x : tsze R M
⊢ r •> x.snd + 0 <• x.fst = r •> x.snd
state_after: no goals
tactic: rw [smul_zero, add_zero]
Theorem: List.get?_set_ne
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
a : α
m n : Nat
l : List α
h : m ≠ n
⊢ (l.set m a).get? n = l.get? n
state_after: no goals
tactic: simp [h]
Theorem: _private.Mathlib.Data.Complex.Abs.0.Complex.AbsTheory.abs_add
File: Mathlib/Data/Complex/Abs.lean

Proof steps:
state_before: z w : ℂ
⊢ ((abs z + w) * abs z + w) ≤ ((abs z) + abs w) * ((abs z) + abs w)
state_after: z w : ℂ
⊢ (z * (starRingEnd ℂ) w).re ≤ abs z * (starRingEnd ℂ) w
tactic: rw [mul_self_abs, add_mul_self_eq, mul_self_abs, mul_self_abs, add_right_comm, normSq_add,
      add_le_add_iff_left, mul_assoc, mul_le_mul_left (zero_lt_two' ℝ), ←
      Real.sqrt_mul <| normSq_nonneg z, ← normSq_conj w, ← map_mul]
state_before: z w : ℂ
⊢ (z * (starRingEnd ℂ) w).re ≤ abs z * (starRingEnd ℂ) w
state_after: no goals
tactic: exact re_le_abs (z * conj w)
Theorem: Real.cos_add_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

Proof steps:
state_before: x : ℝ
⊢ cos (x + π / 2) = -sin x
state_after: no goals
tactic: simp [cos_add]
Theorem: OrderMonoidHom.toOrderHom_injective
File: Mathlib/Algebra/Order/Hom/Monoid.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulOneClass α
inst✝² : MulOneClass β
inst✝¹ : MulOneClass γ
inst✝ : MulOneClass δ
f✝ g✝ f g : α →*o β
h : f.toOrderHom = g.toOrderHom
⊢ ∀ (a : α), f a = g a
state_after: no goals
tactic: convert DFunLike.ext_iff.1 h using 0
Theorem: MeasurableSet.of_union_cover
File: Mathlib/MeasureTheory/MeasurableSpace/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s t u : Set α
hs : MeasurableSet s
ht : MeasurableSet t
h : univ ⊆ s ∪ t
hsu : MeasurableSet (Subtype.val ⁻¹' u)
htu : MeasurableSet (Subtype.val ⁻¹' u)
⊢ MeasurableSet u
state_after: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s t u : Set α
hs : MeasurableSet s
ht : MeasurableSet t
h : univ ⊆ s ∪ t
hsu : MeasurableSet (Subtype.val ⁻¹' u)
htu : MeasurableSet (Subtype.val ⁻¹' u)
⊢ u = Subtype.val '' (Subtype.val ⁻¹' u) ∪ Subtype.val '' (Subtype.val ⁻¹' u)
tactic: convert (hs.subtype_image hsu).union (ht.subtype_image htu)
state_before: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t✝ u✝ : Set α
m : MeasurableSpace α
mβ : MeasurableSpace β
s t u : Set α
hs : MeasurableSet s
ht : MeasurableSet t
h : univ ⊆ s ∪ t
hsu : MeasurableSet (Subtype.val ⁻¹' u)
htu : MeasurableSet (Subtype.val ⁻¹' u)
⊢ u = Subtype.val '' (Subtype.val ⁻¹' u) ∪ Subtype.val '' (Subtype.val ⁻¹' u)
state_after: no goals
tactic: simp [image_preimage_eq_inter_range, ← inter_union_distrib_left, univ_subset_iff.1 h]
Theorem: Real.Gamma_three_div_two_lt_one
File: Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean

Proof steps:
state_before: ⊢ Gamma (3 / 2) < 1
state_after: A : 0 < 3 / 2
⊢ Gamma (3 / 2) < 1
tactic: have A : (0 : ℝ) < 3 / 2 := by norm_num
state_before: A : 0 < 3 / 2
⊢ Gamma (3 / 2) < 1
state_after: case refine_2
A : 0 < 3 / 2
this : (log ∘ Gamma) (↑2 + 1 / 2) ≤ (log ∘ Gamma) ↑2 + 1 / 2 * log ↑2
⊢ Gamma (3 / 2) < 1

case refine_1
A : 0 < 3 / 2
y : ℝ
hy : 0 < y
⊢ (log ∘ Gamma) (y + 1) = (log ∘ Gamma) y + log y
tactic: have :=
    BohrMollerup.f_add_nat_le convexOn_log_Gamma (fun {y} hy => ?_) two_ne_zero one_half_pos
      (by norm_num : 1 / 2 ≤ (1 : ℝ))
state_before: case refine_2
A : 0 < 3 / 2
this : (log ∘ Gamma) (↑2 + 1 / 2) ≤ (log ∘ Gamma) ↑2 + 1 / 2 * log ↑2
⊢ Gamma (3 / 2) < 1

case refine_1
A : 0 < 3 / 2
y : ℝ
hy : 0 < y
⊢ (log ∘ Gamma) (y + 1) = (log ∘ Gamma) y + log y
state_after: case refine_1
A : 0 < 3 / 2
y : ℝ
hy : 0 < y
⊢ (log ∘ Gamma) (y + 1) = (log ∘ Gamma) y + log y

case refine_2
A : 0 < 3 / 2
this : (log ∘ Gamma) (↑2 + 1 / 2) ≤ (log ∘ Gamma) ↑2 + 1 / 2 * log ↑2
⊢ Gamma (3 / 2) < 1
tactic: swap
state_before: case refine_2
A : 0 < 3 / 2
this : (log ∘ Gamma) (↑2 + 1 / 2) ≤ (log ∘ Gamma) ↑2 + 1 / 2 * log ↑2
⊢ Gamma (3 / 2) < 1
state_after: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ Gamma (3 / 2) < 1
tactic: rw [Function.comp_apply, Function.comp_apply, Nat.cast_two, Gamma_two, log_one, zero_add,
    (by norm_num : (2 : ℝ) + 1 / 2 = 3 / 2 + 1), Gamma_add_one A.ne',
    log_mul A.ne' (Gamma_pos_of_pos A).ne', ← le_sub_iff_add_le',
    log_le_iff_le_exp (Gamma_pos_of_pos A)] at this
state_before: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ Gamma (3 / 2) < 1
state_after: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ 1 / 2 * log 2 - log (3 / 2) < 0
tactic: refine this.trans_lt (exp_lt_one_iff.mpr ?_)
state_before: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ 1 / 2 * log 2 - log (3 / 2) < 0
state_after: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ (log 2 * 1 - 2 * log (3 / 2)) / 2 < 0
tactic: rw [mul_comm, ← mul_div_assoc, div_sub' _ _ (2 : ℝ) two_ne_zero]
state_before: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ (log 2 * 1 - 2 * log (3 / 2)) / 2 < 0
state_after: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ log 2 * 1 - 2 * log (3 / 2) < 0
tactic: refine div_neg_of_neg_of_pos ?_ two_pos
state_before: case refine_2
A : 0 < 3 / 2
this : Gamma (3 / 2) ≤ rexp (1 / 2 * log 2 - log (3 / 2))
⊢ log 2 * 1 - 2 * log (3 / 2) < 0
state_after: no goals
tactic: rw [sub_neg, mul_one, ← Nat.cast_two, ← log_pow, ← exp_lt_exp, Nat.cast_two, exp_log two_pos,
      exp_log] <;>
    norm_num
Theorem: EReal.tendsto_nhds_top_iff_real
File: Mathlib/Topology/Instances/EReal.lean

Proof steps:
state_before: α✝ : Type u_1
inst✝ : TopologicalSpace α✝
α : Type u_2
m : α → EReal
f : Filter α
⊢ (∀ (i : ℝ), True → ∀ᶠ (x : α) in f, m x ∈ Ioi ↑i) ↔ ∀ (x : ℝ), ∀ᶠ (a : α) in f, ↑x < m a
state_after: no goals
tactic: simp only [true_implies, mem_Ioi]
Theorem: Filter.tendsto_atTop_embedding
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : Preorder β
inst✝ : Preorder γ
f : α → β
e : β → γ
l : Filter α
hm : ∀ (b₁ b₂ : β), e b₁ ≤ e b₂ ↔ b₁ ≤ b₂
hu : ∀ (c : γ), ∃ b, c ≤ e b
⊢ Tendsto (e ∘ f) l atTop ↔ Tendsto f l atTop
state_after: no goals
tactic: rw [← comap_embedding_atTop hm hu, tendsto_comap_iff]
Theorem: Real.log_lt_iff_lt_exp
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: x y : ℝ
hx : 0 < x
⊢ log x < y ↔ x < rexp y
state_after: no goals
tactic: rw [← exp_lt_exp, exp_log hx]
Theorem: zeta_eq_tsum_one_div_nat_add_one_cpow
File: Mathlib/NumberTheory/LSeries/RiemannZeta.lean

Proof steps:
state_before: s : ℂ
hs : 1 < s.re
⊢ riemannZeta s = ∑' (n : ℕ), 1 / (↑n + 1) ^ s
state_after: s : ℂ
hs : 1 < s.re
this : riemannZeta s = ∑' (n : ℕ), 1 / ↑n ^ s
⊢ riemannZeta s = ∑' (n : ℕ), 1 / (↑n + 1) ^ s
tactic: have := zeta_eq_tsum_one_div_nat_cpow hs
state_before: s : ℂ
hs : 1 < s.re
this : riemannZeta s = ∑' (n : ℕ), 1 / ↑n ^ s
⊢ riemannZeta s = ∑' (n : ℕ), 1 / (↑n + 1) ^ s
state_after: s : ℂ
hs : 1 < s.re
this : riemannZeta s = 1 / ↑0 ^ s + ∑' (b : ℕ), 1 / ↑(b + 1) ^ s
⊢ riemannZeta s = ∑' (n : ℕ), 1 / (↑n + 1) ^ s

s : ℂ
hs : 1 < s.re
this : riemannZeta s = ∑' (n : ℕ), 1 / ↑n ^ s
⊢ Summable fun n => 1 / ↑n ^ s
tactic: rw [tsum_eq_zero_add] at this
Theorem: List.mapIdx_append_one
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β : Type v
⊢ ∀ (f : ℕ → α → β) (l : List α) (e : α), mapIdx f (l ++ [e]) = mapIdx f l ++ [f l.length e]
state_after: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ mapIdx f (l ++ [e]) = mapIdx f l ++ [f l.length e]
tactic: intros f l e
state_before: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ mapIdx f (l ++ [e]) = mapIdx f l ++ [f l.length e]
state_after: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ mapIdx.go f (l ++ [e]) #[] = mapIdx.go f l #[] ++ [f l.length e]
tactic: unfold mapIdx
state_before: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ mapIdx.go f (l ++ [e]) #[] = mapIdx.go f l #[] ++ [f l.length e]
state_after: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ mapIdx.go f [e] (toArray (mapIdx.go f l #[])) = mapIdx.go f l #[] ++ [f l.length e]
tactic: rw [mapIdxGo_append f l [e]]
state_before: α : Type u
β : Type v
f : ℕ → α → β
l : List α
e : α
⊢ mapIdx.go f [e] (toArray (mapIdx.go f l #[])) = mapIdx.go f l #[] ++ [f l.length e]
state_after: no goals
tactic: simp only [mapIdx.go, Array.size_toArray, mapIdxGo_length, length_nil, Nat.add_zero,
    Array.toList_eq, Array.push_data, Array.data_toArray]
Theorem: LieModule.isNilpotent_toEnd_of_isNilpotent
File: Mathlib/Algebra/Lie/Nilpotent.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝¹¹ : CommRing R
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra R L
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : LieRingModule L M
inst✝⁵ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R M₂
inst✝² : LieRingModule L M₂
inst✝¹ : LieModule R L M₂
inst✝ : IsNilpotent R L M
x : L
⊢ _root_.IsNilpotent ((toEnd R L M) x)
state_after: R : Type u
L : Type v
M : Type w
inst✝¹¹ : CommRing R
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra R L
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : LieRingModule L M
inst✝⁵ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R M₂
inst✝² : LieRingModule L M₂
inst✝¹ : LieModule R L M₂
inst✝ : IsNilpotent R L M
x : L
⊢ ∃ k, (toEnd R L M) x ^ k = 0
tactic: change ∃ k, toEnd R L M x ^ k = 0
state_before: R : Type u
L : Type v
M : Type w
inst✝¹¹ : CommRing R
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra R L
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : LieRingModule L M
inst✝⁵ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R M₂
inst✝² : LieRingModule L M₂
inst✝¹ : LieModule R L M₂
inst✝ : IsNilpotent R L M
x : L
⊢ ∃ k, (toEnd R L M) x ^ k = 0
state_after: R : Type u
L : Type v
M : Type w
inst✝¹¹ : CommRing R
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra R L
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : LieRingModule L M
inst✝⁵ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R M₂
inst✝² : LieRingModule L M₂
inst✝¹ : LieModule R L M₂
inst✝ : IsNilpotent R L M
x : L
this : ∃ k, ∀ (x : L), (toEnd R L M) x ^ k = 0
⊢ ∃ k, (toEnd R L M) x ^ k = 0
tactic: have := exists_forall_pow_toEnd_eq_zero R L M
state_before: R : Type u
L : Type v
M : Type w
inst✝¹¹ : CommRing R
inst✝¹⁰ : LieRing L
inst✝⁹ : LieAlgebra R L
inst✝⁸ : AddCommGroup M
inst✝⁷ : Module R M
inst✝⁶ : LieRingModule L M
inst✝⁵ : LieModule R L M
k : ℕ
N : LieSubmodule R L M
M₂ : Type w₁
inst✝⁴ : AddCommGroup M₂
inst✝³ : Module R M₂
inst✝² : LieRingModule L M₂
inst✝¹ : LieModule R L M₂
inst✝ : IsNilpotent R L M
x : L
this : ∃ k, ∀ (x : L), (toEnd R L M) x ^ k = 0
⊢ ∃ k, (toEnd R L M) x ^ k = 0
state_after: no goals
tactic: tauto
Theorem: Finset.insertNone_eraseNone
File: Mathlib/Data/Finset/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq (Option α)
s : Finset (Option α)
⊢ insertNone (eraseNone s) = insert none s
state_after: no goals
tactic: ext (_ | x) <;> simp
Theorem: HilbertBasis.hasSum_inner_mul_inner
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
x y : E
⊢ HasSum
    (fun i => ⟪x, (fun i => b.repr.symm (lp.single 2 i 1)) i⟫_𝕜 * ⟪(fun i => b.repr.symm (lp.single 2 i 1)) i, y⟫_𝕜)
    ⟪x, y⟫_𝕜
state_after: case h.e'_5
ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
x y : E
⊢ (fun i => ⟪x, (fun i => b.repr.symm (lp.single 2 i 1)) i⟫_𝕜 * ⟪(fun i => b.repr.symm (lp.single 2 i 1)) i, y⟫_𝕜) =
    fun b_1 => ((innerSL 𝕜) x) (↑(b.repr y) b_1 • (fun i => b.repr.symm (lp.single 2 i 1)) b_1)
tactic: convert (b.hasSum_repr y).mapL (innerSL 𝕜 x) using 1
state_before: case h.e'_5
ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
x y : E
⊢ (fun i => ⟪x, (fun i => b.repr.symm (lp.single 2 i 1)) i⟫_𝕜 * ⟪(fun i => b.repr.symm (lp.single 2 i 1)) i, y⟫_𝕜) =
    fun b_1 => ((innerSL 𝕜) x) (↑(b.repr y) b_1 • (fun i => b.repr.symm (lp.single 2 i 1)) b_1)
state_after: case h.e'_5.h
ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
x y : E
i : ι
⊢ ⟪x, (fun i => b.repr.symm (lp.single 2 i 1)) i⟫_𝕜 * ⟪(fun i => b.repr.symm (lp.single 2 i 1)) i, y⟫_𝕜 =
    ((innerSL 𝕜) x) (↑(b.repr y) i • (fun i => b.repr.symm (lp.single 2 i 1)) i)
tactic: ext i
state_before: case h.e'_5.h
ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
x y : E
i : ι
⊢ ⟪x, (fun i => b.repr.symm (lp.single 2 i 1)) i⟫_𝕜 * ⟪(fun i => b.repr.symm (lp.single 2 i 1)) i, y⟫_𝕜 =
    ((innerSL 𝕜) x) (↑(b.repr y) i • (fun i => b.repr.symm (lp.single 2 i 1)) i)
state_after: no goals
tactic: rw [innerSL_apply, b.repr_apply_apply, inner_smul_right, mul_comm]
Theorem: Associates.factors_le
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
⊢ a.factors ≤ b.factors ↔ a ≤ b
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
h : a.factors ≤ b.factors
⊢ a ≤ b
tactic: refine ⟨fun h ↦ ?_, factors_mono⟩
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
h : a.factors ≤ b.factors
⊢ a ≤ b
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
h : a.factors ≤ b.factors
this : a.factors.prod ≤ b.factors.prod
⊢ a ≤ b
tactic: have : a.factors.prod ≤ b.factors.prod := prod_mono h
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a b : Associates α
h : a.factors ≤ b.factors
this : a.factors.prod ≤ b.factors.prod
⊢ a ≤ b
state_after: no goals
tactic: rwa [factors_prod, factors_prod] at this
Theorem: bddBelow_upperClosure
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝¹ : Preorder α
inst✝ : Preorder β
s t : Set α
x : α
⊢ BddBelow ↑(upperClosure s) ↔ BddBelow s
state_after: no goals
tactic: simp_rw [BddBelow, lowerBounds_upperClosure]
Theorem: AddSubmonoid.closure_mul_closure
File: Mathlib/Algebra/Group/Submonoid/Pointwise.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
M : Type u_3
R : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : AddMonoid A
inst✝ : NonUnitalNonAssocSemiring R
S T : Set R
⊢ closure S * closure T = closure (S * T)
state_after: case a
α : Type u_1
G : Type u_2
M : Type u_3
R : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : AddMonoid A
inst✝ : NonUnitalNonAssocSemiring R
S T : Set R
⊢ closure S * closure T ≤ closure (S * T)

case a
α : Type u_1
G : Type u_2
M : Type u_3
R : Type u_4
A : Type u_5
inst✝² : Monoid M
inst✝¹ : AddMonoid A
inst✝ : NonUnitalNonAssocSemiring R
S T : Set R
⊢ closure (S * T) ≤ closure S * closure T
tactic: apply le_antisymm
Theorem: Finite.card_le_of_injective
File: Mathlib/Data/Finite/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite β
f : α → β
hf : Function.Injective f
⊢ Nat.card α ≤ Nat.card β
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite β
f : α → β
hf : Function.Injective f
this : Fintype β
⊢ Nat.card α ≤ Nat.card β
tactic: haveI := Fintype.ofFinite β
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite β
f : α → β
hf : Function.Injective f
this : Fintype β
⊢ Nat.card α ≤ Nat.card β
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite β
f : α → β
hf : Function.Injective f
this✝ : Fintype β
this : Fintype α
⊢ Nat.card α ≤ Nat.card β
tactic: haveI := Fintype.ofInjective f hf
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite β
f : α → β
hf : Function.Injective f
this✝ : Fintype β
this : Fintype α
⊢ Nat.card α ≤ Nat.card β
state_after: no goals
tactic: simpa only [Nat.card_eq_fintype_card] using Fintype.card_le_of_injective f hf