ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: HurwitzZeta.completedCosZeta_eq
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : UnitAddCircle
s : ℂ
⊢ completedCosZeta a s = completedCosZeta₀ a s - 1 / s - (if a = 0 then 1 else 0) / (1 - s)
state_after: a : UnitAddCircle
s : ℂ
⊢ (hurwitzEvenFEPair a).symm.Λ₀ (s / 2) / 2 - (1 / (s / 2)) • (hurwitzEvenFEPair a).symm.f₀ / 2 -
      ((hurwitzEvenFEPair a).symm.ε / (↑(hurwitzEvenFEPair a).symm.k - s / 2)) • (hurwitzEvenFEPair a).symm.g₀ / 2 =
    completedCosZeta₀ a s - 1 / s - (if a = 0 then 1 else 0) / (1 - s)
tactic: rw [completedCosZeta, WeakFEPair.Λ, sub_div, sub_div]
state_before: a : UnitAddCircle
s : ℂ
⊢ (hurwitzEvenFEPair a).symm.Λ₀ (s / 2) / 2 - (1 / (s / 2)) • (hurwitzEvenFEPair a).symm.f₀ / 2 -
      ((hurwitzEvenFEPair a).symm.ε / (↑(hurwitzEvenFEPair a).symm.k - s / 2)) • (hurwitzEvenFEPair a).symm.g₀ / 2 =
    completedCosZeta₀ a s - 1 / s - (if a = 0 then 1 else 0) / (1 - s)
state_after: case e_a
a : UnitAddCircle
s : ℂ
⊢ (hurwitzEvenFEPair a).symm.Λ₀ (s / 2) / 2 - (1 / (s / 2)) • (hurwitzEvenFEPair a).symm.f₀ / 2 =
    completedCosZeta₀ a s - 1 / s

case e_a
a : UnitAddCircle
s : ℂ
⊢ ((hurwitzEvenFEPair a).symm.ε / (↑(hurwitzEvenFEPair a).symm.k - s / 2)) • (hurwitzEvenFEPair a).symm.g₀ / 2 =
    (if a = 0 then 1 else 0) / (1 - s)
tactic: congr 1
Theorem: Batteries.RBNode.Ordered.setRed
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: α : Type u_1
cmp : α → α → Ordering
t : RBNode α
⊢ Ordered cmp t.setRed ↔ Ordered cmp t
state_after: α : Type u_1
cmp : α → α → Ordering
t : RBNode α
⊢ Ordered cmp
      (match t with
      | node c a v b => node red a v b
      | nil => nil) ↔
    Ordered cmp t
tactic: unfold setRed
state_before: α : Type u_1
cmp : α → α → Ordering
t : RBNode α
⊢ Ordered cmp
      (match t with
      | node c a v b => node red a v b
      | nil => nil) ↔
    Ordered cmp t
state_after: no goals
tactic: split <;> simp [Ordered]
Theorem: FirstOrder.Language.DirectLimit.of_f
File: Mathlib/ModelTheory/DirectLimit.lean

Proof steps:
state_before: L : Language
ι : Type v
inst✝⁴ : Preorder ι
G : ι → Type w
inst✝³ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
inst✝¹ : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝ : Nonempty ι
i j : ι
hij : i ≤ j
x : G i
⊢ (of L ι G f j) ((f i j hij) x) = (of L ι G f i) x
state_after: L : Language
ι : Type v
inst✝⁴ : Preorder ι
G : ι → Type w
inst✝³ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
inst✝¹ : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝ : Nonempty ι
i j : ι
hij : i ≤ j
x : G i
⊢ Structure.Sigma.mk f j ((f i j hij) x) ≈ Structure.Sigma.mk f i x
tactic: rw [of_apply, of_apply, Quotient.eq]
state_before: L : Language
ι : Type v
inst✝⁴ : Preorder ι
G : ι → Type w
inst✝³ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
inst✝¹ : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝ : Nonempty ι
i j : ι
hij : i ≤ j
x : G i
⊢ Structure.Sigma.mk f j ((f i j hij) x) ≈ Structure.Sigma.mk f i x
state_after: L : Language
ι : Type v
inst✝⁴ : Preorder ι
G : ι → Type w
inst✝³ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
inst✝¹ : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝ : Nonempty ι
i j : ι
hij : i ≤ j
x : G i
⊢ (f i j hij) x = (f j j ⋯) ((f i j hij) x)
tactic: refine Setoid.symm ⟨j, hij, refl j, ?_⟩
state_before: L : Language
ι : Type v
inst✝⁴ : Preorder ι
G : ι → Type w
inst✝³ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝² : IsDirected ι fun x x_1 => x ≤ x_1
inst✝¹ : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝ : Nonempty ι
i j : ι
hij : i ≤ j
x : G i
⊢ (f i j hij) x = (f j j ⋯) ((f i j hij) x)
state_after: no goals
tactic: simp only [DirectedSystem.map_self]
Theorem: Mathlib.Tactic.Monoidal.evalWhiskerRight_comp
File: Mathlib/Tactic/CategoryTheory/Monoidal.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : MonoidalCategory C
f f' g g' h i j : C
η : f ⟶ f'
η₁ : f ⊗ g ⟶ f' ⊗ g
η₂ : (f ⊗ g) ⊗ h ⟶ (f' ⊗ g) ⊗ h
η₃ : (f ⊗ g) ⊗ h ⟶ f' ⊗ g ⊗ h
η₄ : f ⊗ g ⊗ h ⟶ f' ⊗ g ⊗ h
pf_η₁ : η ▷ g = η₁
pf_η₂ : η₁ ▷ h = η₂
pf_η₃ : η₂ ≫ (α_ f' g h).hom = η₃
pf_η₄ : (α_ f g h).inv ≫ η₃ = η₄
⊢ η ▷ (g ⊗ h) = η₄
state_after: no goals
tactic: simp [pf_η₁, pf_η₂, pf_η₃, pf_η₄]
Theorem: CategoryTheory.Limits.biproduct.fromSubtype_π
File: Mathlib/CategoryTheory/Limits/Shapes/Biproducts.lean

Proof steps:
state_before: J : Type w
K : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
⊢ fromSubtype f p ≫ π f j = if h : p j then π (Subtype.restrict p f) ⟨j, h⟩ else 0
state_after: case w
J : Type w
K : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
⊢ ι (Subtype.restrict p f) i ≫ fromSubtype f p ≫ π f j =
    ι (Subtype.restrict p f) i ≫ if h : p j then π (Subtype.restrict p f) ⟨j, h⟩ else 0
tactic: ext i
state_before: case w
J : Type w
K : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
⊢ ι (Subtype.restrict p f) i ≫ fromSubtype f p ≫ π f j =
    ι (Subtype.restrict p f) i ≫ if h : p j then π (Subtype.restrict p f) ⟨j, h⟩ else 0
state_after: case w
J : Type w
K : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
⊢ (if h : ↑i = j then eqToHom ⋯ else 0) =
    ι (Subtype.restrict p f) i ≫ if h : p j then π (Subtype.restrict p f) ⟨j, h⟩ else 0
tactic: rw [biproduct.fromSubtype, biproduct.ι_desc_assoc, biproduct.ι_π]
state_before: case w
J : Type w
K : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
⊢ (if h : ↑i = j then eqToHom ⋯ else 0) =
    ι (Subtype.restrict p f) i ≫ if h : p j then π (Subtype.restrict p f) ⟨j, h⟩ else 0
state_after: case pos
J : Type w
K : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : p j
⊢ (if h : ↑i = j then eqToHom ⋯ else 0) =
    ι (Subtype.restrict p f) i ≫ if h : p j then π (Subtype.restrict p f) ⟨j, h⟩ else 0

case neg
J : Type w
K : Type u_1
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
f : J → C
inst✝² : HasBiproduct f
p : J → Prop
inst✝¹ : HasBiproduct (Subtype.restrict p f)
inst✝ : DecidablePred p
j : J
i : Subtype p
h : ¬p j
⊢ (if h : ↑i = j then eqToHom ⋯ else 0) =
    ι (Subtype.restrict p f) i ≫ if h : p j then π (Subtype.restrict p f) ⟨j, h⟩ else 0
tactic: by_cases h : p j
Theorem: Finset.twoPowSum_toFinset_bitIndices
File: Mathlib/Combinatorics/Colex.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Finset ℕ
n✝ n : ℕ
⊢ ∑ i ∈ n.bitIndices.toFinset, 2 ^ i = n
state_after: no goals
tactic: simp [List.sum_toFinset _ Nat.bitIndices_sorted.nodup]
Theorem: Preperfect.perfect_closure
File: Mathlib/Topology/Perfect.lean

Proof steps:
state_before: α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
⊢ Perfect (closure C)
state_after: case closed
α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
⊢ IsClosed (closure C)

case acc
α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
⊢ Preperfect (closure C)
tactic: constructor
state_before: case acc
α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
⊢ Preperfect (closure C)
state_after: case acc
α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
x : α
hx : x ∈ closure C
⊢ AccPt x (𝓟 (closure C))
tactic: intro x hx
state_before: case acc
α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
x : α
hx : x ∈ closure C
⊢ AccPt x (𝓟 (closure C))
state_after: α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
x : α
hx : x ∈ closure C
h : x ∈ C
⊢ AccPt x (𝓟 C)

α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
x : α
hx : x ∈ closure C
h : x ∉ C
⊢ AccPt x (𝓟 C)
tactic: by_cases h : x ∈ C <;> apply AccPt.mono _ (principal_mono.mpr subset_closure)
state_before: α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
x : α
hx : x ∈ closure C
h : x ∉ C
⊢ AccPt x (𝓟 C)
state_after: α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
x : α
hx : x ∈ closure C
h : x ∉ C
this : {x}ᶜ ∩ C = C
⊢ AccPt x (𝓟 C)
tactic: have : {x}ᶜ ∩ C = C := by simp [h]
state_before: α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
x : α
hx : x ∈ closure C
h : x ∉ C
this : {x}ᶜ ∩ C = C
⊢ AccPt x (𝓟 C)
state_after: α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
x : α
hx : x ∈ closure C
h : x ∉ C
this : {x}ᶜ ∩ C = C
⊢ (𝓝 x ⊓ 𝓟 C).NeBot
tactic: rw [AccPt, nhdsWithin, inf_assoc, inf_principal, this]
state_before: α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
x : α
hx : x ∈ closure C
h : x ∉ C
this : {x}ᶜ ∩ C = C
⊢ (𝓝 x ⊓ 𝓟 C).NeBot
state_after: α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
x : α
hx : x ∈ {a | ClusterPt a (𝓟 C)}
h : x ∉ C
this : {x}ᶜ ∩ C = C
⊢ (𝓝 x ⊓ 𝓟 C).NeBot
tactic: rw [closure_eq_cluster_pts] at hx
state_before: α : Type u_1
inst✝ : TopologicalSpace α
C : Set α
hC : Preperfect C
x : α
hx : x ∈ {a | ClusterPt a (𝓟 C)}
h : x ∉ C
this : {x}ᶜ ∩ C = C
⊢ (𝓝 x ⊓ 𝓟 C).NeBot
state_after: no goals
tactic: exact hx
Theorem: ConvexOn.lt_left_of_right_lt
File: Mathlib/Analysis/Convex/Function.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y z : E
hx : x ∈ s
hy : y ∈ s
hz : z ∈ openSegment 𝕜 x y
hyz : f y < f z
⊢ f z < f x
state_after: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y : E
hx : x ∈ s
hy : y ∈ s
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hyz : f y < f (a • x + b • y)
⊢ f (a • x + b • y) < f x
tactic: obtain ⟨a, b, ha, hb, hab, rfl⟩ := hz
state_before: case intro.intro.intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type u_3
α : Type u_4
β : Type u_5
ι : Type u_6
inst✝⁶ : OrderedSemiring 𝕜
inst✝⁵ : AddCommMonoid E
inst✝⁴ : AddCommMonoid F
inst✝³ : LinearOrderedCancelAddCommMonoid β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f g : E → β
hf : ConvexOn 𝕜 s f
x y : E
hx : x ∈ s
hy : y ∈ s
a b : 𝕜
ha : 0 < a
hb : 0 < b
hab : a + b = 1
hyz : f y < f (a • x + b • y)
⊢ f (a • x + b • y) < f x
state_after: no goals
tactic: exact hf.lt_left_of_right_lt' hx hy ha hb hab hyz
Theorem: Matrix.det_add_col_mul_row
File: Mathlib/LinearAlgebra/Matrix/SchurComplement.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁷ : Fintype l
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : CommRing α
ι : Type u_5
inst✝ : Unique ι
A : Matrix m m α
hA : IsUnit A.det
u v : m → α
⊢ (A + col ι u * row ι v).det = A.det * (1 + row ι v * A⁻¹ * col ι u).det
state_after: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁷ : Fintype l
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : CommRing α
ι : Type u_5
inst✝ : Unique ι
A : Matrix m m α
hA : IsUnit A.det
u v : m → α
⊢ (A * 1 + col ι u * row ι v).det = A.det * (1 + row ι v * A⁻¹ * col ι u).det
tactic: nth_rewrite 1 [← Matrix.mul_one A]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁷ : Fintype l
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : DecidableEq l
inst✝³ : DecidableEq m
inst✝² : DecidableEq n
inst✝¹ : CommRing α
ι : Type u_5
inst✝ : Unique ι
A : Matrix m m α
hA : IsUnit A.det
u v : m → α
⊢ (A * 1 + col ι u * row ι v).det = A.det * (1 + row ι v * A⁻¹ * col ι u).det
state_after: no goals
tactic: rwa [← Matrix.mul_nonsing_inv_cancel_left A (col ι u * row ι v),
    ← Matrix.mul_add, det_mul, ← Matrix.mul_assoc, det_one_add_mul_comm,
    ← Matrix.mul_assoc]
Theorem: Finsupp.erase_add
File: Mathlib/Data/Finsupp/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddZeroClass M
a : α
f f' : α →₀ M
⊢ erase a (f + f') = erase a f + erase a f'
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddZeroClass M
a : α
f f' : α →₀ M
s : α
⊢ (erase a (f + f')) s = (erase a f + erase a f') s
tactic: ext s
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddZeroClass M
a : α
f f' : α →₀ M
s : α
⊢ (erase a (f + f')) s = (erase a f + erase a f') s
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddZeroClass M
a : α
f f' : α →₀ M
s : α
hs : s = a
⊢ (erase a (f + f')) s = (erase a f + erase a f') s

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddZeroClass M
a : α
f f' : α →₀ M
s : α
hs : ¬s = a
⊢ (erase a (f + f')) s = (erase a f + erase a f') s
tactic: by_cases hs : s = a
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : AddZeroClass M
a : α
f f' : α →₀ M
s : α
hs : ¬s = a
⊢ (erase a (f + f')) s = (erase a f + erase a f') s
state_after: no goals
tactic: rw [add_apply, erase_ne hs, erase_ne hs, erase_ne hs, add_apply]
Theorem: AbsoluteValue.sub_le_add
File: Mathlib/Algebra/Order/AbsoluteValue.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
R : Type u_3
S : Type u_4
inst✝² : OrderedCommRing S
inst✝¹ : Ring R
abv : AbsoluteValue R S
inst✝ : NoZeroDivisors S
a b : R
⊢ abv (a - b) ≤ abv a + abv b
state_after: no goals
tactic: simpa only [← sub_eq_add_neg, AbsoluteValue.map_neg] using abv.add_le a (-b)
Theorem: Asymptotics.IsBigOWith.eventually_mul_div_cancel
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
u v : α → 𝕜
h : IsBigOWith c l u v
y : α
hy : ‖u y‖ ≤ c * ‖v y‖
hv : v y = 0
⊢ u y = 0
state_after: no goals
tactic: simpa [hv] using hy
Theorem: CategoryTheory.pullbackShiftFunctorAdd'_hom_app
File: Mathlib/CategoryTheory/Shift/Pullback.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{?u.19934, u_1} C
A : Type u_2
B : Type u_3
inst✝² : AddMonoid A
inst✝¹ : AddMonoid B
φ : A →+ B
inst✝ : HasShift C B
X : PullbackShift C φ
a₁ a₂ a₃ : A
h : a₁ + a₂ = a₃
b₁ b₂ b₃ : B
h₁ : b₁ = φ a₁
h₂ : b₂ = φ a₂
h₃ : b₃ = φ a₃
⊢ b₁ + b₂ = b₃
state_after: no goals
tactic: rw [h₁, h₂, h₃, ← h, φ.map_add]
state_before: C : Type u_1
inst✝³ : Category.{u_4, u_1} C
A : Type u_2
B : Type u_3
inst✝² : AddMonoid A
inst✝¹ : AddMonoid B
φ : A →+ B
inst✝ : HasShift C B
X : PullbackShift C φ
a₁ a₂ a₃ : A
h : a₁ + a₂ = a₃
b₁ b₂ b₃ : B
h₁ : b₁ = φ a₁
h₂ : b₂ = φ a₂
h₃ : b₃ = φ a₃
⊢ (shiftFunctorAdd' (PullbackShift C φ) a₁ a₂ a₃ h).hom.app X =
    (pullbackShiftIso C φ a₃ b₃ h₃).hom.app X ≫
      (shiftFunctorAdd' C b₁ b₂ b₃ ⋯).hom.app X ≫
        (pullbackShiftIso C φ a₂ b₂ h₂).inv.app ((shiftFunctor C b₁).obj X) ≫
          (shiftFunctor (PullbackShift C φ) a₂).map ((pullbackShiftIso C φ a₁ b₁ h₁).inv.app X)
state_after: C : Type u_1
inst✝³ : Category.{u_4, u_1} C
A : Type u_2
B : Type u_3
inst✝² : AddMonoid A
inst✝¹ : AddMonoid B
φ : A →+ B
inst✝ : HasShift C B
X : PullbackShift C φ
a₁ a₂ a₃ : A
h : a₁ + a₂ = a₃
b₁ b₂ b₃ : B
h₁ : b₁ = φ a₁
h₂ : b₂ = φ a₂
h₃ : b₃ = φ a₃
⊢ 𝟙 ((shiftFunctor (PullbackShift C φ) a₁ ⋙ shiftFunctor (PullbackShift C φ) a₂).obj X) =
    𝟙 ((shiftFunctor (PullbackShift C φ) a₂).obj ((shiftFunctor (PullbackShift C φ) a₁).obj X))
tactic: rw [← cancel_epi ((shiftFunctorAdd' _ a₁ a₂ a₃ h).inv.app X), Iso.inv_hom_id_app,
    pullbackShiftFunctorAdd'_inv_app φ X a₁ a₂ a₃ h b₁ b₂ b₃ h₁ h₂ h₃, assoc, assoc, assoc,
    Iso.inv_hom_id_app_assoc, Iso.inv_hom_id_app_assoc, Iso.hom_inv_id_app_assoc,
    ← Functor.map_comp, Iso.hom_inv_id_app, Functor.map_id]
state_before: C : Type u_1
inst✝³ : Category.{u_4, u_1} C
A : Type u_2
B : Type u_3
inst✝² : AddMonoid A
inst✝¹ : AddMonoid B
φ : A →+ B
inst✝ : HasShift C B
X : PullbackShift C φ
a₁ a₂ a₃ : A
h : a₁ + a₂ = a₃
b₁ b₂ b₃ : B
h₁ : b₁ = φ a₁
h₂ : b₂ = φ a₂
h₃ : b₃ = φ a₃
⊢ 𝟙 ((shiftFunctor (PullbackShift C φ) a₁ ⋙ shiftFunctor (PullbackShift C φ) a₂).obj X) =
    𝟙 ((shiftFunctor (PullbackShift C φ) a₂).obj ((shiftFunctor (PullbackShift C φ) a₁).obj X))
state_after: no goals
tactic: rfl
Theorem: Filter.tendsto_mul_const_atTop_of_neg
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✝ : LinearOrderedField α
l : Filter β
f : β → α
r : α
hr : r < 0
⊢ Tendsto (fun x => f x * r) l atTop ↔ Tendsto f l atBot
state_after: no goals
tactic: simpa only [mul_comm] using tendsto_const_mul_atTop_of_neg hr
Theorem: IntermediateField.isPurelyInseparable_adjoin_iff_pow_mem
File: Mathlib/FieldTheory/PurelyInseparable.lean

Proof steps:
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
q : ℕ
hF : ExpChar F q
S : Set E
⊢ IsPurelyInseparable F ↥(adjoin F S) ↔ ∀ x ∈ S, ∃ n, x ^ q ^ n ∈ (algebraMap F E).range
state_after: no goals
tactic: simp_rw [← le_perfectClosure_iff, adjoin_le_iff, ← mem_perfectClosure_iff_pow_mem q,
    Set.le_iff_subset, Set.subset_def, SetLike.mem_coe]
Theorem: Irrational.sub_int
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
x y : ℝ
h : Irrational x
m : ℤ
⊢ Irrational (x - ↑m)
state_after: no goals
tactic: simpa only [Rat.cast_intCast] using h.sub_rat m
Theorem: Action.ρ_one
File: Mathlib/RepresentationTheory/Action/Basic.lean

Proof steps:
state_before: V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
A : Action V G
⊢ A.ρ 1 = 𝟙 A.V
state_after: V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
A : Action V G
⊢ 1 = 𝟙 A.V
tactic: rw [MonoidHom.map_one]
state_before: V : Type (u + 1)
inst✝ : LargeCategory V
G : MonCat
A : Action V G
⊢ 1 = 𝟙 A.V
state_after: no goals
tactic: rfl
Theorem: Ordinal.typein_lt_typein
File: Mathlib/SetTheory/Ordinal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
a b : α
x✝ : typein r a < typein r b
f : Subrel r {b | r b a} ≺i Subrel r {b_1 | r b_1 b}
⊢ r a b
state_after: α : Type u
β : Type u_1
γ : Type u_2
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
a b : α
x✝ : typein r a < typein r b
f : Subrel r {b | r b a} ≺i Subrel r {b_1 | r b_1 b}
this : ↑f.top = a
⊢ r a b
tactic: have : f.top.1 = a := by
      let f' := PrincipalSeg.ofElement r a
      let g' := f.trans (PrincipalSeg.ofElement r b)
      have : g'.top = f'.top := by rw [Subsingleton.elim f' g']
      exact this
state_before: α : Type u
β : Type u_1
γ : Type u_2
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
a b : α
x✝ : typein r a < typein r b
f : Subrel r {b | r b a} ≺i Subrel r {b_1 | r b_1 b}
this : ↑f.top = a
⊢ r a b
state_after: α : Type u
β : Type u_1
γ : Type u_2
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
a b : α
x✝ : typein r a < typein r b
f : Subrel r {b | r b a} ≺i Subrel r {b_1 | r b_1 b}
this : ↑f.top = a
⊢ r (↑f.top) b
tactic: rw [← this]
state_before: α : Type u
β : Type u_1
γ : Type u_2
r✝ : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
r : α → α → Prop
inst✝ : IsWellOrder α r
a b : α
x✝ : typein r a < typein r b
f : Subrel r {b | r b a} ≺i Subrel r {b_1 | r b_1 b}
this : ↑f.top = a
⊢ r (↑f.top) b
state_after: no goals
tactic: exact f.top.2
Theorem: RingHom.ker_eq_bot_iff_eq_zero
File: Mathlib/RingTheory/Ideal/Maps.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
F : Type u_1
inst✝² : Ring R
inst✝¹ : Semiring S
inst✝ : FunLike F R S
rc : RingHomClass F R S
f : F
⊢ ker f = ⊥ ↔ ∀ (x : R), f x = 0 → x = 0
state_after: no goals
tactic: rw [← injective_iff_map_eq_zero f, injective_iff_ker_eq_bot]
Theorem: Set.sigma_univ_range_eq
File: Mathlib/Data/Set/Sigma.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β✝² : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
β✝¹ : Type u_5
inst✝ : CompleteLattice β✝¹
β✝ : Type u_6
β : ι → Type u_7
f : (i : ι) → α i → β i
⊢ ∀ (x : (i : ι) × β i), (x ∈ univ.sigma fun i => range (f i)) ↔ x ∈ range fun x => ⟨x.fst, f x.fst x.snd⟩
state_after: no goals
tactic: simp [range]
Theorem: Metric.diam_le_of_subset_closedBall
File: Mathlib/Topology/MetricSpace/Bounded.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
s : Set α
x y z : α
r : ℝ
hr : 0 ≤ r
h : s ⊆ closedBall x r
a : α
ha : a ∈ s
b : α
hb : b ∈ s
⊢ r + r = 2 * r
state_after: no goals
tactic: simp [mul_two, mul_comm]
Theorem: Complex.coe_selfAdjointEquiv
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
z : ↥(selfAdjoint ℂ)
⊢ ↑(selfAdjointEquiv z) = ↑z
state_after: no goals
tactic: simpa [selfAdjointEquiv_symm_apply]
    using (congr_arg Subtype.val <| Complex.selfAdjointEquiv.left_inv z)