ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: StieltjesFunction.measure_singleton
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

Proof steps:
state_before: f : StieltjesFunction
a : ℝ
⊢ f.measure {a} = ofReal (↑f a - leftLim (↑f) a)
state_after: case intro.intro.intro
f : StieltjesFunction
a : ℝ
u : ℕ → ℝ
u_mono : StrictMono u
u_lt_a : ∀ (n : ℕ), u n < a
u_lim : Tendsto u atTop (𝓝 a)
⊢ f.measure {a} = ofReal (↑f a - leftLim (↑f) a)
tactic: obtain ⟨u, u_mono, u_lt_a, u_lim⟩ :
    ∃ u : ℕ → ℝ, StrictMono u ∧ (∀ n : ℕ, u n < a) ∧ Tendsto u atTop (𝓝 a) :=
    exists_seq_strictMono_tendsto a
state_before: case intro.intro.intro
f : StieltjesFunction
a : ℝ
u : ℕ → ℝ
u_mono : StrictMono u
u_lt_a : ∀ (n : ℕ), u n < a
u_lim : Tendsto u atTop (𝓝 a)
⊢ f.measure {a} = ofReal (↑f a - leftLim (↑f) a)
state_after: case intro.intro.intro
f : StieltjesFunction
a : ℝ
u : ℕ → ℝ
u_mono : StrictMono u
u_lt_a : ∀ (n : ℕ), u n < a
u_lim : Tendsto u atTop (𝓝 a)
A : {a} = ⋂ n, Ioc (u n) a
⊢ f.measure {a} = ofReal (↑f a - leftLim (↑f) a)
tactic: have A : {a} = ⋂ n, Ioc (u n) a := by
    refine Subset.antisymm (fun x hx => by simp [mem_singleton_iff.1 hx, u_lt_a]) fun x hx => ?_
    simp? at hx says simp only [mem_iInter, mem_Ioc] at hx
    have : a ≤ x := le_of_tendsto' u_lim fun n => (hx n).1.le
    simp [le_antisymm this (hx 0).2]
state_before: case intro.intro.intro
f : StieltjesFunction
a : ℝ
u : ℕ → ℝ
u_mono : StrictMono u
u_lt_a : ∀ (n : ℕ), u n < a
u_lim : Tendsto u atTop (𝓝 a)
A : {a} = ⋂ n, Ioc (u n) a
L1 : Tendsto (fun n => f.measure (Ioc (u n) a)) atTop (𝓝 (f.measure {a}))
⊢ f.measure {a} = ofReal (↑f a - leftLim (↑f) a)
state_after: case intro.intro.intro
f : StieltjesFunction
a : ℝ
u : ℕ → ℝ
u_mono : StrictMono u
u_lt_a : ∀ (n : ℕ), u n < a
u_lim : Tendsto u atTop (𝓝 a)
A : {a} = ⋂ n, Ioc (u n) a
L1 : Tendsto (fun n => f.measure (Ioc (u n) a)) atTop (𝓝 (f.measure {a}))
L2 : Tendsto (fun n => f.measure (Ioc (u n) a)) atTop (𝓝 (ofReal (↑f a - leftLim (↑f) a)))
⊢ f.measure {a} = ofReal (↑f a - leftLim (↑f) a)
tactic: have L2 :
      Tendsto (fun n => f.measure (Ioc (u n) a)) atTop (𝓝 (ofReal (f a - leftLim f a))) := by
    simp only [measure_Ioc]
    have : Tendsto (fun n => f (u n)) atTop (𝓝 (leftLim f a)) := by
      apply (f.mono.tendsto_leftLim a).comp
      exact
        tendsto_nhdsWithin_of_tendsto_nhds_of_eventually_within _ u_lim
          (eventually_of_forall fun n => u_lt_a n)
    exact ENNReal.continuous_ofReal.continuousAt.tendsto.comp (tendsto_const_nhds.sub this)
state_before: case intro.intro.intro
f : StieltjesFunction
a : ℝ
u : ℕ → ℝ
u_mono : StrictMono u
u_lt_a : ∀ (n : ℕ), u n < a
u_lim : Tendsto u atTop (𝓝 a)
A : {a} = ⋂ n, Ioc (u n) a
L1 : Tendsto (fun n => f.measure (Ioc (u n) a)) atTop (𝓝 (f.measure {a}))
L2 : Tendsto (fun n => f.measure (Ioc (u n) a)) atTop (𝓝 (ofReal (↑f a - leftLim (↑f) a)))
⊢ f.measure {a} = ofReal (↑f a - leftLim (↑f) a)
state_after: no goals
tactic: exact tendsto_nhds_unique L1 L2
Theorem: Matrix.finite_spectrum
File: Mathlib/LinearAlgebra/Eigenspace/Minpoly.lean

Proof steps:
state_before: n : Type u_1
R : Type u_2
inst✝² : Field R
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n R
⊢ (spectrum R A).Finite
state_after: n : Type u_1
R : Type u_2
inst✝² : Field R
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n R
⊢ (spectrum R ((toLinAlgEquiv (Pi.basisFun R n)) A)).Finite
tactic: rw [← AlgEquiv.spectrum_eq (Matrix.toLinAlgEquiv <| Pi.basisFun R n) A]
state_before: n : Type u_1
R : Type u_2
inst✝² : Field R
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix n n R
⊢ (spectrum R ((toLinAlgEquiv (Pi.basisFun R n)) A)).Finite
state_after: no goals
tactic: exact Module.End.finite_spectrum _
Theorem: MonoidHom.precompEquiv_apply
File: Mathlib/Algebra/Category/Grp/ForgetCorepresentable.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Monoid α
inst✝¹ : Monoid β
e : α ≃* β
γ : Type u_3
inst✝ : Monoid γ
x✝ : β →* γ
⊢ (fun g => g.comp ↑e.symm) ((fun f => f.comp ↑e) x✝) = x✝
state_after: case h
α : Type u_1
β : Type u_2
inst✝² : Monoid α
inst✝¹ : Monoid β
e : α ≃* β
γ : Type u_3
inst✝ : Monoid γ
x✝¹ : β →* γ
x✝ : β
⊢ ((fun g => g.comp ↑e.symm) ((fun f => f.comp ↑e) x✝¹)) x✝ = x✝¹ x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
inst✝² : Monoid α
inst✝¹ : Monoid β
e : α ≃* β
γ : Type u_3
inst✝ : Monoid γ
x✝¹ : β →* γ
x✝ : β
⊢ ((fun g => g.comp ↑e.symm) ((fun f => f.comp ↑e) x✝¹)) x✝ = x✝¹ x✝
state_after: no goals
tactic: simp
state_before: α : Type u_1
β : Type u_2
inst✝² : Monoid α
inst✝¹ : Monoid β
e : α ≃* β
γ : Type u_3
inst✝ : Monoid γ
x✝ : α →* γ
⊢ (fun f => f.comp ↑e) ((fun g => g.comp ↑e.symm) x✝) = x✝
state_after: case h
α : Type u_1
β : Type u_2
inst✝² : Monoid α
inst✝¹ : Monoid β
e : α ≃* β
γ : Type u_3
inst✝ : Monoid γ
x✝¹ : α →* γ
x✝ : α
⊢ ((fun f => f.comp ↑e) ((fun g => g.comp ↑e.symm) x✝¹)) x✝ = x✝¹ x✝
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
inst✝² : Monoid α
inst✝¹ : Monoid β
e : α ≃* β
γ : Type u_3
inst✝ : Monoid γ
x✝¹ : α →* γ
x✝ : α
⊢ ((fun f => f.comp ↑e) ((fun g => g.comp ↑e.symm) x✝¹)) x✝ = x✝¹ x✝
state_after: no goals
tactic: simp
Theorem: Matrix.vec3_add
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : Add α
a₀ a₁ a₂ b₀ b₁ b₂ : α
⊢ ![a₀, a₁, a₂] + ![b₀, b₁, b₂] = ![a₀ + b₀, a₁ + b₁, a₂ + b₂]
state_after: no goals
tactic: rw [cons_add_cons, cons_add_cons, cons_add_cons, empty_add_empty]
Theorem: Matrix.eta_fin_two
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix (Fin 2) (Fin 2) α
⊢ A = !![A 0 0, A 0 1; A 1 0, A 1 1]
state_after: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix (Fin 2) (Fin 2) α
i j : Fin 2
⊢ A i j = !![A 0 0, A 0 1; A 1 0, A 1 1] i j
tactic: ext i j
state_before: case a
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix (Fin 2) (Fin 2) α
i j : Fin 2
⊢ A i j = !![A 0 0, A 0 1; A 1 0, A 1 1] i j
state_after: no goals
tactic: fin_cases i <;> fin_cases j <;> rfl
Theorem: HilbertBasis.dense_span
File: Mathlib/Analysis/InnerProductSpace/l2Space.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
inst✝⁴ : RCLike 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
cplt : CompleteSpace E
G : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (G i)
inst✝ : (i : ι) → InnerProductSpace 𝕜 (G i)
b : HilbertBasis ι 𝕜 E
⊢ (span 𝕜 (Set.range fun i => b.repr.symm (lp.single 2 i 1))).topologicalClosure = ⊤
state_after: no goals
tactic: classical
    rw [eq_top_iff]
    rintro x -
    refine mem_closure_of_tendsto (b.hasSum_repr x) (eventually_of_forall ?_)
    intro s
    simp only [SetLike.mem_coe]
    refine sum_mem ?_
    rintro i -
    refine smul_mem _ _ ?_
    exact subset_span ⟨i, rfl⟩
Theorem: HomologicalComplex.homologyι_singleObjOpcyclesSelfIso_inv
File: Mathlib/Algebra/Homology/SingleHomology.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
inst✝¹ : HasZeroObject C
ι : Type u_1
inst✝ : DecidableEq ι
c : ComplexShape ι
j : ι
A : C
⊢ ((single C c j).obj A).homologyι j ≫ (singleObjOpcyclesSelfIso c j A).inv = (singleObjHomologySelfIso c j A).hom
state_after: no goals
tactic: rw [← cancel_epi (singleObjHomologySelfIso _ _ _).inv,
    singleObjHomologySelfIso_inv_homologyι_assoc, Iso.hom_inv_id, Iso.inv_hom_id]
Theorem: WeierstrassCurve.Affine.baseChange_addPolynomial
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R✝ : Type u
inst✝¹¹ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝¹⁰ : CommRing R
W : Affine R
S : Type s
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
x y L : A
⊢ (baseChange W B).toAffine.addPolynomial (f x) (f y) (f L) =
    Polynomial.map (↑f) ((baseChange W A).toAffine.addPolynomial x y L)
state_after: R✝ : Type u
inst✝¹¹ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝¹⁰ : CommRing R
W : Affine R
S : Type s
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
x y L : A
⊢ (baseChange W B).toAffine.addPolynomial (f x) (f y) (f L) =
    (baseChange W B).toAffine.addPolynomial (↑f x) (↑f y) (↑f L)
tactic: rw [← map_addPolynomial, map_baseChange]
state_before: R✝ : Type u
inst✝¹¹ : CommRing R✝
W✝ : Affine R✝
R : Type r
inst✝¹⁰ : CommRing R
W : Affine R
S : Type s
inst✝⁹ : CommRing S
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
x y L : A
⊢ (baseChange W B).toAffine.addPolynomial (f x) (f y) (f L) =
    (baseChange W B).toAffine.addPolynomial (↑f x) (↑f y) (↑f L)
state_after: no goals
tactic: rfl
Theorem: Homeomorph.transPartialHomeomorph_trans
File: Mathlib/Topology/PartialHomeomorph.lean

Proof steps:
state_before: X : Type u_1
X' : Type u_2
Y : Type u_3
Y' : Type u_4
Z : Type u_5
Z' : Type u_6
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace X'
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Y'
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace Z'
e✝ : X ≃ₜ Y
e' : Y ≃ₜ Z
e : X ≃ₜ Y
f : PartialHomeomorph Y Z
f' : PartialHomeomorph Z Z'
⊢ (e.transPartialHomeomorph f).trans f' = e.transPartialHomeomorph (f.trans f')
state_after: no goals
tactic: simp only [transPartialHomeomorph_eq_trans, PartialHomeomorph.trans_assoc]
Theorem: Valuation.isEquiv_iff_valuationSubring
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

Proof steps:
state_before: K : Type u
inst✝³ : Field K
Γ : Type u_1
Γ₁ : Type u_2
Γ₂ : Type u_3
inst✝² : LinearOrderedCommGroupWithZero Γ
inst✝¹ : LinearOrderedCommGroupWithZero Γ₁
inst✝ : LinearOrderedCommGroupWithZero Γ₂
v : Valuation K Γ
v₁ : Valuation K Γ₁
v₂ : Valuation K Γ₂
⊢ v₁.IsEquiv v₂ ↔ v₁.valuationSubring = v₂.valuationSubring
state_after: case mp
K : Type u
inst✝³ : Field K
Γ : Type u_1
Γ₁ : Type u_2
Γ₂ : Type u_3
inst✝² : LinearOrderedCommGroupWithZero Γ
inst✝¹ : LinearOrderedCommGroupWithZero Γ₁
inst✝ : LinearOrderedCommGroupWithZero Γ₂
v : Valuation K Γ
v₁ : Valuation K Γ₁
v₂ : Valuation K Γ₂
⊢ v₁.IsEquiv v₂ → v₁.valuationSubring = v₂.valuationSubring

case mpr
K : Type u
inst✝³ : Field K
Γ : Type u_1
Γ₁ : Type u_2
Γ₂ : Type u_3
inst✝² : LinearOrderedCommGroupWithZero Γ
inst✝¹ : LinearOrderedCommGroupWithZero Γ₁
inst✝ : LinearOrderedCommGroupWithZero Γ₂
v : Valuation K Γ
v₁ : Valuation K Γ₁
v₂ : Valuation K Γ₂
⊢ v₁.valuationSubring = v₂.valuationSubring → v₁.IsEquiv v₂
tactic: constructor
Theorem: CategoryTheory.LocalizerMorphism.IsLocalizedEquivalence.mk'
File: Mathlib/CategoryTheory/Localization/LocalizerMorphism.lean

Proof steps:
state_before: C₁ : Type u₁
C₂ : Type u₂
C₃ : Type u₃
D₁ : Type u₄
D₂ : Type u₅
D₃ : Type u₆
inst✝⁹ : Category.{v₁, u₁} C₁
inst✝⁸ : Category.{v₂, u₂} C₂
inst✝⁷ : Category.{v₃, u₃} C₃
inst✝⁶ : Category.{v₄, u₄} D₁
inst✝⁵ : Category.{v₅, u₅} D₂
inst✝⁴ : Category.{v₆, u₆} D₃
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
W₃ : MorphismProperty C₃
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝³ : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝² : L₂.IsLocalization W₂
G : D₁ ⥤ D₂
inst✝¹ : CatCommSq Φ.functor L₁ L₂ G
inst✝ : G.IsEquivalence
⊢ (Φ.localizedFunctor W₁.Q W₂.Q).IsEquivalence
state_after: C₁ : Type u₁
C₂ : Type u₂
C₃ : Type u₃
D₁ : Type u₄
D₂ : Type u₅
D₃ : Type u₆
inst✝⁹ : Category.{v₁, u₁} C₁
inst✝⁸ : Category.{v₂, u₂} C₂
inst✝⁷ : Category.{v₃, u₃} C₃
inst✝⁶ : Category.{v₄, u₄} D₁
inst✝⁵ : Category.{v₅, u₅} D₂
inst✝⁴ : Category.{v₆, u₆} D₃
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
W₃ : MorphismProperty C₃
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝³ : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝² : L₂.IsLocalization W₂
G : D₁ ⥤ D₂
inst✝¹ : CatCommSq Φ.functor L₁ L₂ G
inst✝ : G.IsEquivalence
⊢ G.IsEquivalence
tactic: rw [Φ.isEquivalence_iff W₁.Q W₂.Q (Φ.localizedFunctor W₁.Q W₂.Q) L₁ L₂ G]
state_before: C₁ : Type u₁
C₂ : Type u₂
C₃ : Type u₃
D₁ : Type u₄
D₂ : Type u₅
D₃ : Type u₆
inst✝⁹ : Category.{v₁, u₁} C₁
inst✝⁸ : Category.{v₂, u₂} C₂
inst✝⁷ : Category.{v₃, u₃} C₃
inst✝⁶ : Category.{v₄, u₄} D₁
inst✝⁵ : Category.{v₅, u₅} D₂
inst✝⁴ : Category.{v₆, u₆} D₃
W₁ : MorphismProperty C₁
W₂ : MorphismProperty C₂
W₃ : MorphismProperty C₃
Φ : LocalizerMorphism W₁ W₂
L₁ : C₁ ⥤ D₁
inst✝³ : L₁.IsLocalization W₁
L₂ : C₂ ⥤ D₂
inst✝² : L₂.IsLocalization W₂
G : D₁ ⥤ D₂
inst✝¹ : CatCommSq Φ.functor L₁ L₂ G
inst✝ : G.IsEquivalence
⊢ G.IsEquivalence
state_after: no goals
tactic: exact inferInstance
Theorem: real_inner_sub_sub_self
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
⊢ ⟪x - y, x - y⟫_ℝ = ⟪x, x⟫_ℝ - 2 * ⟪x, y⟫_ℝ + ⟪y, y⟫_ℝ
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
this : ⟪y, x⟫_ℝ = ⟪x, y⟫_ℝ
⊢ ⟪x - y, x - y⟫_ℝ = ⟪x, x⟫_ℝ - 2 * ⟪x, y⟫_ℝ + ⟪y, y⟫_ℝ
tactic: have : ⟪y, x⟫_ℝ = ⟪x, y⟫_ℝ := by rw [← inner_conj_symm]; rfl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
this : ⟪y, x⟫_ℝ = ⟪x, y⟫_ℝ
⊢ ⟪x - y, x - y⟫_ℝ = ⟪x, x⟫_ℝ - 2 * ⟪x, y⟫_ℝ + ⟪y, y⟫_ℝ
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
this : ⟪y, x⟫_ℝ = ⟪x, y⟫_ℝ
⊢ ⟪x, x⟫_ℝ - ⟪x, y⟫_ℝ - ⟪x, y⟫_ℝ = ⟪x, x⟫_ℝ - 2 * ⟪x, y⟫_ℝ
tactic: simp only [inner_sub_sub_self, this, add_left_inj]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
this : ⟪y, x⟫_ℝ = ⟪x, y⟫_ℝ
⊢ ⟪x, x⟫_ℝ - ⟪x, y⟫_ℝ - ⟪x, y⟫_ℝ = ⟪x, x⟫_ℝ - 2 * ⟪x, y⟫_ℝ
state_after: no goals
tactic: ring
Theorem: dist_inv
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
x y : E
⊢ dist x⁻¹ y = dist x y⁻¹
state_after: no goals
tactic: simp_rw [dist_eq_norm_div, ← norm_inv' (x⁻¹ / y), inv_div, div_inv_eq_mul, mul_comm]
Theorem: Multiset.map_eq_zero
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
s : Multiset α
f : α → β
⊢ map f s = 0 ↔ s = 0
state_after: no goals
tactic: rw [← Multiset.card_eq_zero, Multiset.card_map, Multiset.card_eq_zero]
Theorem: Cardinal.exists_not_mem_of_length_lt
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α✝ β : Type u
c : Cardinal.{?u.236298}
α : Type u_1
l : List α
h : ↑l.length < #α
⊢ ∃ z, z ∉ l
state_after: α✝ β : Type u
c : Cardinal.{?u.236298}
α : Type u_1
l : List α
h : ∀ (z : α), z ∈ l
⊢ #α ≤ ↑l.length
tactic: contrapose! h
state_before: α✝ β : Type u
c : Cardinal.{?u.236298}
α : Type u_1
l : List α
h : ∀ (z : α), z ∈ l
⊢ #α ≤ ↑l.length
state_after: no goals
tactic: calc
    #α = #(Set.univ : Set α) := mk_univ.symm
    _ ≤ #l.toFinset := mk_le_mk_of_subset fun x _ => List.mem_toFinset.mpr (h x)
    _ = l.toFinset.card := Cardinal.mk_coe_finset
    _ ≤ l.length := Cardinal.natCast_le.mpr (List.toFinset_card_le l)
Theorem: Nat.testBit_eq_false_of_lt
File: Mathlib/Data/Nat/Bitwise.lean

Proof steps:
state_before: n i : ℕ
h : n < 2 ^ i
⊢ n.testBit i = false
state_after: no goals
tactic: simp [testBit, shiftRight_eq_div_pow, Nat.div_eq_of_lt h]
Theorem: Real.rpow_mul_natCast
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y✝ z : ℝ
n✝ : ℕ
hx : 0 ≤ x
y : ℝ
n : ℕ
⊢ x ^ (y * ↑n) = (x ^ y) ^ n
state_after: no goals
tactic: rw [rpow_mul hx, rpow_natCast]
Theorem: CategoryTheory.OverPresheafAux.counitForward_naturality₂
File: Mathlib/CategoryTheory/Comma/Presheaf.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
s t : (CostructuredArrow yoneda A)ᵒᵖ
f : t ⟶ s
x : F.obj t
⊢ yoneda.map f.unop.left ≫ (unop t).hom = (unop s).hom
state_after: no goals
tactic: simp
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
s t : (CostructuredArrow yoneda A)ᵒᵖ
f : t ⟶ s
x : F.obj t
⊢ counitForward F (unop s) (F.map f x) = (counitForward F (unop t) x).map₂ f.unop.left ⋯
state_after: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
s t : (CostructuredArrow yoneda A)ᵒᵖ
f : t ⟶ s
x : F.obj t
⊢ F.map (eqToHom ⋯) (YonedaCollection.snd ((counitForward F (unop t) x).map₂ f.unop.left ⋯).val) =
    YonedaCollection.snd (counitForward F (unop s) (F.map f x)).val
tactic: refine OverArrows.ext <| YonedaCollection.ext (by simp) ?_
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
s t : (CostructuredArrow yoneda A)ᵒᵖ
f : t ⟶ s
x : F.obj t
⊢ F.map (eqToHom ⋯) (YonedaCollection.snd ((counitForward F (unop t) x).map₂ f.unop.left ⋯).val) =
    YonedaCollection.snd (counitForward F (unop s) (F.map f x)).val
state_after: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
s t : (CostructuredArrow yoneda A)ᵒᵖ
f : t ⟶ s
x : F.obj t
this : (CostructuredArrow.mkPrecomp (unop t).hom f.unop.left).op = f ≫ eqToHom ⋯
⊢ F.map (eqToHom ⋯) (YonedaCollection.snd ((counitForward F (unop t) x).map₂ f.unop.left ⋯).val) =
    YonedaCollection.snd (counitForward F (unop s) (F.map f x)).val
tactic: have : (CostructuredArrow.mkPrecomp t.unop.hom f.unop.left).op =
      f ≫ eqToHom (by simp [← CostructuredArrow.eq_mk]) := by
    apply Quiver.Hom.unop_inj
    aesop_cat
state_before: C : Type u
inst✝ : Category.{v, u} C
A : Cᵒᵖ ⥤ Type v
F : (CostructuredArrow yoneda A)ᵒᵖ ⥤ Type v
X : C
s t : (CostructuredArrow yoneda A)ᵒᵖ
f : t ⟶ s
x : F.obj t
this : (CostructuredArrow.mkPrecomp (unop t).hom f.unop.left).op = f ≫ eqToHom ⋯
⊢ F.map (eqToHom ⋯) (YonedaCollection.snd ((counitForward F (unop t) x).map₂ f.unop.left ⋯).val) =
    YonedaCollection.snd (counitForward F (unop s) (F.map f x)).val
state_after: no goals
tactic: aesop_cat
Theorem: Finset.Ioo_subset_Iio_self
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : LocallyFiniteOrderBot α
⊢ Ioo a b ⊆ Iio b
state_after: no goals
tactic: simpa [← coe_subset] using Set.Ioo_subset_Iio_self
Theorem: isConformalMap_of_subsingleton
File: Mathlib/Analysis/NormedSpace/ConformalLinearMap.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
N : Type u_3
G : Type u_4
M' : Type u_5
inst✝⁹ : NormedField R
inst✝⁸ : SeminormedAddCommGroup M
inst✝⁷ : SeminormedAddCommGroup N
inst✝⁶ : SeminormedAddCommGroup G
inst✝⁵ : NormedSpace R M
inst✝⁴ : NormedSpace R N
inst✝³ : NormedSpace R G
inst✝² : NormedAddCommGroup M'
inst✝¹ : NormedSpace R M'
f : M →L[R] N
g : N →L[R] G
c : R
inst✝ : Subsingleton M
f' : M →L[R] N
x : M
⊢ ‖0 x‖ = ‖x‖
state_after: no goals
tactic: simp [Subsingleton.elim x 0]
Theorem: TrivSqZeroExt.snd_map
File: Mathlib/Algebra/TrivSqZeroExt.lean

Proof steps:
state_before: S : Type u_1
R R' : Type u
M : Type v
inst✝²⁶ : CommSemiring S
inst✝²⁵ : Semiring R
inst✝²⁴ : CommSemiring R'
inst✝²³ : AddCommMonoid M
inst✝²² : Algebra S R
inst✝²¹ : Algebra S R'
inst✝²⁰ : Module S M
inst✝¹⁹ : Module R M
inst✝¹⁸ : Module Rᵐᵒᵖ M
inst✝¹⁷ : SMulCommClass R Rᵐᵒᵖ M
inst✝¹⁶ : IsScalarTower S R M
inst✝¹⁵ : IsScalarTower S Rᵐᵒᵖ M
inst✝¹⁴ : Module R' M
inst✝¹³ : Module R'ᵐᵒᵖ M
inst✝¹² : IsCentralScalar R' M
inst✝¹¹ : IsScalarTower S R' M
A : Type u_2
inst✝¹⁰ : Semiring A
inst✝⁹ : Algebra S A
inst✝⁸ : Algebra R' A
N : Type u_3
P : Type u_4
inst✝⁷ : AddCommMonoid N
inst✝⁶ : Module R' N
inst✝⁵ : Module R'ᵐᵒᵖ N
inst✝⁴ : IsCentralScalar R' N
inst✝³ : AddCommMonoid P
inst✝² : Module R' P
inst✝¹ : Module R'ᵐᵒᵖ P
inst✝ : IsCentralScalar R' P
f : M →ₗ[R'] N
x : tsze R' M
⊢ ((map f) x).snd = f x.snd
state_after: no goals
tactic: simp [map, lift_def, Algebra.ofId_apply, algebraMap_eq_inl]
Theorem: CategoryTheory.bifunctorComp₂₃Obj_obj_map
File: Mathlib/CategoryTheory/Functor/Trifunctor.lean

Proof steps:
state_before: C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
C₁₂ : Type u_5
C₂₃ : Type u_6
inst✝⁵ : Category.{?u.16016, u_1} C₁
inst✝⁴ : Category.{?u.16020, u_2} C₂
inst✝³ : Category.{?u.16024, u_3} C₃
inst✝² : Category.{?u.16028, u_4} C₄
inst✝¹ : Category.{?u.16032, u_5} C₁₂
inst✝ : Category.{?u.16036, u_6} C₂₃
F : C₁ ⥤ C₂₃ ⥤ C₄
G₂₃ : C₂ ⥤ C₃ ⥤ C₂₃
X₁ : C₁
X₂ Y₂ : C₂
φ✝ : X₂ ⟶ Y₂
X₃ Y₃ : C₃
φ : X₃ ⟶ Y₃
⊢ ((fun X₂ =>
              { obj := fun X₃ => (F.obj X₁).obj ((G₂₃.obj X₂).obj X₃),
                map := fun {X₃ Y₃} φ => (F.obj X₁).map ((G₂₃.obj X₂).map φ), map_id := ⋯, map_comp := ⋯ })
            X₂).map
        φ ≫
      (fun X₃ => (F.obj X₁).map ((G₂₃.map φ✝).app X₃)) Y₃ =
    (fun X₃ => (F.obj X₁).map ((G₂₃.map φ✝).app X₃)) X₃ ≫
      ((fun X₂ =>
              { obj := fun X₃ => (F.obj X₁).obj ((G₂₃.obj X₂).obj X₃),
                map := fun {X₃ Y₃} φ => (F.obj X₁).map ((G₂₃.obj X₂).map φ), map_id := ⋯, map_comp := ⋯ })
            Y₂).map
        φ
state_after: C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
C₁₂ : Type u_5
C₂₃ : Type u_6
inst✝⁵ : Category.{?u.16016, u_1} C₁
inst✝⁴ : Category.{?u.16020, u_2} C₂
inst✝³ : Category.{?u.16024, u_3} C₃
inst✝² : Category.{?u.16028, u_4} C₄
inst✝¹ : Category.{?u.16032, u_5} C₁₂
inst✝ : Category.{?u.16036, u_6} C₂₃
F : C₁ ⥤ C₂₃ ⥤ C₄
G₂₃ : C₂ ⥤ C₃ ⥤ C₂₃
X₁ : C₁
X₂ Y₂ : C₂
φ✝ : X₂ ⟶ Y₂
X₃ Y₃ : C₃
φ : X₃ ⟶ Y₃
⊢ (F.obj X₁).map ((G₂₃.obj X₂).map φ) ≫ (F.obj X₁).map ((G₂₃.map φ✝).app Y₃) =
    (F.obj X₁).map ((G₂₃.map φ✝).app X₃) ≫ (F.obj X₁).map ((G₂₃.obj Y₂).map φ)
tactic: dsimp
state_before: C₁ : Type u_1
C₂ : Type u_2
C₃ : Type u_3
C₄ : Type u_4
C₁₂ : Type u_5
C₂₃ : Type u_6
inst✝⁵ : Category.{?u.16016, u_1} C₁
inst✝⁴ : Category.{?u.16020, u_2} C₂
inst✝³ : Category.{?u.16024, u_3} C₃
inst✝² : Category.{?u.16028, u_4} C₄
inst✝¹ : Category.{?u.16032, u_5} C₁₂
inst✝ : Category.{?u.16036, u_6} C₂₃
F : C₁ ⥤ C₂₃ ⥤ C₄
G₂₃ : C₂ ⥤ C₃ ⥤ C₂₃
X₁ : C₁
X₂ Y₂ : C₂
φ✝ : X₂ ⟶ Y₂
X₃ Y₃ : C₃
φ : X₃ ⟶ Y₃
⊢ (F.obj X₁).map ((G₂₃.obj X₂).map φ) ≫ (F.obj X₁).map ((G₂₃.map φ✝).app Y₃) =
    (F.obj X₁).map ((G₂₃.map φ✝).app X₃) ≫ (F.obj X₁).map ((G₂₃.obj Y₂).map φ)
state_after: no goals
tactic: simp only [← Functor.map_comp, NatTrans.naturality]
Theorem: Matroid.map_freeOn
File: Mathlib/Data/Matroid/Map.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α → β
hf : InjOn f (freeOn E).E
⊢ (freeOn E).map f hf = freeOn (f '' E)
state_after: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α → β
hf : InjOn f (freeOn E).E
⊢ ((freeOn E).map f hf)✶ = (freeOn (f '' E))✶
tactic: rw [← dual_inj]
state_before: α : Type u_1
β : Type u_2
f✝ : α → β
E I s : Set α
M : Matroid α
N : Matroid β
f : α → β
hf : InjOn f (freeOn E).E
⊢ ((freeOn E).map f hf)✶ = (freeOn (f '' E))✶
state_after: no goals
tactic: simp