ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: InnerProductGeometry.inner_eq_neg_mul_norm_iff_angle_eq_pi
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
⊢ ⟪x, y⟫_ℝ = -(‖x‖ * ‖y‖) ↔ angle x y = π
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ⟪x, y⟫_ℝ = -(‖x‖ * ‖y‖)
⊢ angle x y = π
tactic: refine ⟨fun h => ?_, inner_eq_neg_mul_norm_of_angle_eq_pi⟩
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ⟪x, y⟫_ℝ = -(‖x‖ * ‖y‖)
⊢ angle x y = π
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ⟪x, y⟫_ℝ = -(‖x‖ * ‖y‖)
h₁ : ‖x‖ * ‖y‖ ≠ 0
⊢ angle x y = π
tactic: have h₁ : ‖x‖ * ‖y‖ ≠ 0 := (mul_pos (norm_pos_iff.mpr hx) (norm_pos_iff.mpr hy)).ne'
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
hx : x ≠ 0
hy : y ≠ 0
h : ⟪x, y⟫_ℝ = -(‖x‖ * ‖y‖)
h₁ : ‖x‖ * ‖y‖ ≠ 0
⊢ angle x y = π
state_after: no goals
tactic: rw [angle, h, neg_div, div_self h₁, Real.arccos_neg_one]
Theorem: CoxeterSystem.length_mul_le
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w₁ w₂ : W
⊢ cs.length (w₁ * w₂) ≤ cs.length w₁ + cs.length w₂
state_after: case intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w₂ : W
ω₁ : List B
hω₁ : ω₁.length = cs.length (cs.wordProd ω₁)
⊢ cs.length (cs.wordProd ω₁ * w₂) ≤ cs.length (cs.wordProd ω₁) + cs.length w₂
tactic: rcases cs.exists_reduced_word w₁ with ⟨ω₁, hω₁, rfl⟩
state_before: case intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w₂ : W
ω₁ : List B
hω₁ : ω₁.length = cs.length (cs.wordProd ω₁)
⊢ cs.length (cs.wordProd ω₁ * w₂) ≤ cs.length (cs.wordProd ω₁) + cs.length w₂
state_after: case intro.intro.intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω₁ : List B
hω₁ : ω₁.length = cs.length (cs.wordProd ω₁)
ω₂ : List B
hω₂ : ω₂.length = cs.length (cs.wordProd ω₂)
⊢ cs.length (cs.wordProd ω₁ * cs.wordProd ω₂) ≤ cs.length (cs.wordProd ω₁) + cs.length (cs.wordProd ω₂)
tactic: rcases cs.exists_reduced_word w₂ with ⟨ω₂, hω₂, rfl⟩
state_before: case intro.intro.intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω₁ : List B
hω₁ : ω₁.length = cs.length (cs.wordProd ω₁)
ω₂ : List B
hω₂ : ω₂.length = cs.length (cs.wordProd ω₂)
⊢ cs.length (cs.wordProd ω₁ * cs.wordProd ω₂) ≤ cs.length (cs.wordProd ω₁) + cs.length (cs.wordProd ω₂)
state_after: case intro.intro.intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω₁ : List B
hω₁ : ω₁.length = cs.length (cs.wordProd ω₁)
ω₂ : List B
hω₂ : ω₂.length = cs.length (cs.wordProd ω₂)
this : cs.length (cs.wordProd (ω₁ ++ ω₂)) ≤ (ω₁ ++ ω₂).length
⊢ cs.length (cs.wordProd ω₁ * cs.wordProd ω₂) ≤ cs.length (cs.wordProd ω₁) + cs.length (cs.wordProd ω₂)
tactic: have := cs.length_wordProd_le (ω₁ ++ ω₂)
state_before: case intro.intro.intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω₁ : List B
hω₁ : ω₁.length = cs.length (cs.wordProd ω₁)
ω₂ : List B
hω₂ : ω₂.length = cs.length (cs.wordProd ω₂)
this : cs.length (cs.wordProd (ω₁ ++ ω₂)) ≤ (ω₁ ++ ω₂).length
⊢ cs.length (cs.wordProd ω₁ * cs.wordProd ω₂) ≤ cs.length (cs.wordProd ω₁) + cs.length (cs.wordProd ω₂)
state_after: no goals
tactic: simpa [hω₁, hω₂, wordProd_append] using this
Theorem: MonoidHom.CompTriple.comp_apply
File: Mathlib/Algebra/Group/Hom/CompTypeclasses.lean

Proof steps:
state_before: M' : Type u_1
inst✝³ : Monoid M'
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
φ : M →* N
ψ : N →* P
χ : M →* P
h : φ.CompTriple ψ χ
x : M
⊢ ψ (φ x) = χ x
state_after: no goals
tactic: rw [← h.comp_eq, MonoidHom.comp_apply]
Theorem: Matrix.det_updateRow_add_smul_self
File: Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
c : R
⊢ (A.updateRow i (A i + c • A j)).det = A.det
state_after: no goals
tactic: simp [det_updateRow_add, det_updateRow_smul,
    det_zero_of_row_eq hij (updateRow_self.trans (updateRow_ne hij.symm).symm)]
Theorem: List.mem_pi
File: Mathlib/Data/List/Pi.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : DecidableEq ι
α : ι → Type u_2
l : List ι
fs : (i : ι) → List (α i)
⊢ ∀ (f : (i : ι) → i ∈ l → α i), f ∈ l.pi fs ↔ ∀ (i : ι) (hi : i ∈ l), f i hi ∈ fs i
state_after: ι : Type u_1
inst✝ : DecidableEq ι
α : ι → Type u_2
l : List ι
fs : (i : ι) → List (α i)
f : (i : ι) → i ∈ l → α i
⊢ f ∈ l.pi fs ↔ ∀ (i : ι) (hi : i ∈ l), f i hi ∈ fs i
tactic: intros f
state_before: case h.e'_1.a
ι : Type u_1
inst✝ : DecidableEq ι
α : ι → Type u_2
l : List ι
fs : (i : ι) → List (α i)
f : (i : ι) → i ∈ l → α i
⊢ f ∈ l.pi fs ↔ f ∈ (↑l).pi fun x => ↑(fs x)
state_after: case h.e'_1.a
ι : Type u_1
inst✝ : DecidableEq ι
α : ι → Type u_2
l : List ι
fs : (i : ι) → List (α i)
f : (i : ι) → i ∈ l → α i
⊢ f ∈ l.pi fs ↔ f ∈ ↑(l.pi fs)
tactic: rw [Multiset.pi_coe]
state_before: case h.e'_1.a
ι : Type u_1
inst✝ : DecidableEq ι
α : ι → Type u_2
l : List ι
fs : (i : ι) → List (α i)
f : (i : ι) → i ∈ l → α i
⊢ f ∈ l.pi fs ↔ f ∈ ↑(l.pi fs)
state_after: no goals
tactic: rfl
Theorem: ProbabilityTheory.Kernel.iIndepSets.meas_iInter
File: Mathlib/Probability/Independence/Kernel.lean

Proof steps:
state_before: α : Type u_1
Ω : Type u_2
ι : Type u_3
β : ι → Type u_4
mβ : (i : ι) → MeasurableSpace (β i)
_mα : MeasurableSpace α
m : ι → MeasurableSpace Ω
_mΩ : MeasurableSpace Ω
κ : Kernel α Ω
μ : Measure α
π : ι → Set (Set Ω)
s : ι → Set Ω
S : Finset ι
f : (x : ι) → Ω → β x
inst✝ : Fintype ι
h : iIndepSets π κ μ
hs : ∀ (i : ι), s i ∈ π i
⊢ ∀ᵐ (a : α) ∂μ, (κ a) (⋂ i, s i) = ∏ i : ι, (κ a) (s i)
state_after: no goals
tactic: filter_upwards [h.meas_biInter Finset.univ (fun _i _ ↦ hs _)] with a ha using by simp [← ha]
Theorem: AddChar.coe_mk
File: Mathlib/Algebra/Group/AddChar.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
M : Type u_3
N : Type u_4
inst✝³ : AddMonoid A
inst✝² : AddMonoid B
inst✝¹ : Monoid M
inst✝ : Monoid N
ψ : AddChar A M
f : A → M
map_zero_eq_one' : f 0 = 1
map_add_eq_mul' : ∀ (a b : A), f (a + b) = f a * f b
⊢ ⇑{ toFun := f, map_zero_eq_one' := map_zero_eq_one', map_add_eq_mul' := map_add_eq_mul' } = f
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.isIso_unop_iff
File: Mathlib/CategoryTheory/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
X Y : Cᵒᵖ
f : X ⟶ Y
⊢ IsIso f.unop ↔ IsIso f
state_after: no goals
tactic: rw [← isIso_op_iff f.unop, Quiver.Hom.op_unop]
Theorem: IsSubfield.div_mem
File: Mathlib/Deprecated/Subfield.lean

Proof steps:
state_before: F : Type u_1
inst✝ : Field F
S✝ S : Set F
hS : IsSubfield S
x y : F
hx : x ∈ S
hy : y ∈ S
⊢ x / y ∈ S
state_after: F : Type u_1
inst✝ : Field F
S✝ S : Set F
hS : IsSubfield S
x y : F
hx : x ∈ S
hy : y ∈ S
⊢ x * y⁻¹ ∈ S
tactic: rw [div_eq_mul_inv]
state_before: F : Type u_1
inst✝ : Field F
S✝ S : Set F
hS : IsSubfield S
x y : F
hx : x ∈ S
hy : y ∈ S
⊢ x * y⁻¹ ∈ S
state_after: no goals
tactic: exact hS.toIsSubring.toIsSubmonoid.mul_mem hx (hS.inv_mem hy)
Theorem: LinearIndependent.restrict_scalars_algebras
File: Mathlib/LinearAlgebra/FreeModule/PID.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
ι : Type u_4
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring S
inst✝⁴ : AddCommMonoid M
inst✝³ : Algebra R S
inst✝² : Module R M
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
hinj : Function.Injective ⇑(algebraMap R S)
v : ι → M
li : LinearIndependent S v
⊢ Function.Injective fun r => r • 1
state_after: no goals
tactic: rwa [Algebra.algebraMap_eq_smul_one'] at hinj
Theorem: Ordnode.size_balance'
File: Mathlib/Data/Ordmap/Ordset.lean

Proof steps:
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
⊢ (l.balance' x r).size = l.size + r.size + 1
state_after: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
⊢ (if l.size + r.size ≤ 1 then l.node' x r
      else
        if r.size > delta * l.size then l.rotateL x r
        else if l.size > delta * r.size then l.rotateR x r else l.node' x r).size =
    l.size + r.size + 1
tactic: unfold balance'
state_before: α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
⊢ (if l.size + r.size ≤ 1 then l.node' x r
      else
        if r.size > delta * l.size then l.rotateL x r
        else if l.size > delta * r.size then l.rotateR x r else l.node' x r).size =
    l.size + r.size + 1
state_after: case pos
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
h✝ : l.size + r.size ≤ 1
⊢ (l.node' x r).size = l.size + r.size + 1

case pos
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
h✝¹ : ¬l.size + r.size ≤ 1
h✝ : r.size > delta * l.size
⊢ (l.rotateL x r).size = l.size + r.size + 1

case pos
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
h✝² : ¬l.size + r.size ≤ 1
h✝¹ : ¬r.size > delta * l.size
h✝ : l.size > delta * r.size
⊢ (l.rotateR x r).size = l.size + r.size + 1

case neg
α : Type u_1
l : Ordnode α
x : α
r : Ordnode α
hl : l.Sized
hr : r.Sized
h✝² : ¬l.size + r.size ≤ 1
h✝¹ : ¬r.size > delta * l.size
h✝ : ¬l.size > delta * r.size
⊢ (l.node' x r).size = l.size + r.size + 1
tactic: split_ifs
Theorem: FreeGroup.invRev_length
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
⊢ (invRev L₁).length = L₁.length
state_after: no goals
tactic: simp [invRev]
Theorem: AlgebraicGeometry.PresheafedSpace.stalkMap.congr_hom
File: Mathlib/Geometry/RingedSpace/Stalks.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
α β : X ⟶ Y
h : α = β
x : ↑↑X
⊢ Y.presheaf.stalk (α.base x) = Y.presheaf.stalk (β.base x)
state_after: no goals
tactic: rw [h]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : HasColimits C
X Y : PresheafedSpace C
α β : X ⟶ Y
h : α = β
x : ↑↑X
⊢ Hom.stalkMap α x = eqToHom ⋯ ≫ Hom.stalkMap β x
state_after: no goals
tactic: rw [← stalkMap.congr α β h x x rfl, eqToHom_refl, Category.comp_id]
Theorem: Matrix.toLinearMap₂_compl₁₂
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M✝ : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
inst✝¹⁸ : CommSemiring R
inst✝¹⁷ : AddCommMonoid M₁
inst✝¹⁶ : Module R M₁
inst✝¹⁵ : AddCommMonoid M₂
inst✝¹⁴ : Module R M₂
inst✝¹³ : AddCommMonoid N₂
inst✝¹² : Module R N₂
inst✝¹¹ : DecidableEq n
inst✝¹⁰ : Fintype n
inst✝⁹ : DecidableEq m
inst✝⁸ : Fintype m
b₁✝ : Basis n R M₁
b₂✝ : Basis m R M₂
b₁ : Basis n R M₁
b₂ : Basis m R M₂
inst✝⁷ : AddCommMonoid M₁'
inst✝⁶ : Module R M₁'
inst✝⁵ : AddCommMonoid M₂'
inst✝⁴ : Module R M₂'
b₁' : Basis n' R M₁'
b₂' : Basis m' R M₂'
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
M : Matrix n m R
P : Matrix n n' R
Q : Matrix m m' R
⊢ (toMatrix₂ b₁' b₂') (((toLinearMap₂ b₁ b₂) M).compl₁₂ ((toLin b₁' b₁) P) ((toLin b₂' b₂) Q)) =
    (toMatrix₂ b₁' b₂') ((toLinearMap₂ b₁' b₂') (Pᵀ * M * Q))
state_after: no goals
tactic: simp only [LinearMap.toMatrix₂_compl₁₂ b₁ b₂, LinearMap.toMatrix₂_toLinearMap₂,
        toMatrix_toLin]
Theorem: List.perm_dlookup
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd₁ : l₁.NodupKeys
nd₂ : l₂.NodupKeys
p : l₁ ~ l₂
⊢ dlookup a l₁ = dlookup a l₂
state_after: case a
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd₁ : l₁.NodupKeys
nd₂ : l₂.NodupKeys
p : l₁ ~ l₂
b : β a
⊢ b ∈ dlookup a l₁ ↔ b ∈ dlookup a l₂
tactic: ext b
state_before: case a
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd₁ : l₁.NodupKeys
nd₂ : l₂.NodupKeys
p : l₁ ~ l₂
b : β a
⊢ b ∈ dlookup a l₁ ↔ b ∈ dlookup a l₂
state_after: case a
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd₁ : l₁.NodupKeys
nd₂ : l₂.NodupKeys
p : l₁ ~ l₂
b : β a
⊢ ⟨a, b⟩ ∈ l₁ ↔ ⟨a, b⟩ ∈ l₂
tactic: simp only [mem_dlookup_iff nd₁, mem_dlookup_iff nd₂]
state_before: case a
α : Type u
β : α → Type v
l l₁✝ l₂✝ : List (Sigma β)
inst✝ : DecidableEq α
a : α
l₁ l₂ : List (Sigma β)
nd₁ : l₁.NodupKeys
nd₂ : l₂.NodupKeys
p : l₁ ~ l₂
b : β a
⊢ ⟨a, b⟩ ∈ l₁ ↔ ⟨a, b⟩ ∈ l₂
state_after: no goals
tactic: exact p.mem_iff
Theorem: MeasureTheory.Measure.AbsolutelyContinuous.trim
File: Mathlib/MeasureTheory/Measure/Trim.lean

Proof steps:
state_before: α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s : Set α
ν : Measure α
hμν : μ ≪ ν
hm : m ≤ m0
⊢ μ.trim hm ≪ ν.trim hm
state_after: α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s✝ : Set α
ν : Measure α
hμν : μ ≪ ν
hm : m ≤ m0
s : Set α
hs : MeasurableSet s
hsν : (ν.trim hm) s = 0
⊢ (μ.trim hm) s = 0
tactic: refine Measure.AbsolutelyContinuous.mk (fun s hs hsν ↦ ?_)
state_before: α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s✝ : Set α
ν : Measure α
hμν : μ ≪ ν
hm : m ≤ m0
s : Set α
hs : MeasurableSet s
hsν : (ν.trim hm) s = 0
⊢ (μ.trim hm) s = 0
state_after: α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s✝ : Set α
ν : Measure α
hμν : μ ≪ ν
hm : m ≤ m0
s : Set α
hs : MeasurableSet s
hsν : ν s = 0
⊢ μ s = 0
tactic: rw [trim_measurableSet_eq hm hs] at hsν ⊢
state_before: α : Type u_1
m m0 : MeasurableSpace α
μ : Measure α
s✝ : Set α
ν : Measure α
hμν : μ ≪ ν
hm : m ≤ m0
s : Set α
hs : MeasurableSet s
hsν : ν s = 0
⊢ μ s = 0
state_after: no goals
tactic: exact hμν hsν
Theorem: AddEquiv.toIntLinearEquiv_toAddEquiv
File: Mathlib/Algebra/Module/Equiv/Basic.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
K : Type u_6
S : Type u_7
M : Type u_8
M₁ : Type u_9
M₂ : Type u_10
M₃ : Type u_11
N₁ : Type u_12
N₂ : Type u_13
N₃ : Type u_14
N₄ : Type u_15
ι : Type u_16
inst✝² : AddCommGroup M
inst✝¹ : AddCommGroup M₂
inst✝ : AddCommGroup M₃
e : M ≃+ M₂
⊢ ↑e.toIntLinearEquiv = e
state_after: case h
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
K : Type u_6
S : Type u_7
M : Type u_8
M₁ : Type u_9
M₂ : Type u_10
M₃ : Type u_11
N₁ : Type u_12
N₂ : Type u_13
N₃ : Type u_14
N₄ : Type u_15
ι : Type u_16
inst✝² : AddCommGroup M
inst✝¹ : AddCommGroup M₂
inst✝ : AddCommGroup M₃
e : M ≃+ M₂
x✝ : M
⊢ ↑e.toIntLinearEquiv x✝ = e x✝
tactic: ext
state_before: case h
R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
K : Type u_6
S : Type u_7
M : Type u_8
M₁ : Type u_9
M₂ : Type u_10
M₃ : Type u_11
N₁ : Type u_12
N₂ : Type u_13
N₃ : Type u_14
N₄ : Type u_15
ι : Type u_16
inst✝² : AddCommGroup M
inst✝¹ : AddCommGroup M₂
inst✝ : AddCommGroup M₃
e : M ≃+ M₂
x✝ : M
⊢ ↑e.toIntLinearEquiv x✝ = e x✝
state_after: no goals
tactic: rfl
Theorem: ContinuousLinearEquiv.comp_right_hasFDerivAt_iff
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : F → G
x : E
f' : F →L[𝕜] G
⊢ HasFDerivAt (f ∘ ⇑iso) (f'.comp ↑iso) x ↔ HasFDerivAt f f' (iso x)
state_after: no goals
tactic: simp only [← hasFDerivWithinAt_univ, ← comp_right_hasFDerivWithinAt_iff, preimage_univ]
Theorem: Zsqrtd.norm_one
File: Mathlib/NumberTheory/Zsqrtd/Basic.lean

Proof steps:
state_before: d : ℤ
⊢ norm 1 = 1
state_after: no goals
tactic: simp [norm]
Theorem: ContractingWith.one_sub_K_pos'
File: Mathlib/Topology/MetricSpace/Contracting.lean

Proof steps:
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
⊢ 0 < 1 - ↑K
state_after: no goals
tactic: simp [hf.1]
Theorem: CategoryTheory.Comma.post_obj_right
File: Mathlib/CategoryTheory/Comma/Basic.lean

Proof steps:
state_before: A : Type u₁
inst✝⁷ : Category.{v₁, u₁} A
B : Type u₂
inst✝⁶ : Category.{v₂, u₂} B
T : Type u₃
inst✝⁵ : Category.{v₃, u₃} T
A' : Type u_1
B' : Type u_2
T' : Type u_3
inst✝⁴ : Category.{?u.158446, u_1} A'
inst✝³ : Category.{?u.158450, u_2} B'
inst✝² : Category.{?u.158454, u_3} T'
L✝ : A ⥤ T
R✝ : B ⥤ T
C : Type u₄
inst✝¹ : Category.{v₄, u₄} C
D : Type u₅
inst✝ : Category.{v₅, u₅} D
L : A ⥤ T
R : B ⥤ T
F : T ⥤ C
X✝ Y✝ : Comma L R
f : X✝ ⟶ Y✝
⊢ (L ⋙ F).map f.left ≫ ((fun X => { left := X.left, right := X.right, hom := F.map X.hom }) Y✝).hom =
    ((fun X => { left := X.left, right := X.right, hom := F.map X.hom }) X✝).hom ≫ (R ⋙ F).map f.right
state_after: no goals
tactic: simp only [Functor.comp_map, ← F.map_comp, f.w]
Theorem: NormedAddGroupHom.id_apply
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
⊢ ∀ (v : V), ‖(AddMonoidHom.id V) v‖ ≤ 1 * ‖v‖
state_after: no goals
tactic: simp [le_refl]
Theorem: eq_mul_of_hasProd_ite
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a : α
hf : HasProd f a
b : β
a' : α
hf' : HasProd (fun n => if n = b then 1 else f n) a'
⊢ a = a' * f b
state_after: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a : α
hf : HasProd f a
b : β
a' : α
hf' : HasProd (fun n => if n = b then 1 else f n) a'
⊢ HasProd (update f b 1) a'
tactic: refine (mul_one a).symm.trans (hf.update' b 1 ?_)
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a : α
hf : HasProd f a
b : β
a' : α
hf' : HasProd (fun n => if n = b then 1 else f n) a'
⊢ HasProd (update f b 1) a'
state_after: case h.e'_5.h
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a : α
hf : HasProd f a
b : β
a' : α
hf' : HasProd (fun n => if n = b then 1 else f n) a'
x✝ : β
⊢ update f b 1 x✝ = if x✝ = b then 1 else f x✝
tactic: convert hf'
state_before: case h.e'_5.h
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁷ : CommMonoid α✝
inst✝⁶ : TopologicalSpace α✝
f✝ g : β✝ → α✝
a✝ b✝ : α✝
s : Finset β✝
inst✝⁵ : ContinuousMul α✝
α : Type u_5
β : Type u_6
inst✝⁴ : TopologicalSpace α
inst✝³ : CommMonoid α
inst✝² : T2Space α
inst✝¹ : ContinuousMul α
inst✝ : DecidableEq β
f : β → α
a : α
hf : HasProd f a
b : β
a' : α
hf' : HasProd (fun n => if n = b then 1 else f n) a'
x✝ : β
⊢ update f b 1 x✝ = if x✝ = b then 1 else f x✝
state_after: no goals
tactic: apply update_apply
Theorem: Path.Homotopy.eval_zero
File: Mathlib/Topology/Homotopy/Path.lean

Proof steps:
state_before: X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ p₁ : Path x₀ x₁
F : p₀.Homotopy p₁
⊢ F.eval 0 = p₀
state_after: case a.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ p₁ : Path x₀ x₁
F : p₀.Homotopy p₁
t : ↑I
⊢ (F.eval 0) t = p₀ t
tactic: ext t
state_before: case a.h
X : Type u
Y : Type v
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x₀ x₁ x₂ x₃ : X
p₀ p₁ : Path x₀ x₁
F : p₀.Homotopy p₁
t : ↑I
⊢ (F.eval 0) t = p₀ t
state_after: no goals
tactic: simp [eval]
Theorem: RCLike.ofNat_mul_im
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝¹ : RCLike K
z✝ : K
n : ℕ
inst✝ : n.AtLeastTwo
z : K
⊢ im (OfNat.ofNat n * z) = OfNat.ofNat n * im z
state_after: no goals
tactic: rw [← ofReal_ofNat, im_ofReal_mul]
Theorem: suffixLevenshtein_eq_tails_map
File: Mathlib/Data/List/EditDistance/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
xs : List α
ys : List β
⊢ (suffixLevenshtein C xs ys).val = List.map (fun xs' => levenshtein C xs' ys) xs.tails
state_after: no goals
tactic: induction xs with
  | nil =>
    simp only [List.map, suffixLevenshtein_nil']
  | cons x xs ih =>
    simp only [List.map, suffixLevenshtein_cons₁, ih]
Theorem: nhdsWithin_pi_eq_bot
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝ : (i : ι) → TopologicalSpace (π i)
I : Set ι
s : (i : ι) → Set (π i)
x : (i : ι) → π i
⊢ 𝓝[I.pi s] x = ⊥ ↔ ∃ i ∈ I, 𝓝[s i] x i = ⊥
state_after: no goals
tactic: simp only [nhdsWithin, nhds_pi, pi_inf_principal_pi_eq_bot]
Theorem: Finset.subtype_univ
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : Fintype α
s t : Finset α
inst✝² : Fintype α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : Fintype { a // p a }
⊢ Finset.subtype p univ = univ
state_after: no goals
tactic: simp