ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.SigmaFinite.withDensity_of_ne_top
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
f : α → ℝ≥0∞
hf_ne_top : ∀ᵐ (x : α) ∂μ, f x ≠ ⊤
⊢ SigmaFinite (μ.withDensity f)
state_after: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
f : α → ℝ≥0∞
hf_ne_top : ∀ᵐ (x : α) ∂μ, f x ≠ ⊤
this : f =ᶠ[ae μ] fun x => ↑(f x).toNNReal
⊢ SigmaFinite (μ.withDensity f)
tactic: have : f =ᵐ[μ] fun x ↦ (f x).toNNReal := hf_ne_top.mono fun x hx ↦ (ENNReal.coe_toNNReal hx).symm
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
f : α → ℝ≥0∞
hf_ne_top : ∀ᵐ (x : α) ∂μ, f x ≠ ⊤
this : f =ᶠ[ae μ] fun x => ↑(f x).toNNReal
⊢ SigmaFinite (μ.withDensity f)
state_after: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
f : α → ℝ≥0∞
hf_ne_top : ∀ᵐ (x : α) ∂μ, f x ≠ ⊤
this : f =ᶠ[ae μ] fun x => ↑(f x).toNNReal
⊢ SigmaFinite (μ.withDensity fun x => ↑(f x).toNNReal)
tactic: rw [withDensity_congr_ae this]
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
inst✝ : SigmaFinite μ
f : α → ℝ≥0∞
hf_ne_top : ∀ᵐ (x : α) ∂μ, f x ≠ ⊤
this : f =ᶠ[ae μ] fun x => ↑(f x).toNNReal
⊢ SigmaFinite (μ.withDensity fun x => ↑(f x).toNNReal)
state_after: no goals
tactic: infer_instance
Theorem: CategoryTheory.Limits.Types.limit_ext
File: Mathlib/CategoryTheory/Limits/Types.lean

Proof steps:
state_before: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasLimit F
x y : limit F
w : ∀ (j : J), limit.π F j x = limit.π F j y
⊢ x = y
state_after: case a
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasLimit F
x y : limit F
w : ∀ (j : J), limit.π F j x = limit.π F j y
⊢ (limitEquivSections F) x = (limitEquivSections F) y
tactic: apply (limitEquivSections F).injective
state_before: case a
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasLimit F
x y : limit F
w : ∀ (j : J), limit.π F j x = limit.π F j y
⊢ (limitEquivSections F) x = (limitEquivSections F) y
state_after: case a.a.h
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasLimit F
x y : limit F
w : ∀ (j : J), limit.π F j x = limit.π F j y
j : J
⊢ ↑((limitEquivSections F) x) j = ↑((limitEquivSections F) y) j
tactic: ext j
state_before: case a.a.h
J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasLimit F
x y : limit F
w : ∀ (j : J), limit.π F j x = limit.π F j y
j : J
⊢ ↑((limitEquivSections F) x) j = ↑((limitEquivSections F) y) j
state_after: no goals
tactic: simp [w j]
Theorem: EuclideanGeometry.two_zsmul_oangle_of_vectorSpan_eq
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ p₄ p₅ p₆ : P
h₁₂₄₅ : vectorSpan ℝ {p₁, p₂} = vectorSpan ℝ {p₄, p₅}
h₃₂₆₅ : vectorSpan ℝ {p₃, p₂} = vectorSpan ℝ {p₆, p₅}
⊢ 2 • ∡ p₁ p₂ p₃ = 2 • ∡ p₄ p₅ p₆
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ p₄ p₅ p₆ : P
h₁₂₄₅ : Submodule.span ℝ {p₁ -ᵥ p₂} = Submodule.span ℝ {p₄ -ᵥ p₅}
h₃₂₆₅ : Submodule.span ℝ {p₃ -ᵥ p₂} = Submodule.span ℝ {p₆ -ᵥ p₅}
⊢ 2 • ∡ p₁ p₂ p₃ = 2 • ∡ p₄ p₅ p₆
tactic: simp_rw [vectorSpan_pair] at h₁₂₄₅ h₃₂₆₅
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ p₄ p₅ p₆ : P
h₁₂₄₅ : Submodule.span ℝ {p₁ -ᵥ p₂} = Submodule.span ℝ {p₄ -ᵥ p₅}
h₃₂₆₅ : Submodule.span ℝ {p₃ -ᵥ p₂} = Submodule.span ℝ {p₆ -ᵥ p₅}
⊢ 2 • ∡ p₁ p₂ p₃ = 2 • ∡ p₄ p₅ p₆
state_after: no goals
tactic: exact o.two_zsmul_oangle_of_span_eq_of_span_eq h₁₂₄₅ h₃₂₆₅
Theorem: CategoryTheory.Functor.comp_obj
File: Mathlib/CategoryTheory/Functor/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
G : D ⥤ E
⊢ ∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
    { obj := fun X => G.obj (F.obj X), map := fun {X Y} f => G.map (F.map f) }.map (f ≫ g) =
      { obj := fun X => G.obj (F.obj X), map := fun {X Y} f => G.map (F.map f) }.map f ≫
        { obj := fun X => G.obj (F.obj X), map := fun {X Y} f => G.map (F.map f) }.map g
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
G : D ⥤ E
X✝ Y✝ Z✝ : C
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
⊢ { obj := fun X => G.obj (F.obj X), map := fun {X Y} f => G.map (F.map f) }.map (f✝ ≫ g✝) =
    { obj := fun X => G.obj (F.obj X), map := fun {X Y} f => G.map (F.map f) }.map f✝ ≫
      { obj := fun X => G.obj (F.obj X), map := fun {X Y} f => G.map (F.map f) }.map g✝
tactic: intros
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
G : D ⥤ E
X✝ Y✝ Z✝ : C
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
⊢ { obj := fun X => G.obj (F.obj X), map := fun {X Y} f => G.map (F.map f) }.map (f✝ ≫ g✝) =
    { obj := fun X => G.obj (F.obj X), map := fun {X Y} f => G.map (F.map f) }.map f✝ ≫
      { obj := fun X => G.obj (F.obj X), map := fun {X Y} f => G.map (F.map f) }.map g✝
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
G : D ⥤ E
X✝ Y✝ Z✝ : C
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
⊢ G.map (F.map (f✝ ≫ g✝)) = G.map (F.map f✝) ≫ G.map (F.map g✝)
tactic: dsimp
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
G : D ⥤ E
X✝ Y✝ Z✝ : C
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
⊢ G.map (F.map (f✝ ≫ g✝)) = G.map (F.map f✝) ≫ G.map (F.map g✝)
state_after: no goals
tactic: rw [F.map_comp, G.map_comp]
Theorem: Finsupp.card_pi
File: Mathlib/Data/Finset/Finsupp.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f✝ : ι →₀ α
f : ι →₀ Finset α
⊢ f.pi.card = f.prod fun i => ↑(f i).card
state_after: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f✝ : ι →₀ α
f : ι →₀ Finset α
⊢ ∏ i ∈ f.support, (f i).card = f.prod fun i => ↑(f i).card
tactic: rw [pi, card_finsupp]
state_before: ι : Type u_1
α : Type u_2
inst✝ : Zero α
s : Finset ι
f✝ : ι →₀ α
f : ι →₀ Finset α
⊢ ∏ i ∈ f.support, (f i).card = f.prod fun i => ↑(f i).card
state_after: no goals
tactic: exact Finset.prod_congr rfl fun i _ => by simp only [Pi.natCast_apply, Nat.cast_id]
Theorem: LinearMap.ker_dualMap_eq_dualAnnihilator_range
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: R : Type uR
inst✝⁴ : CommSemiring R
M₁ : Type uM₁
M₂ : Type uM₂
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
⊢ ker f.dualMap = (range f).dualAnnihilator
state_after: case h
R : Type uR
inst✝⁴ : CommSemiring R
M₁ : Type uM₁
M₂ : Type uM₂
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
x✝ : Dual R M₂
⊢ x✝ ∈ ker f.dualMap ↔ x✝ ∈ (range f).dualAnnihilator
tactic: ext
state_before: case h
R : Type uR
inst✝⁴ : CommSemiring R
M₁ : Type uM₁
M₂ : Type uM₂
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
x✝ : Dual R M₂
⊢ x✝ ∈ ker f.dualMap ↔ x✝ ∈ (range f).dualAnnihilator
state_after: case h
R : Type uR
inst✝⁴ : CommSemiring R
M₁ : Type uM₁
M₂ : Type uM₂
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
x✝ : Dual R M₂
⊢ (∀ (x : M₁), (f.dualMap x✝) x = 0 x) ↔ ∀ (i : M₁), x✝ (f i) = 0
tactic: simp_rw [mem_ker, LinearMap.ext_iff, Submodule.mem_dualAnnihilator,
    ← SetLike.mem_coe, range_coe, Set.forall_mem_range]
state_before: case h
R : Type uR
inst✝⁴ : CommSemiring R
M₁ : Type uM₁
M₂ : Type uM₂
inst✝³ : AddCommMonoid M₁
inst✝² : Module R M₁
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R M₂
f : M₁ →ₗ[R] M₂
x✝ : Dual R M₂
⊢ (∀ (x : M₁), (f.dualMap x✝) x = 0 x) ↔ ∀ (i : M₁), x✝ (f i) = 0
state_after: no goals
tactic: rfl
Theorem: Subsemiring.unop_closure
File: Mathlib/Algebra/Ring/Subsemiring/MulOpposite.lean

Proof steps:
state_before: ι : Sort u_1
R : Type u_2
inst✝ : NonAssocSemiring R
s : Set Rᵐᵒᵖ
⊢ (closure s).unop = closure (MulOpposite.op ⁻¹' s)
state_after: ι : Sort u_1
R : Type u_2
inst✝ : NonAssocSemiring R
s : Set Rᵐᵒᵖ
⊢ sInf {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} = sInf {S | MulOpposite.op ⁻¹' s ⊆ ↑S}
tactic: simp_rw [closure, unop_sInf, Set.preimage_setOf_eq, op_coe]
state_before: ι : Sort u_1
R : Type u_2
inst✝ : NonAssocSemiring R
s : Set Rᵐᵒᵖ
⊢ sInf {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} = sInf {S | MulOpposite.op ⁻¹' s ⊆ ↑S}
state_after: case e_a.h
ι : Sort u_1
R : Type u_2
inst✝ : NonAssocSemiring R
s : Set Rᵐᵒᵖ
a : Subsemiring R
⊢ a ∈ {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} ↔ a ∈ {S | MulOpposite.op ⁻¹' s ⊆ ↑S}
tactic: congr with a
state_before: case e_a.h
ι : Sort u_1
R : Type u_2
inst✝ : NonAssocSemiring R
s : Set Rᵐᵒᵖ
a : Subsemiring R
⊢ a ∈ {a | s ⊆ MulOpposite.unop ⁻¹' ↑a} ↔ a ∈ {S | MulOpposite.op ⁻¹' s ⊆ ↑S}
state_after: no goals
tactic: exact MulOpposite.op_surjective.forall
Theorem: intervalIntegrable_const_iff
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
f : ℝ → E
a b : ℝ
μ : Measure ℝ
c : E
⊢ IntervalIntegrable (fun x => c) μ a b ↔ c = 0 ∨ μ (Ι a b) < ⊤
state_after: no goals
tactic: simp only [intervalIntegrable_iff, integrableOn_const]
Theorem: Ordinal.log_opow
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: b : Ordinal.{u_1}
hb : 1 < b
x : Ordinal.{u_1}
⊢ log b (b ^ x) = x
state_after: case h.e'_2
b : Ordinal.{u_1}
hb : 1 < b
x : Ordinal.{u_1}
⊢ log b (b ^ x) = log b (b ^ x * 1 + 0)
tactic: convert log_opow_mul_add hb zero_ne_one.symm hb (opow_pos x (zero_lt_one.trans hb))
    using 1
state_before: case h.e'_2
b : Ordinal.{u_1}
hb : 1 < b
x : Ordinal.{u_1}
⊢ log b (b ^ x) = log b (b ^ x * 1 + 0)
state_after: no goals
tactic: rw [add_zero, mul_one]
Theorem: mul_right_iterate_apply_one
File: Mathlib/Algebra/GroupPower/IterateHom.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
H : Type u_4
inst✝ : Monoid G
a : G
n : ℕ
⊢ (fun x => x * a)^[n] 1 = a ^ n
state_after: no goals
tactic: simp [mul_right_iterate]
Theorem: CommSemiring.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
inst₁ inst₂ : CommSemiring R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : CommSemiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
tactic: rintro rfl
state_before: R : Type u
inst₁ : CommSemiring R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
tactic: constructor <;> rfl
Theorem: Matroid.Dep.of_restriction
File: Mathlib/Data/Matroid/Restrict.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
R I J X Y : Set α
N : Matroid α
hX : N.Dep X
hNM : N ≤r M
⊢ M.Dep X
state_after: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y R : Set α
hR : R ⊆ M.E
hX : (M ↾ R).Dep X
⊢ M.Dep X
tactic: obtain ⟨R, hR, rfl⟩ := hNM
state_before: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y R : Set α
hR : R ⊆ M.E
hX : (M ↾ R).Dep X
⊢ M.Dep X
state_after: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y R : Set α
hR : R ⊆ M.E
hX : ¬M.Indep X ∧ X ⊆ R
⊢ M.Dep X
tactic: rw [restrict_dep_iff] at hX
state_before: case intro.intro
α : Type u_1
M : Matroid α
R✝ I J X Y R : Set α
hR : R ⊆ M.E
hX : ¬M.Indep X ∧ X ⊆ R
⊢ M.Dep X
state_after: no goals
tactic: exact ⟨hX.1, hX.2.trans hR⟩
Theorem: CochainComplex.mappingConeCompTriangle_obj₂
File: Mathlib/Algebra/Homology/HomotopyCategory/Triangulated.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{?u.342, u_1} C
inst✝² : Preadditive C
inst✝¹ : HasZeroObject C
inst✝ : HasBinaryBiproducts C
X₁ X₂ X₃ : CochainComplex C ℤ
f : X₁ ⟶ X₂
g : X₂ ⟶ X₃
⊢ f ≫ g = 𝟙 X₁ ≫ f ≫ g
state_after: no goals
tactic: rw [id_comp]
state_before: C : Type u_1
inst✝³ : Category.{?u.342, u_1} C
inst✝² : Preadditive C
inst✝¹ : HasZeroObject C
inst✝ : HasBinaryBiproducts C
X₁ X₂ X₃ : CochainComplex C ℤ
f : X₁ ⟶ X₂
g : X₂ ⟶ X₃
⊢ (f ≫ g) ≫ 𝟙 X₃ = f ≫ g
state_after: no goals
tactic: rw [comp_id]
Theorem: List.mem_union_iff
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
x : α
l₁ l₂ : List α
⊢ x ∈ l₁ ∪ l₂ ↔ x ∈ l₁ ∨ x ∈ l₂
state_after: no goals
tactic: induction l₁ <;> simp [*, or_assoc]
Theorem: HomotopyCategory.quotient_inverts_homotopyEquivalences
File: Mathlib/Algebra/Homology/HomotopyCategory.lean

Proof steps:
state_before: R : Type u_1
inst✝² : Semiring R
ι : Type u_2
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
⊢ (homotopyEquivalences V c).IsInvertedBy (quotient V c)
state_after: case intro
R : Type u_1
inst✝² : Semiring R
ι : Type u_2
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
K L : HomologicalComplex V c
e : HomotopyEquiv K L
⊢ IsIso ((quotient V c).map e.hom)
tactic: rintro K L _ ⟨e, rfl⟩
state_before: case intro
R : Type u_1
inst✝² : Semiring R
ι : Type u_2
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
K L : HomologicalComplex V c
e : HomotopyEquiv K L
⊢ IsIso ((quotient V c).map e.hom)
state_after: case intro
R : Type u_1
inst✝² : Semiring R
ι : Type u_2
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
K L : HomologicalComplex V c
e : HomotopyEquiv K L
⊢ IsIso (isoOfHomotopyEquiv e).hom
tactic: change IsIso (isoOfHomotopyEquiv e).hom
state_before: case intro
R : Type u_1
inst✝² : Semiring R
ι : Type u_2
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
K L : HomologicalComplex V c
e : HomotopyEquiv K L
⊢ IsIso (isoOfHomotopyEquiv e).hom
state_after: no goals
tactic: infer_instance
Theorem: Nat.Icc_insert_succ_left
File: Mathlib/Order/Interval/Finset/Nat.lean

Proof steps:
state_before: a b c : ℕ
h : a ≤ b
⊢ insert a (Icc (a + 1) b) = Icc a b
state_after: case a
a b c : ℕ
h : a ≤ b
x : ℕ
⊢ x ∈ insert a (Icc (a + 1) b) ↔ x ∈ Icc a b
tactic: ext x
state_before: case a
a b c : ℕ
h : a ≤ b
x : ℕ
⊢ x ∈ insert a (Icc (a + 1) b) ↔ x ∈ Icc a b
state_after: case a
a b c : ℕ
h : a ≤ b
x : ℕ
⊢ x = a ∨ a + 1 ≤ x ∧ x ≤ b ↔ a ≤ x ∧ x ≤ b
tactic: simp only [mem_insert, mem_Icc]
state_before: case a
a b c : ℕ
h : a ≤ b
x : ℕ
⊢ x = a ∨ a + 1 ≤ x ∧ x ≤ b ↔ a ≤ x ∧ x ≤ b
state_after: no goals
tactic: omega
Theorem: PiNat.mem_cylinder_iff_eq
File: Mathlib/Topology/MetricSpace/PiNat.lean

Proof steps:
state_before: E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
⊢ y ∈ cylinder x n ↔ cylinder y n = cylinder x n
state_after: case mp
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
⊢ y ∈ cylinder x n → cylinder y n = cylinder x n

case mpr
E : ℕ → Type u_1
x y : (n : ℕ) → E n
n : ℕ
⊢ cylinder y n = cylinder x n → y ∈ cylinder x n
tactic: constructor
Theorem: AlgebraicGeometry.Scheme.ofRestrict_appIso
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
U✝ : TopCat
X : Scheme
f : U✝ ⟶ TopCat.of ↑↑X.toPresheafedSpace
h : OpenEmbedding ⇑f
U : (X.restrict h).Opens
⊢ Hom.appIso (X.ofRestrict h) U = Iso.refl Γ(X, X.ofRestrict h ''ᵁ U)
state_after: case w
C : Type u
inst✝ : Category.{v, u} C
U✝ : TopCat
X : Scheme
f : U✝ ⟶ TopCat.of ↑↑X.toPresheafedSpace
h : OpenEmbedding ⇑f
U : (X.restrict h).Opens
⊢ (Hom.appIso (X.ofRestrict h) U).hom = (Iso.refl Γ(X, X.ofRestrict h ''ᵁ U)).hom
tactic: ext1
state_before: case w
C : Type u
inst✝ : Category.{v, u} C
U✝ : TopCat
X : Scheme
f : U✝ ⟶ TopCat.of ↑↑X.toPresheafedSpace
h : OpenEmbedding ⇑f
U : (X.restrict h).Opens
⊢ (Hom.appIso (X.ofRestrict h) U).hom = (Iso.refl Γ(X, X.ofRestrict h ''ᵁ U)).hom
state_after: no goals
tactic: simp only [restrict_presheaf_obj, Hom.appIso_hom', ofRestrict_appLE, homOfLE_refl, op_id,
    CategoryTheory.Functor.map_id, Iso.refl_hom]
Theorem: Submonoid.LocalizationMap.eq_iff_exists
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x y : M
x✝ : ∃ c, ↑c * x = ↑c * y
c : ↥S
h : ↑c * x = ↑c * y
⊢ f.toMap x = f.toMap y
state_after: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x y : M
x✝ : ∃ c, ↑c * x = ↑c * y
c : ↥S
h : f.toMap (↑c * x) = f.toMap (↑c * y)
⊢ f.toMap x = f.toMap y
tactic: replace h := congr_arg f.toMap h
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x y : M
x✝ : ∃ c, ↑c * x = ↑c * y
c : ↥S
h : f.toMap (↑c * x) = f.toMap (↑c * y)
⊢ f.toMap x = f.toMap y
state_after: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x y : M
x✝ : ∃ c, ↑c * x = ↑c * y
c : ↥S
h : f.toMap ↑c * f.toMap x = f.toMap ↑c * f.toMap y
⊢ f.toMap x = f.toMap y
tactic: rw [map_mul, map_mul] at h
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
x y : M
x✝ : ∃ c, ↑c * x = ↑c * y
c : ↥S
h : f.toMap ↑c * f.toMap x = f.toMap ↑c * f.toMap y
⊢ f.toMap x = f.toMap y
state_after: no goals
tactic: exact (f.map_units c).mul_right_inj.mp h
Theorem: Trivialization.map_proj_nhds
File: Mathlib/Topology/FiberBundle/Trivialization.lean

Proof steps:
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x : Z
ex : x ∈ e.source
⊢ map proj (𝓝 x) = 𝓝 (proj x)
state_after: no goals
tactic: rw [← e.coe_fst ex, ← map_congr (e.coe_fst_eventuallyEq_proj ex), ← map_map, ← e.coe_coe,
    e.map_nhds_eq ex, map_fst_nhds]
Theorem: Multiset.count_erase_self
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s : Multiset α
l : List α
⊢ count a (erase ⟦l⟧ a) = count a ⟦l⟧ - 1
state_after: no goals
tactic: convert List.count_erase_self a l <;> rw [← coe_count] <;> simp
Theorem: Associates.eq_of_prod_eq_prod
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a b : FactorSet α
h : a.prod = b.prod
⊢ a = b
state_after: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a b : FactorSet α
h : a.prod = b.prod
this : a.prod.factors = b.prod.factors
⊢ a = b
tactic: have : a.prod.factors = b.prod.factors := by rw [h]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : UniqueFactorizationMonoid α
inst✝ : Nontrivial α
a b : FactorSet α
h : a.prod = b.prod
this : a.prod.factors = b.prod.factors
⊢ a = b
state_after: no goals
tactic: rwa [prod_factors, prod_factors] at this
Theorem: eqOn_closure₂'
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space Z
s : Set X
t : Set Y
f g : X → Y → Z
h : ∀ x ∈ s, ∀ y ∈ t, f x y = g x y
hf₁ : ∀ (x : X), Continuous (f x)
hf₂ : ∀ (y : Y), Continuous fun x => f x y
hg₁ : ∀ (x : X), Continuous (g x)
hg₂ : ∀ (y : Y), Continuous fun x => g x y
this : closure s ⊆ ⋂ y ∈ closure t, {x | f x y = g x y}
⊢ ∀ x ∈ closure s, ∀ y ∈ closure t, f x y = g x y
state_after: no goals
tactic: simpa only [subset_def, mem_iInter]
Theorem: MeasureTheory.VectorMeasure.trim_eq_self
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
L : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
n : MeasurableSpace α
v : VectorMeasure α M
⊢ v.trim ⋯ = v
state_after: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
L : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
n : MeasurableSpace α
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ ↑(v.trim ⋯) i = ↑v i
tactic: ext i hi
state_before: case h
α : Type u_1
β : Type u_2
m : MeasurableSpace α
L : Type u_3
M : Type u_4
N : Type u_5
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
n : MeasurableSpace α
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
⊢ ↑(v.trim ⋯) i = ↑v i
state_after: no goals
tactic: exact if_pos hi
Theorem: CategoryTheory.leftUnitor_inv_braiding
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X : C
⊢ (λ_ X).inv ≫ (β_ (𝟙_ C) X).hom = (ρ_ X).inv
state_after: no goals
tactic: simp
Theorem: AddSubgroup.toAddSubmonoid_injective
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

Proof steps:
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
p q : Subgroup G
h : p.toSubmonoid = q.toSubmonoid
⊢ p = q
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
p q : Subgroup G
h : p.toSubmonoid = q.toSubmonoid
this : ↑p.toSubmonoid = ↑q.toSubmonoid
⊢ p = q
tactic: have := SetLike.ext'_iff.1 h
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
p q : Subgroup G
h : p.toSubmonoid = q.toSubmonoid
this : ↑p.toSubmonoid = ↑q.toSubmonoid
⊢ p = q
state_after: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
p q : Subgroup G
h : p.toSubmonoid = q.toSubmonoid
this : ↑p = ↑q
⊢ p = q
tactic: rw [coe_toSubmonoid, coe_toSubmonoid] at this
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝³ : Group G
inst✝² : Group G'
inst✝¹ : Group G''
A : Type u_4
inst✝ : AddGroup A
p q : Subgroup G
h : p.toSubmonoid = q.toSubmonoid
this : ↑p = ↑q
⊢ p = q
state_after: no goals
tactic: exact SetLike.ext'_iff.2 this
Theorem: dvd_pow
File: Mathlib/Algebra/Divisibility/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
a b c : α
m n✝ : ℕ
hab : a ∣ b
n : ℕ
x✝ : n + 1 ≠ 0
⊢ a ∣ b ^ (n + 1)
state_after: α : Type u_1
inst✝ : Monoid α
a b c : α
m n✝ : ℕ
hab : a ∣ b
n : ℕ
x✝ : n + 1 ≠ 0
⊢ a ∣ b * b ^ n
tactic: rw [pow_succ']
state_before: α : Type u_1
inst✝ : Monoid α
a b c : α
m n✝ : ℕ
hab : a ∣ b
n : ℕ
x✝ : n + 1 ≠ 0
⊢ a ∣ b * b ^ n
state_after: no goals
tactic: exact hab.mul_right _