ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finset.mulEnergy_empty_right
File: Mathlib/Combinatorics/Additive/Energy.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Mul α
s s₁ s₂ t t₁ t₂ : Finset α
⊢ Eₘ[s, ∅] = 0
state_after: no goals
tactic: simp [mulEnergy]
Theorem: Finset.map_add_right_Ico
File: Mathlib/Algebra/Order/Interval/Finset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ map (addRightEmbedding c) (Ico a b) = Ico (a + c) (b + c)
state_after: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ⇑(addRightEmbedding c) '' Set.Ico a b = Set.Ico (a + c) (b + c)
tactic: rw [← coe_inj, coe_map, coe_Ico, coe_Ico]
state_before: ι : Type u_1
α : Type u_2
inst✝² : OrderedCancelAddCommMonoid α
inst✝¹ : ExistsAddOfLE α
inst✝ : LocallyFiniteOrder α
a b c : α
⊢ ⇑(addRightEmbedding c) '' Set.Ico a b = Set.Ico (a + c) (b + c)
state_after: no goals
tactic: exact Set.image_add_const_Ico _ _ _
Theorem: SetTheory.PGame.birthday_one_add
File: Mathlib/SetTheory/Game/Birthday.lean

Proof steps:
state_before: a b x : PGame
⊢ (1 + a).birthday = Order.succ a.birthday
state_after: no goals
tactic: simp
Theorem: subset_interior_iff_isOpen
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ s ⊆ interior s ↔ IsOpen s
state_after: no goals
tactic: simp only [interior_eq_iff_isOpen.symm, Subset.antisymm_iff, interior_subset, true_and]
Theorem: Set.einfsep_of_fintype
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : EDist α
x y : α
s t : Set α
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
⊢ s.einfsep = s.offDiag.toFinset.inf (uncurry edist)
state_after: α : Type u_1
β : Type u_2
inst✝² : EDist α
x y : α
s t : Set α
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
x✝ : ℝ≥0∞
⊢ x✝ ≤ s.einfsep ↔ x✝ ≤ s.offDiag.toFinset.inf (uncurry edist)
tactic: refine eq_of_forall_le_iff fun _ => ?_
state_before: α : Type u_1
β : Type u_2
inst✝² : EDist α
x y : α
s t : Set α
inst✝¹ : DecidableEq α
inst✝ : Fintype ↑s
x✝ : ℝ≥0∞
⊢ x✝ ≤ s.einfsep ↔ x✝ ≤ s.offDiag.toFinset.inf (uncurry edist)
state_after: no goals
tactic: simp_rw [le_einfsep_iff, imp_forall_iff, Finset.le_inf_iff, mem_toFinset, mem_offDiag,
    Prod.forall, uncurry_apply_pair, and_imp]
Theorem: HurwitzZeta.LSeriesHasSum_sin
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
⊢ LSeriesHasSum (fun x => ↑(Real.sin (2 * π * a * ↑x))) s (sinZeta (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ LSeries.term (fun x => ↑(Real.sin (2 * π * a * ↑x))) s n = ↑(Real.sin (2 * π * a * ↑n)) / ↑n ^ s
tactic: refine (hasSum_nat_sinZeta a hs).congr_fun (fun n ↦ ?_)
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
⊢ LSeries.term (fun x => ↑(Real.sin (2 * π * a * ↑x))) s n = ↑(Real.sin (2 * π * a * ↑n)) / ↑n ^ s
state_after: case inl
a : ℝ
s : ℂ
hs : 1 < s.re
⊢ LSeries.term (fun x => ↑(Real.sin (2 * π * a * ↑x))) s 0 = ↑(Real.sin (2 * π * a * ↑0)) / ↑0 ^ s

case inr
a : ℝ
s : ℂ
hs : 1 < s.re
n : ℕ
hn : n ≠ 0
⊢ LSeries.term (fun x => ↑(Real.sin (2 * π * a * ↑x))) s n = ↑(Real.sin (2 * π * a * ↑n)) / ↑n ^ s
tactic: rcases eq_or_ne n 0 with rfl | hn
Theorem: Substring.Valid.foldr
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

Proof steps:
state_before: α : Type u_1
f : Char → α → α
init : α
x✝ : Substring
h✝ : x✝.Valid
w✝² w✝¹ w✝ : List Char
h : ValidFor w✝² w✝¹ w✝ x✝
⊢ Substring.foldr f init x✝ = List.foldr f init x✝.toString.data
state_after: no goals
tactic: simp [h.foldr, h.toString]
Theorem: Fin.preimage_insertNth_Icc_of_mem
File: Mathlib/Order/Fin/Tuple.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u_1
x✝ : α 0
q : (i : Fin (n + 1)) → α i
p✝ : (i : Fin n) → α i.succ
i✝ : Fin n
y : α i✝.succ
z : α 0
inst✝ : (i : Fin (n + 1)) → Preorder (α i)
i : Fin (n + 1)
x : α i
q₁ q₂ : (j : Fin (n + 1)) → α j
hx : x ∈ Icc (q₁ i) (q₂ i)
p : (j : Fin n) → α (i.succAbove j)
⊢ p ∈ i.insertNth x ⁻¹' Icc q₁ q₂ ↔ p ∈ Icc (fun j => q₁ (i.succAbove j)) fun j => q₂ (i.succAbove j)
state_after: no goals
tactic: simp only [mem_preimage, insertNth_mem_Icc, hx, true_and_iff]
Theorem: PowerSeries.derivativeFun_coe
File: Mathlib/RingTheory/PowerSeries/Derivative.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemiring R
f : R[X]
⊢ (↑f).derivativeFun = ↑(derivative f)
state_after: case h
R : Type u_1
inst✝ : CommSemiring R
f : R[X]
n✝ : ℕ
⊢ (coeff R n✝) (↑f).derivativeFun = (coeff R n✝) ↑(derivative f)
tactic: ext
state_before: case h
R : Type u_1
inst✝ : CommSemiring R
f : R[X]
n✝ : ℕ
⊢ (coeff R n✝) (↑f).derivativeFun = (coeff R n✝) ↑(derivative f)
state_after: no goals
tactic: rw [coeff_derivativeFun, coeff_coe, coeff_coe, coeff_derivative]
Theorem: Subsingleton.pi_mulSingle_eq
File: Mathlib/Algebra/Group/Pi/Basic.lean

Proof steps:
state_before: I : Type u
α✝ : Type u_1
β : Type u_2
γ : Type u_3
f : I → Type v₁
g : I → Type v₂
h : I → Type v₃
x✝ y : (i : I) → f i
i✝ : I
α : Type u_4
inst✝² : DecidableEq I
inst✝¹ : Subsingleton I
inst✝ : One α
i : I
x : α
j : I
⊢ Pi.mulSingle i x j = x
state_after: no goals
tactic: rw [Subsingleton.elim j i, Pi.mulSingle_eq_same]
Theorem: Multiset.multinomial_zero
File: Mathlib/Data/Nat/Choose/Multinomial.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
⊢ multinomial 0 = 1
state_after: no goals
tactic: simp [multinomial, Finsupp.multinomial]
Theorem: Matrix.one_hadamard
File: Mathlib/Data/Matrix/Hadamard.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
m : Type u_4
n : Type u_5
R : Type u_6
A B C : Matrix m n α
inst✝¹ : DecidableEq n
inst✝ : MulZeroOneClass α
M : Matrix n n α
⊢ 1 ⊙ M = diagonal fun i => M i i
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
m : Type u_4
n : Type u_5
R : Type u_6
A B C : Matrix m n α
inst✝¹ : DecidableEq n
inst✝ : MulZeroOneClass α
M : Matrix n n α
i j : n
⊢ (1 ⊙ M) i j = diagonal (fun i => M i i) i j
tactic: ext i j
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
m : Type u_4
n : Type u_5
R : Type u_6
A B C : Matrix m n α
inst✝¹ : DecidableEq n
inst✝ : MulZeroOneClass α
M : Matrix n n α
i j : n
⊢ (1 ⊙ M) i j = diagonal (fun i => M i i) i j
state_after: no goals
tactic: by_cases h : i = j <;> simp [h]
Theorem: ContinuousLinearMap.intervalIntegral_apply
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : CompleteSpace E
inst✝⁴ : NormedSpace ℝ E
a✝ b✝ : ℝ
μ : Measure ℝ
f : ℝ → E
inst✝³ : RCLike 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
a b : ℝ
φ : ℝ → F →L[𝕜] E
hφ : IntervalIntegrable φ μ a b
v : F
⊢ (∫ (x : ℝ) in a..b, φ x ∂μ) v = ∫ (x : ℝ) in a..b, (φ x) v ∂μ
state_after: no goals
tactic: simp_rw [intervalIntegral_eq_integral_uIoc, ← integral_apply hφ.def' v, coe_smul', Pi.smul_apply]
Theorem: MulAction.IsBlock.def
File: Mathlib/GroupTheory/GroupAction/Blocks.lean

Proof steps:
state_before: G : Type u_1
X : Type u_2
inst✝ : SMul G X
B : Set X
⊢ IsBlock G B ↔ ∀ (g g' : G), g • B = g' • B ∨ Disjoint (g • B) (g' • B)
state_after: no goals
tactic: apply Set.pairwiseDisjoint_range_iff
Theorem: div_self_mul_self
File: Mathlib/Algebra/GroupWithZero/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
⊢ a / a * a = a
state_after: no goals
tactic: rw [div_eq_mul_inv, mul_inv_mul_self a]
Theorem: List.replaceF_eq_replaceFTR.go
File: .lake/packages/batteries/Batteries/Data/List/Basic.lean

Proof steps:
state_before: ⊢ @replaceF = @replaceFTR
state_after: case h.h.h
α : Type u_1
p : α → Option α
l : List α
⊢ replaceF p l = replaceFTR p l
tactic: funext α p l
state_before: case h.h.h
α : Type u_1
p : α → Option α
l : List α
⊢ replaceF p l = replaceFTR p l
state_after: case h.h.h
α : Type u_1
p : α → Option α
l : List α
⊢ replaceF p l = replaceFTR.go p l #[]
tactic: simp [replaceFTR]
state_before: α : Type u_1
p : α → Option α
l : List α
acc : Array α
⊢ replaceFTR.go p [] acc = acc.data ++ replaceF p []
state_after: no goals
tactic: simp [replaceFTR.go, replaceF]
state_before: α : Type u_1
p : α → Option α
l : List α
acc : Array α
x : α
xs : List α
⊢ replaceFTR.go p (x :: xs) acc = acc.data ++ replaceF p (x :: xs)
state_after: α : Type u_1
p : α → Option α
l : List α
acc : Array α
x : α
xs : List α
⊢ (match p x with
    | none => replaceFTR.go p xs (acc.push x)
    | some a' => acc.data ++ a' :: xs) =
    acc.data ++
      match p x with
      | none => x :: replaceF p xs
      | some a => a :: xs
tactic: simp [replaceFTR.go, replaceF]
state_before: α : Type u_1
p : α → Option α
l : List α
acc : Array α
x : α
xs : List α
⊢ (match p x with
    | none => replaceFTR.go p xs (acc.push x)
    | some a' => acc.data ++ a' :: xs) =
    acc.data ++
      match p x with
      | none => x :: replaceF p xs
      | some a => a :: xs
state_after: case none
α : Type u_1
p : α → Option α
l : List α
acc : Array α
x : α
xs : List α
⊢ replaceFTR.go p xs (acc.push x) = acc.data ++ x :: replaceF p xs
tactic: cases p x <;> simp
state_before: case h.h.h
α : Type u_1
p : α → Option α
l : List α
⊢ replaceF p l = replaceFTR.go p l #[]
state_after: no goals
tactic: exact (go #[] _).symm
Theorem: padicValNat.pow_two_sub_pow
File: Mathlib/NumberTheory/Multiplicity.lean

Proof steps:
state_before: R : Type u_1
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : n ≠ 0
hneven : Even n
⊢ padicValNat 2 (x ^ n - y ^ n) + 1 = padicValNat 2 (x + y) + padicValNat 2 (x - y) + padicValNat 2 n
state_after: R : Type u_1
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : n ≠ 0
hneven : Even n
⊢ ↑(padicValNat 2 (x ^ n - y ^ n)) + ↑1 = ↑(padicValNat 2 (x + y)) + ↑(padicValNat 2 (x - y)) + ↑(padicValNat 2 n)
tactic: simp only [← PartENat.natCast_inj, Nat.cast_add]
state_before: R : Type u_1
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : n ≠ 0
hneven : Even n
⊢ ↑(padicValNat 2 (x ^ n - y ^ n)) + ↑1 = ↑(padicValNat 2 (x + y)) + ↑(padicValNat 2 (x - y)) + ↑(padicValNat 2 n)
state_after: R : Type u_1
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : n ≠ 0
hneven : Even n
⊢ multiplicity 2 (x ^ n - y ^ n) + ↑1 = multiplicity 2 (x + y) + multiplicity 2 (x - y) + multiplicity 2 n

R : Type u_1
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : n ≠ 0
hneven : Even n
⊢ 0 < n

R : Type u_1
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : n ≠ 0
hneven : Even n
⊢ 0 < x - y

R : Type u_1
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : n ≠ 0
hneven : Even n
⊢ 0 < x + y

R : Type u_1
n✝ x y : ℕ
hyx : y < x
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : n ≠ 0
hneven : Even n
⊢ 0 < x ^ n - y ^ n
tactic: iterate 4 rw [padicValNat_def, PartENat.natCast_get]
Theorem: schnirelmannDensity_le_div
File: Mathlib/Combinatorics/Schnirelmann.lean

Proof steps:
state_before: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
n : ℕ
hn : n ≠ 0
x✝¹ : ℝ
x✝ : x✝¹ ∈ Set.range fun n => ↑(filter (fun x => x ∈ A) (Ioc 0 ↑n)).card / ↑↑n
w✝ : { n // 0 < n }
hx : (fun n => ↑(filter (fun x => x ∈ A) (Ioc 0 ↑n)).card / ↑↑n) w✝ = x✝¹
⊢ 0 ≤ (fun n => ↑(filter (fun x => x ∈ A) (Ioc 0 ↑n)).card / ↑↑n) w✝
state_after: no goals
tactic: positivity
Theorem: Ordinal.bmex_lt_ord_succ_card
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ o.bmex f < (succ o.card).ord
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ o.bmex f < (succ #(Quotient.out o).α).ord
tactic: rw [← mk_ordinal_out]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
f : (a : Ordinal.{u}) → a < o → Ordinal.{u}
⊢ o.bmex f < (succ #(Quotient.out o).α).ord
state_after: no goals
tactic: exact mex_lt_ord_succ_mk (familyOfBFamily o f)
Theorem: Complex.cos_arg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x✝ z x : ℂ
hx : x ≠ 0
⊢ Real.cos x.arg = x.re / abs x
state_after: a x✝ z x : ℂ
hx : x ≠ 0
⊢ Real.cos
      (if 0 ≤ x.re then Real.arcsin (x.im / abs x)
      else if 0 ≤ x.im then Real.arcsin ((-x).im / abs x) + π else Real.arcsin ((-x).im / abs x) - π) =
    x.re / abs x
tactic: rw [arg]
state_before: a x✝ z x : ℂ
hx : x ≠ 0
⊢ Real.cos
      (if 0 ≤ x.re then Real.arcsin (x.im / abs x)
      else if 0 ≤ x.im then Real.arcsin ((-x).im / abs x) + π else Real.arcsin ((-x).im / abs x) - π) =
    x.re / abs x
state_after: case pos
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : 0 ≤ x.re
⊢ Real.cos (Real.arcsin (x.im / abs x)) = x.re / abs x

case pos
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : ¬0 ≤ x.re
h₂ : 0 ≤ x.im
⊢ Real.cos (Real.arcsin ((-x).im / abs x) + π) = x.re / abs x

case neg
a x✝ z x : ℂ
hx : x ≠ 0
h₁ : ¬0 ≤ x.re
h₂ : ¬0 ≤ x.im
⊢ Real.cos (Real.arcsin ((-x).im / abs x) - π) = x.re / abs x
tactic: split_ifs with h₁ h₂
Theorem: Real.tendsto_exp_atTop
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

Proof steps:
state_before: α : Type u_1
x y z : ℝ
l : Filter α
⊢ Tendsto rexp atTop atTop
state_after: α : Type u_1
x y z : ℝ
l : Filter α
A : Tendsto (fun x => x + 1) atTop atTop
⊢ Tendsto rexp atTop atTop
tactic: have A : Tendsto (fun x : ℝ => x + 1) atTop atTop :=
    tendsto_atTop_add_const_right atTop 1 tendsto_id
state_before: α : Type u_1
x y z : ℝ
l : Filter α
A : Tendsto (fun x => x + 1) atTop atTop
⊢ Tendsto rexp atTop atTop
state_after: α : Type u_1
x y z : ℝ
l : Filter α
A : Tendsto (fun x => x + 1) atTop atTop
B : ∀ᶠ (x : ℝ) in atTop, x + 1 ≤ rexp x
⊢ Tendsto rexp atTop atTop
tactic: have B : ∀ᶠ x in atTop, x + 1 ≤ exp x := eventually_atTop.2 ⟨0, fun x _ => add_one_le_exp x⟩
state_before: α : Type u_1
x y z : ℝ
l : Filter α
A : Tendsto (fun x => x + 1) atTop atTop
B : ∀ᶠ (x : ℝ) in atTop, x + 1 ≤ rexp x
⊢ Tendsto rexp atTop atTop
state_after: no goals
tactic: exact tendsto_atTop_mono' atTop B A
Theorem: hasFDerivAt_apply
File: Mathlib/Analysis/Calculus/FDeriv/Prod.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_6
inst✝² : Fintype ι
F' : ι → Type u_7
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
φ' : (i : ι) → E →L[𝕜] F' i
Φ : E → (i : ι) → F' i
Φ' : E →L[𝕜] (i : ι) → F' i
i : ι
f : (i : ι) → F' i
⊢ HasFDerivAt (fun f => f i) (proj i) f
state_after: case hf
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_6
inst✝² : Fintype ι
F' : ι → Type u_7
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
φ' : (i : ι) → E →L[𝕜] F' i
Φ : E → (i : ι) → F' i
Φ' : E →L[𝕜] (i : ι) → F' i
i : ι
f : (i : ι) → F' i
⊢ HasStrictFDerivAt (fun f => f i) (proj i) f
tactic: apply HasStrictFDerivAt.hasFDerivAt
state_before: case hf
𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type u_5
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_6
inst✝² : Fintype ι
F' : ι → Type u_7
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
φ' : (i : ι) → E →L[𝕜] F' i
Φ : E → (i : ι) → F' i
Φ' : E →L[𝕜] (i : ι) → F' i
i : ι
f : (i : ι) → F' i
⊢ HasStrictFDerivAt (fun f => f i) (proj i) f
state_after: no goals
tactic: apply hasStrictFDerivAt_apply
Theorem: Ordinal.nfp_mul_one
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: a : Ordinal.{u_1}
ha : 0 < a
⊢ nfp (fun x => a * x) 1 = a ^ ω
state_after: a : Ordinal.{u_1}
ha : 0 < a
⊢ (fun a_1 => sup fun n => (fun x => a * x)^[n] a_1) 1 = sup fun n => a ^ ↑n

a : Ordinal.{u_1}
ha : 0 < a
⊢ 0 < a
tactic: rw [← sup_iterate_eq_nfp, ← sup_opow_nat]
Theorem: intervalIntegral.integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_right
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : CompleteSpace E
f : ℝ → E
c ca cb : E
l l' la la' lb lb' : Filter ℝ
lt : Filter ι
a b z : ℝ
u v ua ub va vb : ι → ℝ
inst✝¹ : FTCFilter a la la'
inst✝ : FTCFilter b lb lb'
hab : IntervalIntegrable f volume a b
hmeas : StronglyMeasurableAtFilter f lb' volume
hf : Tendsto f (lb' ⊓ ae volume) (𝓝 c)
hu : Tendsto u lt lb
hv : Tendsto v lt lb
⊢ (fun t => ((∫ (x : ℝ) in a..v t, f x) - ∫ (x : ℝ) in a..u t, f x) - (v t - u t) • c) =o[lt] (v - u)
state_after: no goals
tactic: simpa only [integral_const, smul_eq_mul, mul_one] using
    measure_integral_sub_integral_sub_linear_isLittleO_of_tendsto_ae_right hab hmeas hf hu hv
Theorem: Mathlib.Tactic.Abel.term_add_const
File: Mathlib/Tactic/Abel.lean

Proof steps:
state_before: α : Type u_1
inst✝ : AddCommMonoid α
n : ℕ
x a k a' : α
h : a + k = a'
⊢ term n x a + k = term n x a'
state_after: no goals
tactic: simp [h.symm, term, add_assoc]
Theorem: Polynomial.Monic.natDegree_eq_zero_iff_eq_one
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
⊢ p.natDegree = 0 ↔ p = 1
state_after: case mp
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
h : p.natDegree = 0
⊢ p = 1

case mpr
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
h : p = 1
⊢ p.natDegree = 0
tactic: constructor <;> intro h
state_before: case mp
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
h : p.natDegree = 0
⊢ p = 1

case mpr
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
h : p = 1
⊢ p.natDegree = 0
state_after: case mpr
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
h : p = 1
⊢ p.natDegree = 0

case mp
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
h : p.natDegree = 0
⊢ p = 1
tactic: swap
state_before: case mp
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
h : p.natDegree = 0
⊢ p = 1
state_after: case mp
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
h : p.natDegree = 0
this : p = C (p.coeff 0)
⊢ p = 1
tactic: have : p = C (p.coeff 0) := by
    rw [← Polynomial.degree_le_zero_iff]
    rwa [Polynomial.natDegree_eq_zero_iff_degree_le_zero] at h
state_before: case mp
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
h : p.natDegree = 0
this : p = C (p.coeff 0)
⊢ p = 1
state_after: case mp
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
h : p.natDegree = 0
this : p = C (p.coeff 0)
⊢ C (p.coeff 0) = 1
tactic: rw [this]
state_before: case mp
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
h : p.natDegree = 0
this : p = C (p.coeff 0)
⊢ C (p.coeff 0) = 1
state_after: no goals
tactic: rw [← h, ← Polynomial.leadingCoeff, Monic.def.1 hp, C_1]
Theorem: AnalyticWithinAt.prod
File: Mathlib/Analysis/Analytic/Within.lean

Proof steps:
state_before: α : Type u_1
𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
F : Type u_4
G : Type u_5
H : Type u_6
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
e : E
f : E → F
g : E → G
s : Set E
hf : AnalyticWithinAt 𝕜 f s e
hg : AnalyticWithinAt 𝕜 g s e
⊢ AnalyticWithinAt 𝕜 (fun x => (f x, g x)) s e
state_after: case intro
α : Type u_1
𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
F : Type u_4
G : Type u_5
H : Type u_6
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
e : E
f : E → F
g : E → G
s : Set E
hg : AnalyticWithinAt 𝕜 g s e
w✝ : FormalMultilinearSeries 𝕜 E F
hf : HasFPowerSeriesWithinAt f w✝ s e
⊢ AnalyticWithinAt 𝕜 (fun x => (f x, g x)) s e
tactic: rcases hf with ⟨_, hf⟩
state_before: case intro
α : Type u_1
𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
F : Type u_4
G : Type u_5
H : Type u_6
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
e : E
f : E → F
g : E → G
s : Set E
hg : AnalyticWithinAt 𝕜 g s e
w✝ : FormalMultilinearSeries 𝕜 E F
hf : HasFPowerSeriesWithinAt f w✝ s e
⊢ AnalyticWithinAt 𝕜 (fun x => (f x, g x)) s e
state_after: case intro.intro
α : Type u_1
𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
F : Type u_4
G : Type u_5
H : Type u_6
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
e : E
f : E → F
g : E → G
s : Set E
w✝¹ : FormalMultilinearSeries 𝕜 E F
hf : HasFPowerSeriesWithinAt f w✝¹ s e
w✝ : FormalMultilinearSeries 𝕜 E G
hg : HasFPowerSeriesWithinAt g w✝ s e
⊢ AnalyticWithinAt 𝕜 (fun x => (f x, g x)) s e
tactic: rcases hg with ⟨_, hg⟩
state_before: case intro.intro
α : Type u_1
𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
F : Type u_4
G : Type u_5
H : Type u_6
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
e : E
f : E → F
g : E → G
s : Set E
w✝¹ : FormalMultilinearSeries 𝕜 E F
hf : HasFPowerSeriesWithinAt f w✝¹ s e
w✝ : FormalMultilinearSeries 𝕜 E G
hg : HasFPowerSeriesWithinAt g w✝ s e
⊢ AnalyticWithinAt 𝕜 (fun x => (f x, g x)) s e
state_after: no goals
tactic: exact ⟨_, hf.prod hg⟩
Theorem: WeierstrassCurve.Ψ_one
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹ : CommRing R
inst✝ : CommRing S
W : WeierstrassCurve R
⊢ W.Ψ 1 = 1
state_after: no goals
tactic: erw [Ψ_ofNat, preΨ'_one, C_1, mul_one]
Theorem: Subsemigroup.bot_prod_bot
File: Mathlib/Algebra/Group/Subsemigroup/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
σ : Type u_4
inst✝² : Mul M
inst✝¹ : Mul N
inst✝ : Mul P
S : Subsemigroup M
⊢ ↑(⊥.prod ⊥) = ↑⊥
state_after: no goals
tactic: simp [coe_prod, Prod.one_eq_mk]