ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: eq_of_derivWithin_eq
File: Mathlib/Analysis/Calculus/MeanValue.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
f' g : ℝ → E
fdiff : DifferentiableOn ℝ f (Icc a b)
gdiff : DifferentiableOn ℝ g (Icc a b)
hderiv : EqOn (derivWithin f (Icc a b)) (derivWithin g (Icc a b)) (Ico a b)
hi : f a = g a
⊢ ∀ y ∈ Icc a b, f y = g y
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
f' g : ℝ → E
fdiff : DifferentiableOn ℝ f (Icc a b)
gdiff : DifferentiableOn ℝ g (Icc a b)
hderiv : EqOn (derivWithin f (Icc a b)) (derivWithin g (Icc a b)) (Ico a b)
hi : f a = g a
A : ∀ y ∈ Ico a b, HasDerivWithinAt f (derivWithin f (Icc a b) y) (Ici y) y
⊢ ∀ y ∈ Icc a b, f y = g y
tactic: have A : ∀ y ∈ Ico a b, HasDerivWithinAt f (derivWithin f (Icc a b) y) (Ici y) y := fun y hy =>
    (fdiff y (mem_Icc_of_Ico hy)).hasDerivWithinAt.mono_of_mem (Icc_mem_nhdsWithin_Ici hy)
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
f' g : ℝ → E
fdiff : DifferentiableOn ℝ f (Icc a b)
gdiff : DifferentiableOn ℝ g (Icc a b)
hderiv : EqOn (derivWithin f (Icc a b)) (derivWithin g (Icc a b)) (Ico a b)
hi : f a = g a
A : ∀ y ∈ Ico a b, HasDerivWithinAt f (derivWithin f (Icc a b) y) (Ici y) y
⊢ ∀ y ∈ Icc a b, f y = g y
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
f' g : ℝ → E
fdiff : DifferentiableOn ℝ f (Icc a b)
gdiff : DifferentiableOn ℝ g (Icc a b)
hderiv : EqOn (derivWithin f (Icc a b)) (derivWithin g (Icc a b)) (Ico a b)
hi : f a = g a
A : ∀ y ∈ Ico a b, HasDerivWithinAt f (derivWithin f (Icc a b) y) (Ici y) y
B : ∀ y ∈ Ico a b, HasDerivWithinAt g (derivWithin g (Icc a b) y) (Ici y) y
⊢ ∀ y ∈ Icc a b, f y = g y
tactic: have B : ∀ y ∈ Ico a b, HasDerivWithinAt g (derivWithin g (Icc a b) y) (Ici y) y := fun y hy =>
    (gdiff y (mem_Icc_of_Ico hy)).hasDerivWithinAt.mono_of_mem (Icc_mem_nhdsWithin_Ici hy)
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → E
a b : ℝ
f' g : ℝ → E
fdiff : DifferentiableOn ℝ f (Icc a b)
gdiff : DifferentiableOn ℝ g (Icc a b)
hderiv : EqOn (derivWithin f (Icc a b)) (derivWithin g (Icc a b)) (Ico a b)
hi : f a = g a
A : ∀ y ∈ Ico a b, HasDerivWithinAt f (derivWithin f (Icc a b) y) (Ici y) y
B : ∀ y ∈ Ico a b, HasDerivWithinAt g (derivWithin g (Icc a b) y) (Ici y) y
⊢ ∀ y ∈ Icc a b, f y = g y
state_after: no goals
tactic: exact
    eq_of_has_deriv_right_eq A (fun y hy => (hderiv hy).symm ▸ B y hy) fdiff.continuousOn
      gdiff.continuousOn hi
Theorem: Mathlib.Vector.get_tail
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
x : Vector α n
i : Fin (n - 1)
⊢ ↑i + 1 < n
state_after: no goals
tactic: omega
state_before: n : ℕ
α : Type u_1
x : Vector α n
i : Fin (n - 1)
⊢ x.tail.get i = x.get ⟨↑i + 1, ⋯⟩
state_after: case mk
n : ℕ
α : Type u_1
x : Vector α n
i : ℕ
ih : i < n - 1
⊢ x.tail.get ⟨i, ih⟩ = x.get ⟨↑⟨i, ih⟩ + 1, ⋯⟩
tactic: cases' i with i ih
state_before: case mk
n : ℕ
α : Type u_1
x : Vector α n
i : ℕ
ih : i < n - 1
⊢ x.tail.get ⟨i, ih⟩ = x.get ⟨↑⟨i, ih⟩ + 1, ⋯⟩
state_after: case mk
n : ℕ
α : Type u_1
x : Vector α n
i : ℕ
ih : i < n - 1
⊢ x.tail.get ⟨i, ih⟩ = x.get ⟨i + 1, ⋯⟩
tactic: dsimp
state_before: case mk
n : ℕ
α : Type u_1
x : Vector α n
i : ℕ
ih : i < n - 1
⊢ x.tail.get ⟨i, ih⟩ = x.get ⟨i + 1, ⋯⟩
state_after: case mk.mk.nil
n : ℕ
α : Type u_1
i : ℕ
ih : i < n - 1
h : [].length = n
⊢ (tail ⟨[], h⟩).get ⟨i, ih⟩ = get ⟨[], h⟩ ⟨i + 1, ⋯⟩
tactic: rcases x with ⟨_ | _, h⟩ <;> try rfl
state_before: case mk.mk.nil
n : ℕ
α : Type u_1
i : ℕ
ih : i < n - 1
h : [].length = n
⊢ (tail ⟨[], h⟩).get ⟨i, ih⟩ = get ⟨[], h⟩ ⟨i + 1, ⋯⟩
state_after: case mk.mk.nil
n : ℕ
α : Type u_1
i : ℕ
ih : i < n - 1
h✝ : [].length = n
h : 0 = n
⊢ (tail ⟨[], h✝⟩).get ⟨i, ih⟩ = get ⟨[], h✝⟩ ⟨i + 1, ⋯⟩
tactic: rw [List.length] at h
state_before: case mk.mk.nil
n : ℕ
α : Type u_1
i : ℕ
ih : i < n - 1
h✝ : [].length = n
h : 0 = n
⊢ (tail ⟨[], h✝⟩).get ⟨i, ih⟩ = get ⟨[], h✝⟩ ⟨i + 1, ⋯⟩
state_after: case mk.mk.nil
n : ℕ
α : Type u_1
i : ℕ
ih✝ : i < n - 1
ih : i < 0 - 1
h✝ : [].length = n
h : 0 = n
⊢ (tail ⟨[], h✝⟩).get ⟨i, ih✝⟩ = get ⟨[], h✝⟩ ⟨i + 1, ⋯⟩
tactic: rw [← h] at ih
state_before: case mk.mk.nil
n : ℕ
α : Type u_1
i : ℕ
ih✝ : i < n - 1
ih : i < 0 - 1
h✝ : [].length = n
h : 0 = n
⊢ (tail ⟨[], h✝⟩).get ⟨i, ih✝⟩ = get ⟨[], h✝⟩ ⟨i + 1, ⋯⟩
state_after: no goals
tactic: contradiction
Theorem: FractionalIdeal.spanSingleton_div_self
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Field K
R₁ : Type u_4
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
x : K
hx : x ≠ 0
⊢ spanSingleton R₁⁰ x / spanSingleton R₁⁰ x = 1
state_after: no goals
tactic: rw [spanSingleton_div_spanSingleton, div_self hx, spanSingleton_one]
Theorem: AddSubmonoid.closure_induction_right
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

Proof steps:
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : Monoid M
a : M
s : Set M
p : (m : M) → m ∈ closure s → Prop
one : p 1 ⋯
mul_right : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ s), p x hx → p (x * y) ⋯
x : M
h : x ∈ closure s
m : Mᵐᵒᵖ
hm : m ∈ closure (MulOpposite.unop ⁻¹' s)
⊢ MulOpposite.unop m ∈ closure s
state_after: no goals
tactic: rwa [← op_closure] at hm
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝ : Monoid M
a : M
s : Set M
p : (m : M) → m ∈ closure s → Prop
one : p 1 ⋯
mul_right : ∀ (x : M) (hx : x ∈ closure s) (y : M) (hy : y ∈ s), p x hx → p (x * y) ⋯
x : M
h : x ∈ closure s
⊢ { unop' := x } ∈ closure (MulOpposite.unop ⁻¹' s)
state_after: no goals
tactic: rwa [← op_closure]
Theorem: List.chain'_isInfix
File: Mathlib/Data/List/Chain.lean

Proof steps:
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b✝ a b : α
l : List α
⊢ [] ++ [a, b] ++ l = a :: b :: l
state_after: no goals
tactic: simp
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a✝ b✝ a b : α
l : List α
x y : α
h : [x, y] <:+: b :: l
⊢ [a] ++ b :: l ++ [] = a :: b :: l
state_after: no goals
tactic: simp
Theorem: Associates.le_of_mul_le_mul_left
File: Mathlib/Algebra/Associated/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝ : CancelCommMonoidWithZero α
a b c : Associates α
ha : a ≠ 0
d : Associates α
hd : a * c = a * b * d
⊢ a * c = a * (b * d)
state_after: no goals
tactic: rwa [← mul_assoc]
Theorem: MeasureTheory.IsFundamentalDomain.covolume_eq_volume
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁶ : Group G
inst✝⁵ : MulAction G α
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace α
ν : Measure α
inst✝² : Countable G
inst✝¹ : MeasurableSMul G α
inst✝ : SMulInvariantMeasure G α ν
s : Set α
fund_dom_s : IsFundamentalDomain G s ν
⊢ covolume G α ν = ν s
state_after: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁶ : Group G
inst✝⁵ : MulAction G α
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace α
ν : Measure α
inst✝² : Countable G
inst✝¹ : MeasurableSMul G α
inst✝ : SMulInvariantMeasure G α ν
s : Set α
fund_dom_s : IsFundamentalDomain G s ν
⊢ (if funDom : HasFundamentalDomain G α ν then ν ⋯.choose else 0) = ν s
tactic: dsimp [covolume]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁶ : Group G
inst✝⁵ : MulAction G α
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace α
ν : Measure α
inst✝² : Countable G
inst✝¹ : MeasurableSMul G α
inst✝ : SMulInvariantMeasure G α ν
s : Set α
fund_dom_s : IsFundamentalDomain G s ν
⊢ (if funDom : HasFundamentalDomain G α ν then ν ⋯.choose else 0) = ν s
state_after: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁶ : Group G
inst✝⁵ : MulAction G α
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace α
ν : Measure α
inst✝² : Countable G
inst✝¹ : MeasurableSMul G α
inst✝ : SMulInvariantMeasure G α ν
s : Set α
fund_dom_s : IsFundamentalDomain G s ν
⊢ ν ⋯.choose = ν s
tactic: simp only [(fund_dom_s.hasFundamentalDomain ν), ↓reduceDIte]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁶ : Group G
inst✝⁵ : MulAction G α
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace α
ν : Measure α
inst✝² : Countable G
inst✝¹ : MeasurableSMul G α
inst✝ : SMulInvariantMeasure G α ν
s : Set α
fund_dom_s : IsFundamentalDomain G s ν
⊢ ν ⋯.choose = ν s
state_after: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁶ : Group G
inst✝⁵ : MulAction G α
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace α
ν : Measure α
inst✝² : Countable G
inst✝¹ : MeasurableSMul G α
inst✝ : SMulInvariantMeasure G α ν
s : Set α
fund_dom_s : IsFundamentalDomain G s ν
⊢ IsFundamentalDomain G ⋯.choose ν
tactic: rw [fund_dom_s.measure_eq]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝⁶ : Group G
inst✝⁵ : MulAction G α
inst✝⁴ : MeasurableSpace G
inst✝³ : MeasurableSpace α
ν : Measure α
inst✝² : Countable G
inst✝¹ : MeasurableSMul G α
inst✝ : SMulInvariantMeasure G α ν
s : Set α
fund_dom_s : IsFundamentalDomain G s ν
⊢ IsFundamentalDomain G ⋯.choose ν
state_after: no goals
tactic: exact (fund_dom_s.hasFundamentalDomain ν).ExistsIsFundamentalDomain.choose_spec
Theorem: contMDiffOn_iff_contDiffOn
File: Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝³² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³¹ : NormedAddCommGroup E
inst✝³⁰ : NormedSpace 𝕜 E
H : Type u_3
inst✝²⁹ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝²⁸ : TopologicalSpace M
inst✝²⁷ : ChartedSpace H M
inst✝²⁶ : SmoothManifoldWithCorners I M
E' : Type u_5
inst✝²⁵ : NormedAddCommGroup E'
inst✝²⁴ : NormedSpace 𝕜 E'
H' : Type u_6
inst✝²³ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
M' : Type u_7
inst✝²² : TopologicalSpace M'
inst✝²¹ : ChartedSpace H' M'
inst✝²⁰ : SmoothManifoldWithCorners I' M'
F : Type u_8
inst✝¹⁹ : NormedAddCommGroup F
inst✝¹⁸ : NormedSpace 𝕜 F
G : Type u_9
inst✝¹⁷ : TopologicalSpace G
J : ModelWithCorners 𝕜 F G
N : Type u_10
inst✝¹⁶ : TopologicalSpace N
inst✝¹⁵ : ChartedSpace G N
inst✝¹⁴ : SmoothManifoldWithCorners J N
F' : Type u_11
inst✝¹³ : NormedAddCommGroup F'
inst✝¹² : NormedSpace 𝕜 F'
G' : Type u_12
inst✝¹¹ : TopologicalSpace G'
J' : ModelWithCorners 𝕜 F' G'
N' : Type u_13
inst✝¹⁰ : TopologicalSpace N'
inst✝⁹ : ChartedSpace G' N'
inst✝⁸ : SmoothManifoldWithCorners J' N'
F₁ : Type u_14
inst✝⁷ : NormedAddCommGroup F₁
inst✝⁶ : NormedSpace 𝕜 F₁
F₂ : Type u_15
inst✝⁵ : NormedAddCommGroup F₂
inst✝⁴ : NormedSpace 𝕜 F₂
F₃ : Type u_16
inst✝³ : NormedAddCommGroup F₃
inst✝² : NormedSpace 𝕜 F₃
F₄ : Type u_17
inst✝¹ : NormedAddCommGroup F₄
inst✝ : NormedSpace 𝕜 F₄
f✝ f₁ : M → M'
s✝ t : Set M
x : M
m n : ℕ∞
f : E → E'
s : Set E
⊢ ∀ (a : E), a ∈ s → ContMDiffWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') n f s a ↔ a ∈ s → ContDiffWithinAt 𝕜 n f s a
state_after: no goals
tactic: simp [contMDiffWithinAt_iff_contDiffWithinAt]
Theorem: Complex.exp_sub_sum_range_isBigO_pow
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

Proof steps:
state_before: z y x : ℝ
n : ℕ
⊢ (fun x => cexp x - ∑ i ∈ Finset.range n, x ^ i / ↑i !) =O[𝓝 0] fun x => x ^ n
state_after: case inl
z y x : ℝ
⊢ (fun x => cexp x - ∑ i ∈ Finset.range 0, x ^ i / ↑i !) =O[𝓝 0] fun x => x ^ 0

case inr
z y x : ℝ
n : ℕ
hn : 0 < n
⊢ (fun x => cexp x - ∑ i ∈ Finset.range n, x ^ i / ↑i !) =O[𝓝 0] fun x => x ^ n
tactic: rcases (zero_le n).eq_or_lt with rfl | hn
Theorem: List.prod_cons
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
⊢ (a :: l).prod = foldl (fun x x_1 => x * x_1) (a * 1) l
state_after: no goals
tactic: simp only [List.prod, foldl_cons, one_mul, mul_one]
Theorem: MeasureTheory.FinStronglyMeasurable.neg
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
hf : FinStronglyMeasurable f μ
⊢ FinStronglyMeasurable (-f) μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
hf : FinStronglyMeasurable f μ
n : ℕ
⊢ μ (support ↑((fun n => -hf.approx n) n)) < ⊤
tactic: refine ⟨fun n => -hf.approx n, fun n => ?_, fun x => (hf.tendsto_approx x).neg⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
hf : FinStronglyMeasurable f μ
n : ℕ
⊢ μ (support ↑((fun n => -hf.approx n) n)) < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
hf : FinStronglyMeasurable f μ
n : ℕ
⊢ μ (support fun x => -↑(hf.approx n) x) < ⊤
tactic: suffices μ (Function.support fun x => -(hf.approx n) x) < ∞ by convert this
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
hf : FinStronglyMeasurable f μ
n : ℕ
⊢ μ (support fun x => -↑(hf.approx n) x) < ⊤
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
hf : FinStronglyMeasurable f μ
n : ℕ
⊢ μ (support ↑(hf.approx n)) < ⊤
tactic: rw [Function.support_neg (hf.approx n)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝³ : Countable ι
m0 : MeasurableSpace α
μ : Measure α
f g : α → β
inst✝² : TopologicalSpace β
inst✝¹ : AddGroup β
inst✝ : TopologicalAddGroup β
hf : FinStronglyMeasurable f μ
n : ℕ
⊢ μ (support ↑(hf.approx n)) < ⊤
state_after: no goals
tactic: exact hf.fin_support_approx n
Theorem: AddHom.subsemigroupMap_surjective
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
f : M →ₙ* N
M' : Subsemigroup M
⊢ Function.Surjective ⇑(f.subsemigroupMap M')
state_after: case mk.intro.intro
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
f : M →ₙ* N
M' : Subsemigroup M
x : M
hx : x ∈ ↑M'
⊢ ∃ a, (f.subsemigroupMap M') a = ⟨f x, ⋯⟩
tactic: rintro ⟨_, x, hx, rfl⟩
state_before: case mk.intro.intro
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
f : M →ₙ* N
M' : Subsemigroup M
x : M
hx : x ∈ ↑M'
⊢ ∃ a, (f.subsemigroupMap M') a = ⟨f x, ⋯⟩
state_after: no goals
tactic: exact ⟨⟨x, hx⟩, rfl⟩
Theorem: List.rotate'_rotate'
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
a : α
l : List α
m : ℕ
⊢ ((a :: l).rotate' 0).rotate' m = (a :: l).rotate' (0 + m)
state_after: no goals
tactic: simp
state_before: α : Type u
n m : ℕ
⊢ ([].rotate' n).rotate' m = [].rotate' (n + m)
state_after: no goals
tactic: simp
state_before: α : Type u
a : α
l : List α
n m : ℕ
⊢ ((a :: l).rotate' (n + 1)).rotate' m = (a :: l).rotate' (n + 1 + m)
state_after: no goals
tactic: rw [rotate'_cons_succ, rotate'_rotate' _ n, Nat.add_right_comm, ← rotate'_cons_succ,
      Nat.succ_eq_add_one]
Theorem: Nat.digits_of_two_le_of_pos
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n b : ℕ
hb : 2 ≤ b
hn : 0 < n
⊢ b.digits n = n % b :: b.digits (n / b)
state_after: no goals
tactic: rw [Nat.eq_add_of_sub_eq hb rfl, Nat.eq_add_of_sub_eq hn rfl, Nat.digits_add_two_add_one]
Theorem: has_fderiv_at_filter_real_equiv
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
f' : E →L[ℝ] F
x : E
L : Filter E
⊢ Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) L (𝓝 0) ↔
    Tendsto (fun x' => ‖x' - x‖⁻¹ • (f x' - f x - f' (x' - x))) L (𝓝 0)
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
f' : E →L[ℝ] F
x : E
L : Filter E
⊢ Tendsto (fun x' => ‖x' - x‖⁻¹ • (f x' - f x - f' (x' - x))) L (𝓝 0) ↔
    Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) L (𝓝 0)
tactic: symm
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
f' : E →L[ℝ] F
x : E
L : Filter E
⊢ Tendsto (fun x' => ‖x' - x‖⁻¹ • (f x' - f x - f' (x' - x))) L (𝓝 0) ↔
    Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) L (𝓝 0)
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
f' : E →L[ℝ] F
x : E
L : Filter E
⊢ Tendsto (fun e => ‖‖e - x‖⁻¹ • (f e - f x - f' (e - x)) - 0‖) L (𝓝 0) ↔
    Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) L (𝓝 0)
tactic: rw [tendsto_iff_norm_sub_tendsto_zero]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
f' : E →L[ℝ] F
x : E
L : Filter E
⊢ Tendsto (fun e => ‖‖e - x‖⁻¹ • (f e - f x - f' (e - x)) - 0‖) L (𝓝 0) ↔
    Tendsto (fun x' => ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖) L (𝓝 0)
state_after: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
f' : E →L[ℝ] F
x : E
L : Filter E
x' : E
⊢ ‖‖x' - x‖⁻¹ • (f x' - f x - f' (x' - x)) - 0‖ = ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖
tactic: refine tendsto_congr fun x' => ?_
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : E → F
f' : E →L[ℝ] F
x : E
L : Filter E
x' : E
⊢ ‖‖x' - x‖⁻¹ • (f x' - f x - f' (x' - x)) - 0‖ = ‖x' - x‖⁻¹ * ‖f x' - f x - f' (x' - x)‖
state_after: no goals
tactic: simp [norm_smul]
Theorem: Matrix.isUnit_nonsing_inv_det_iff
File: Mathlib/LinearAlgebra/Matrix/NonsingularInverse.lean

Proof steps:
state_before: l : Type u_1
m : Type u
n : Type u'
α : Type v
inst✝² : Fintype n
inst✝¹ : DecidableEq n
inst✝ : CommRing α
A✝ B A : Matrix n n α
⊢ IsUnit A⁻¹.det ↔ IsUnit A.det
state_after: no goals
tactic: rw [Matrix.det_nonsing_inv, isUnit_ring_inverse]
Theorem: Fin.cycleRange_zero
File: Mathlib/GroupTheory/Perm/Fin.lean

Proof steps:
state_before: n : ℕ
⊢ cycleRange 0 = 1
state_after: case H.h
n : ℕ
j : Fin n.succ
⊢ ↑((cycleRange 0) j) = ↑(1 j)
tactic: ext j
state_before: case H.h
n : ℕ
j : Fin n.succ
⊢ ↑((cycleRange 0) j) = ↑(1 j)
state_after: case H.h.refine_1
n : ℕ
j : Fin n.succ
⊢ ↑((cycleRange 0) 0) = ↑(1 0)

case H.h.refine_2
n : ℕ
j✝ : Fin n.succ
j : Fin n
⊢ ↑((cycleRange 0) j.succ) = ↑(1 j.succ)
tactic: refine Fin.cases ?_ (fun j => ?_) j
Theorem: List.range'_eq_nil
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: s n step : Nat
⊢ range' s n step = [] ↔ n = 0
state_after: no goals
tactic: rw [← length_eq_zero, length_range']
Theorem: CategoryTheory.Kleisli.Adjunction.fromKleisli_obj
File: Mathlib/CategoryTheory/Monad/Kleisli.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map (f ≫ g) =
    { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map f ≫
      { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map g
state_after: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ T.map (f ≫ T.map g ≫ T.μ.app Z) ≫ T.μ.app Z =
    { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map f ≫
      { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map g
tactic: change T.map (f ≫ T.map g ≫ T.μ.app Z) ≫ T.μ.app Z = _
state_before: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ T.map (f ≫ T.map g ≫ T.μ.app Z) ≫ T.μ.app Z =
    { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map f ≫
      { obj := fun X => T.obj X, map := fun {x Y} f => T.map f ≫ T.μ.app Y }.map g
state_after: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ T.map f ≫ T.map (T.map g) ≫ T.map (T.μ.app Z) ≫ T.μ.app Z = T.map f ≫ T.μ.app Y ≫ T.map g ≫ T.μ.app Z
tactic: simp only [Functor.map_comp, Category.assoc]
state_before: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ T.map f ≫ T.map (T.map g) ≫ T.map (T.μ.app Z) ≫ T.μ.app Z = T.map f ≫ T.μ.app Y ≫ T.map g ≫ T.μ.app Z
state_after: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ T.map f ≫ T.map (T.map g) ≫ T.μ.app (T.obj Z) ≫ T.μ.app Z =
    T.map f ≫ (T.toFunctor ⋙ T.toFunctor).map g ≫ T.μ.app (T.obj Z) ≫ T.μ.app Z
tactic: erw [← T.μ.naturality_assoc g, T.assoc]
state_before: C : Type u
inst✝ : Category.{v, u} C
T : Monad C
X Y Z : Kleisli T
f : X ⟶ Y
g : Y ⟶ Z
⊢ T.map f ≫ T.map (T.map g) ≫ T.μ.app (T.obj Z) ≫ T.μ.app Z =
    T.map f ≫ (T.toFunctor ⋙ T.toFunctor).map g ≫ T.μ.app (T.obj Z) ≫ T.μ.app Z
state_after: no goals
tactic: rfl
Theorem: Ordinal.CNF_of_le_one
File: Mathlib/SetTheory/Ordinal/CantorNormalForm.lean

Proof steps:
state_before: b o : Ordinal.{u_1}
hb : b ≤ 1
ho : o ≠ 0
⊢ CNF b o = [(0, o)]
state_after: case inl
o : Ordinal.{u_1}
ho : o ≠ 0
hb : 0 ≤ 1
⊢ CNF 0 o = [(0, o)]

case inr
o : Ordinal.{u_1}
ho : o ≠ 0
hb : 1 ≤ 1
⊢ CNF 1 o = [(0, o)]
tactic: rcases le_one_iff.1 hb with (rfl | rfl)
Theorem: imaginaryPart_I_smul
File: Mathlib/Data/Complex/Module.lean

Proof steps:
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ℑ (I • a) = ℜ a
state_after: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑(ℑ (I • a)) = ↑(ℜ a)
tactic: ext
state_before: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑(ℑ (I • a)) = ↑(ℜ a)
state_after: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ 2⁻¹ • -I • (I • a - star (I • a)) = 2⁻¹ • (a + star a)
tactic: rw [realPart_apply_coe, imaginaryPart_apply_coe, smul_comm]
state_before: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ 2⁻¹ • -I • (I • a - star (I • a)) = 2⁻¹ • (a + star a)
state_after: no goals
tactic: simp [← smul_assoc]
Theorem: tsub_le_iff_tsub_le
File: Mathlib/Algebra/Order/Sub/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : Preorder α
inst✝² : AddCommSemigroup α
inst✝¹ : Sub α
inst✝ : OrderedSub α
a b c d : α
⊢ a - b ≤ c ↔ a - c ≤ b
state_after: no goals
tactic: rw [tsub_le_iff_left, tsub_le_iff_right]