ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Mathlib.Vector.get_set_same
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
v : Vector α n
i : Fin n
a : α
⊢ (v.set i a).get i = a
state_after: case mk
n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
i : Fin n
a : α
val✝ : List α
property✝ : val✝.length = n
⊢ (set ⟨val✝, property✝⟩ i a).get i = a
tactic: cases v
state_before: case mk
n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
i : Fin n
a : α
val✝ : List α
property✝ : val✝.length = n
⊢ (set ⟨val✝, property✝⟩ i a).get i = a
state_after: case mk.mk
n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a : α
val✝¹ : List α
property✝ : val✝¹.length = n
val✝ : ℕ
isLt✝ : val✝ < n
⊢ (set ⟨val✝¹, property✝⟩ ⟨val✝, isLt✝⟩ a).get ⟨val✝, isLt✝⟩ = a
tactic: cases i
state_before: case mk.mk
n : ℕ
α : Type u_1
β : Type u_2
γ : Type u_3
a : α
val✝¹ : List α
property✝ : val✝¹.length = n
val✝ : ℕ
isLt✝ : val✝ < n
⊢ (set ⟨val✝¹, property✝⟩ ⟨val✝, isLt✝⟩ a).get ⟨val✝, isLt✝⟩ = a
state_after: no goals
tactic: simp [Vector.set, get_eq_get]
Theorem: Matrix.vandermonde_transpose_mul_vandermonde
File: Mathlib/LinearAlgebra/Vandermonde.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
n : ℕ
v : Fin n → R
i j : Fin n
⊢ ((vandermonde v)ᵀ * vandermonde v) i j = ∑ k : Fin n, v k ^ (↑i + ↑j)
state_after: no goals
tactic: simp only [vandermonde_apply, Matrix.mul_apply, Matrix.transpose_apply, pow_add]
Theorem: Matrix.updateRow_submatrix_equiv
File: Mathlib/Data/Matrix/RowCol.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j : n
b : n → α
c : m → α
inst✝¹ : DecidableEq l
inst✝ : DecidableEq m
A : Matrix m n α
i : l
r : o → α
e : l ≃ m
f : o ≃ n
⊢ (A.submatrix ⇑e ⇑f).updateRow i r = (A.updateRow (e i) fun j => r (f.symm j)).submatrix ⇑e ⇑f
state_after: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j✝ : n
b : n → α
c : m → α
inst✝¹ : DecidableEq l
inst✝ : DecidableEq m
A : Matrix m n α
i : l
r : o → α
e : l ≃ m
f : o ≃ n
i' : l
j : o
⊢ (A.submatrix ⇑e ⇑f).updateRow i r i' j = (A.updateRow (e i) fun j => r (f.symm j)).submatrix (⇑e) (⇑f) i' j
tactic: ext i' j
state_before: case a
l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
α : Type v
β : Type w
ι : Type u_6
M : Matrix m n α
i✝ : m
j✝ : n
b : n → α
c : m → α
inst✝¹ : DecidableEq l
inst✝ : DecidableEq m
A : Matrix m n α
i : l
r : o → α
e : l ≃ m
f : o ≃ n
i' : l
j : o
⊢ (A.submatrix ⇑e ⇑f).updateRow i r i' j = (A.updateRow (e i) fun j => r (f.symm j)).submatrix (⇑e) (⇑f) i' j
state_after: no goals
tactic: simp only [submatrix_apply, updateRow_apply, Equiv.apply_eq_iff_eq, Equiv.symm_apply_apply]
Theorem: one_le_div
File: Mathlib/Algebra/Order/Field/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
hb : 0 < b
⊢ 1 ≤ a / b ↔ b ≤ a
state_after: no goals
tactic: rw [le_div_iff hb, one_mul]
Theorem: Subgroup.isComplement_univ_right
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ IsComplement S univ ↔ ∃ g, S = {g}
state_after: case refine_1
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement S univ
⊢ S.Nonempty

case refine_2
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
h : IsComplement S univ
a : G
ha : a ∈ S
b : G
hb : b ∈ S
⊢ a = b

case refine_3
G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
⊢ (∃ g, S = {g}) → IsComplement S univ
tactic: refine
    ⟨fun h => Set.exists_eq_singleton_iff_nonempty_subsingleton.mpr ⟨?_, fun a ha b hb => ?_⟩, ?_⟩
Theorem: CategoryTheory.Monad.ForgetCreatesLimits.conePoint_a
File: Mathlib/CategoryTheory/Monad/Limits.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
j : J
⊢ (T.η.app c.pt ≫ t.lift (newCone D c)) ≫ c.π.app j = 𝟙 c.pt ≫ c.π.app j
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
j : J
⊢ c.π.app j ≫ 𝟙 (D.obj j).A = 𝟙 c.pt ≫ c.π.app j
tactic: rw [Category.assoc, t.fac, newCone_π_app, ← T.η.naturality_assoc, Functor.id_map,
        (D.obj j).unit]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
j : J
⊢ c.π.app j ≫ 𝟙 (D.obj j).A = 𝟙 c.pt ≫ c.π.app j
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
j : J
⊢ (T.μ.app c.pt ≫ t.lift (newCone D c)) ≫ c.π.app j = (T.map (t.lift (newCone D c)) ≫ t.lift (newCone D c)) ≫ c.π.app j
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
j : J
⊢ (T.toFunctor ⋙ T.toFunctor).map (c.π.app j) ≫ T.map (D.obj j).a ≫ (D.obj j).a =
    T.map (T.map (c.π.app j)) ≫ T.map (D.obj j).a ≫ (D.obj j).a
tactic: rw [Category.assoc, Category.assoc, t.fac (newCone D c), newCone_π_app, ←
        Functor.map_comp_assoc, t.fac (newCone D c), newCone_π_app, ← T.μ.naturality_assoc,
        (D.obj j).assoc, Functor.map_comp, Category.assoc]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
j : J
⊢ (T.toFunctor ⋙ T.toFunctor).map (c.π.app j) ≫ T.map (D.obj j).a ≫ (D.obj j).a =
    T.map (T.map (c.π.app j)) ≫ T.map (D.obj j).a ≫ (D.obj j).a
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Limits.pullbackIsoUnopPushout_hom_inl
File: Mathlib/CategoryTheory/Limits/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPushout f.op g.op
⊢ pushout.inl f.op g.op ≫ (pullbackIsoUnopPushout f g).hom.op = (pullback.fst f g).op
state_after: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPushout f.op g.op
⊢ (pushout.inl f.op g.op ≫ (pullbackIsoUnopPushout f g).hom.op).unop = (pullback.fst f g).op.unop
tactic: apply Quiver.Hom.unop_inj
state_before: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPushout f.op g.op
⊢ (pushout.inl f.op g.op ≫ (pullbackIsoUnopPushout f g).hom.op).unop = (pullback.fst f g).op.unop
state_after: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPushout f.op g.op
⊢ (pullbackIsoUnopPushout f g).hom ≫ (pushout.inl f.op g.op).unop = pullback.fst f g
tactic: dsimp
state_before: case a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPushout f.op g.op
⊢ (pullbackIsoUnopPushout f g).hom ≫ (pushout.inl f.op g.op).unop = pullback.fst f g
state_after: no goals
tactic: rw [← pullbackIsoUnopPushout_inv_fst, Iso.hom_inv_id_assoc]
Theorem: Valuation.map_one_add_of_lt
File: Mathlib/RingTheory/Valuation/Basic.lean

Proof steps:
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v x < 1
⊢ v (1 + x) = 1
state_after: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v x < v 1
⊢ v (1 + x) = 1
tactic: rw [← v.map_one] at h
state_before: K : Type u_1
F : Type u_2
R : Type u_3
inst✝³ : DivisionRing K
Γ₀ : Type u_4
Γ'₀ : Type u_5
Γ''₀ : Type u_6
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : v x < v 1
⊢ v (1 + x) = 1
state_after: no goals
tactic: simpa only [v.map_one] using v.map_add_eq_of_lt_left h
Theorem: CategoryTheory.Functor.rightKanExtensionUniqueOfIso_hom
File: Mathlib/CategoryTheory/Functor/KanExtension/Basic.lean

Proof steps:
state_before: C : Type u_1
C' : Type u_2
H : Type u_3
H' : Type u_4
D : Type u_5
D' : Type u_6
inst✝⁷ : Category.{?u.24384, u_1} C
inst✝⁶ : Category.{?u.24388, u_2} C'
inst✝⁵ : Category.{?u.24392, u_3} H
inst✝⁴ : Category.{?u.24396, u_4} H'
inst✝³ : Category.{?u.24400, u_5} D
inst✝² : Category.{?u.24404, u_6} D'
F' : D ⥤ H
L : C ⥤ D
F : C ⥤ H
α : L ⋙ F' ⟶ F
inst✝¹ : F'.IsRightKanExtension α
G : C ⥤ H
i : F ≅ G
G' : D ⥤ H
β : L ⋙ G' ⟶ G
inst✝ : G'.IsRightKanExtension β
⊢ whiskerLeft L (G'.liftOfIsRightKanExtension β F' (α ≫ i.hom) ≫ F'.liftOfIsRightKanExtension α G' (β ≫ i.inv)) ≫ α =
    whiskerLeft L (𝟙 F') ≫ α
state_after: no goals
tactic: simp
state_before: C : Type u_1
C' : Type u_2
H : Type u_3
H' : Type u_4
D : Type u_5
D' : Type u_6
inst✝⁷ : Category.{?u.24384, u_1} C
inst✝⁶ : Category.{?u.24388, u_2} C'
inst✝⁵ : Category.{?u.24392, u_3} H
inst✝⁴ : Category.{?u.24396, u_4} H'
inst✝³ : Category.{?u.24400, u_5} D
inst✝² : Category.{?u.24404, u_6} D'
F' : D ⥤ H
L : C ⥤ D
F : C ⥤ H
α : L ⋙ F' ⟶ F
inst✝¹ : F'.IsRightKanExtension α
G : C ⥤ H
i : F ≅ G
G' : D ⥤ H
β : L ⋙ G' ⟶ G
inst✝ : G'.IsRightKanExtension β
⊢ whiskerLeft L (F'.liftOfIsRightKanExtension α G' (β ≫ i.inv) ≫ G'.liftOfIsRightKanExtension β F' (α ≫ i.hom)) ≫ β =
    whiskerLeft L (𝟙 G') ≫ β
state_after: no goals
tactic: simp
Theorem: CategoryTheory.IsHomLift.lift_eqToHom_comp_iff
File: Mathlib/CategoryTheory/FiberedCategory/HomLift.lean

Proof steps:
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R' R S : 𝒮
a b : 𝒳
f : R ⟶ S
φ : a ⟶ b
h : R' = R
hφ' : p.IsHomLift (eqToHom h ≫ f) φ
⊢ p.IsHomLift f φ
state_after: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R' S : 𝒮
a b : 𝒳
φ : a ⟶ b
f : R' ⟶ S
hφ' : p.IsHomLift (eqToHom ⋯ ≫ f) φ
⊢ p.IsHomLift f φ
tactic: subst h
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R' S : 𝒮
a b : 𝒳
φ : a ⟶ b
f : R' ⟶ S
hφ' : p.IsHomLift (eqToHom ⋯ ≫ f) φ
⊢ p.IsHomLift f φ
state_after: no goals
tactic: simpa using hφ'
Theorem: FractionalIdeal.mem_div_iff_of_nonzero
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

Proof steps:
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝ : IsDomain R₁
I✝ J✝ I J : FractionalIdeal R₁⁰ K
h : J ≠ 0
x : K
⊢ x ∈ I / J ↔ ∀ y ∈ J, x * y ∈ I
state_after: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝ : IsDomain R₁
I✝ J✝ I J : FractionalIdeal R₁⁰ K
h : J ≠ 0
x : K
⊢ x ∈ ⟨↑I / ↑J, ⋯⟩ ↔ ∀ y ∈ J, x * y ∈ I
tactic: rw [div_nonzero h]
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝³ : CommRing R₁
K : Type u_4
inst✝² : Field K
inst✝¹ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝ : IsDomain R₁
I✝ J✝ I J : FractionalIdeal R₁⁰ K
h : J ≠ 0
x : K
⊢ x ∈ ⟨↑I / ↑J, ⋯⟩ ↔ ∀ y ∈ J, x * y ∈ I
state_after: no goals
tactic: exact Submodule.mem_div_iff_forall_mul_mem
Theorem: exists_of_schnirelmannDensity_eq_zero
File: Mathlib/Combinatorics/Schnirelmann.lean

Proof steps:
state_before: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
ε : ℝ
hε : 0 < ε
hA : schnirelmannDensity A = 0
⊢ ∃ n, 0 < n ∧ ↑(filter (fun x => x ∈ A) (Ioc 0 n)).card / ↑n < ε
state_after: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
ε : ℝ
hε : 0 < ε
hA : schnirelmannDensity A = 0
h : ∀ (n : ℕ), 0 < n → ε ≤ ↑(filter (fun x => x ∈ A) (Ioc 0 n)).card / ↑n
⊢ False
tactic: by_contra! h
state_before: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
ε : ℝ
hε : 0 < ε
hA : schnirelmannDensity A = 0
h : ∀ (n : ℕ), 0 < n → ε ≤ ↑(filter (fun x => x ∈ A) (Ioc 0 n)).card / ↑n
⊢ False
state_after: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
ε : ℝ
hε : 0 < ε
hA : schnirelmannDensity A = 0
h : ε ≤ schnirelmannDensity A
⊢ False
tactic: rw [← le_schnirelmannDensity_iff] at h
state_before: A : Set ℕ
inst✝ : DecidablePred fun x => x ∈ A
ε : ℝ
hε : 0 < ε
hA : schnirelmannDensity A = 0
h : ε ≤ schnirelmannDensity A
⊢ False
state_after: no goals
tactic: linarith
Theorem: le_comap_range_lTensor
File: Mathlib/LinearAlgebra/TensorProduct/RightExactness.lean

Proof steps:
state_before: R : Type u_1
inst✝⁸ : CommSemiring R
M : Type u_2
N : Type u_3
P : Type u_4
Q : Type u_5
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid N
inst✝⁵ : AddCommMonoid P
inst✝⁴ : AddCommMonoid Q
inst✝³ : Module R M
inst✝² : Module R N
inst✝¹ : Module R P
inst✝ : Module R Q
f : M →ₗ[R] N
g : N →ₗ[R] P
q : Q
⊢ range g ≤ Submodule.comap ((TensorProduct.mk R Q P) q) (range (lTensor Q g))
state_after: case intro
R : Type u_1
inst✝⁸ : CommSemiring R
M : Type u_2
N : Type u_3
P : Type u_4
Q : Type u_5
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid N
inst✝⁵ : AddCommMonoid P
inst✝⁴ : AddCommMonoid Q
inst✝³ : Module R M
inst✝² : Module R N
inst✝¹ : Module R P
inst✝ : Module R Q
f : M →ₗ[R] N
g : N →ₗ[R] P
q : Q
n : N
⊢ g n ∈ Submodule.comap ((TensorProduct.mk R Q P) q) (range (lTensor Q g))
tactic: rintro x ⟨n, rfl⟩
state_before: case intro
R : Type u_1
inst✝⁸ : CommSemiring R
M : Type u_2
N : Type u_3
P : Type u_4
Q : Type u_5
inst✝⁷ : AddCommMonoid M
inst✝⁶ : AddCommMonoid N
inst✝⁵ : AddCommMonoid P
inst✝⁴ : AddCommMonoid Q
inst✝³ : Module R M
inst✝² : Module R N
inst✝¹ : Module R P
inst✝ : Module R Q
f : M →ₗ[R] N
g : N →ₗ[R] P
q : Q
n : N
⊢ g n ∈ Submodule.comap ((TensorProduct.mk R Q P) q) (range (lTensor Q g))
state_after: no goals
tactic: exact ⟨q ⊗ₜ[R] n, rfl⟩
Theorem: MvPolynomial.eval₂_C_mk_eq_zero
File: Mathlib/RingTheory/Polynomial/Quotient.lean

Proof steps:
state_before: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
a : MvPolynomial σ R
ha : a ∈ Ideal.map C I
⊢ (eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) a = 0
state_after: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
a : MvPolynomial σ R
ha : a ∈ Ideal.map C I
⊢ (eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) (∑ v ∈ a.support, (monomial v) (coeff v a)) = 0
tactic: rw [as_sum a]
state_before: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
a : MvPolynomial σ R
ha : a ∈ Ideal.map C I
⊢ (eval₂Hom (C.comp (Ideal.Quotient.mk I)) X) (∑ v ∈ a.support, (monomial v) (coeff v a)) = 0
state_after: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
a : MvPolynomial σ R
ha : a ∈ Ideal.map C I
⊢ ∑ x ∈ a.support, eval₂ (C.comp (Ideal.Quotient.mk I)) X ((monomial x) (coeff x a)) = 0
tactic: rw [coe_eval₂Hom, eval₂_sum]
state_before: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
a : MvPolynomial σ R
ha : a ∈ Ideal.map C I
⊢ ∑ x ∈ a.support, eval₂ (C.comp (Ideal.Quotient.mk I)) X ((monomial x) (coeff x a)) = 0
state_after: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
a : MvPolynomial σ R
ha : a ∈ Ideal.map C I
n : σ →₀ ℕ
x✝ : n ∈ a.support
⊢ eval₂ (C.comp (Ideal.Quotient.mk I)) X ((monomial n) (coeff n a)) = 0
tactic: refine Finset.sum_eq_zero fun n _ => ?_
state_before: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
a : MvPolynomial σ R
ha : a ∈ Ideal.map C I
n : σ →₀ ℕ
x✝ : n ∈ a.support
⊢ eval₂ (C.comp (Ideal.Quotient.mk I)) X ((monomial n) (coeff n a)) = 0
state_after: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
a : MvPolynomial σ R
ha : a ∈ Ideal.map C I
n : σ →₀ ℕ
x✝ : n ∈ a.support
⊢ (C ((Ideal.Quotient.mk I) (coeff n a)) * n.prod fun n e => X n ^ e) = 0
tactic: simp only [eval₂_monomial, Function.comp_apply, RingHom.coe_comp]
state_before: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
a : MvPolynomial σ R
ha : a ∈ Ideal.map C I
n : σ →₀ ℕ
x✝ : n ∈ a.support
⊢ (C ((Ideal.Quotient.mk I) (coeff n a)) * n.prod fun n e => X n ^ e) = 0
state_after: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
a : MvPolynomial σ R
ha : a ∈ Ideal.map C I
n : σ →₀ ℕ
x✝ : n ∈ a.support
⊢ C ((Ideal.Quotient.mk I) (coeff n a)) = 0
tactic: refine mul_eq_zero_of_left ?_ _
state_before: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
a : MvPolynomial σ R
ha : a ∈ Ideal.map C I
n : σ →₀ ℕ
x✝ : n ∈ a.support
⊢ C ((Ideal.Quotient.mk I) (coeff n a)) = 0
state_after: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
a : MvPolynomial σ R
ha : a ∈ Ideal.map C I
n : σ →₀ ℕ
x✝ : n ∈ a.support
⊢ coeff n a ∈ I
tactic: suffices coeff n a ∈ I by
    rw [← @Ideal.mk_ker R _ I, RingHom.mem_ker] at this
    simp only [this, C_0]
state_before: R : Type u_1
σ : Type u_2
inst✝ : CommRing R
r : R
I : Ideal R
a : MvPolynomial σ R
ha : a ∈ Ideal.map C I
n : σ →₀ ℕ
x✝ : n ∈ a.support
⊢ coeff n a ∈ I
state_after: no goals
tactic: exact mem_map_C_iff.1 ha n
Theorem: Polynomial.eval_smul'
File: Mathlib/Algebra/Polynomial/GroupRingAction.lean

Proof steps:
state_before: M : Type u_1
inst✝⁶ : Monoid M
R : Type u_2
inst✝⁵ : Semiring R
inst✝⁴ : MulSemiringAction M R
S : Type u_3
inst✝³ : CommSemiring S
inst✝² : MulSemiringAction M S
G : Type u_4
inst✝¹ : Group G
inst✝ : MulSemiringAction G S
g : G
f : S[X]
x : S
⊢ eval (g • x) f = g • eval x (g⁻¹ • f)
state_after: no goals
tactic: rw [← smul_eval_smul, smul_inv_smul]
Theorem: ZNum.abs_to_nat
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
p : PosNum
⊢ (↑↑p).natAbs = (-↑p).natAbs
state_after: no goals
tactic: rw [p.to_nat_to_int, Int.natAbs_neg]
Theorem: NumberField.InfinitePlace.isReal_or_isComplex
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝² : Field k
K : Type u_2
inst✝¹ : Field K
F : Type u_3
inst✝ : Field F
w : InfinitePlace K
⊢ w.IsReal ∨ w.IsComplex
state_after: k : Type u_1
inst✝² : Field k
K : Type u_2
inst✝¹ : Field K
F : Type u_3
inst✝ : Field F
w : InfinitePlace K
⊢ w.IsReal ∨ ¬w.IsReal
tactic: rw [← not_isReal_iff_isComplex]
state_before: k : Type u_1
inst✝² : Field k
K : Type u_2
inst✝¹ : Field K
F : Type u_3
inst✝ : Field F
w : InfinitePlace K
⊢ w.IsReal ∨ ¬w.IsReal
state_after: no goals
tactic: exact em _
Theorem: midpoint_self_neg
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y z : P
x : V
⊢ midpoint R x (-x) = 0
state_after: no goals
tactic: rw [midpoint_eq_smul_add, add_neg_self, smul_zero]
Theorem: divp_eq_iff_mul_eq
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a b c x : α
u : αˣ
y : α
⊢ x /ₚ u * ↑u = y * ↑u ↔ y * ↑u = x
state_after: α : Type u
inst✝ : Monoid α
a b c x : α
u : αˣ
y : α
⊢ x = y * ↑u ↔ y * ↑u = x
tactic: rw [divp_mul_cancel]
state_before: α : Type u
inst✝ : Monoid α
a b c x : α
u : αˣ
y : α
⊢ x = y * ↑u ↔ y * ↑u = x
state_after: no goals
tactic: exact ⟨Eq.symm, Eq.symm⟩
Theorem: ENNReal.mul_rpow_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 ≤ z
⊢ (x * y) ^ z = x ^ z * y ^ z
state_after: no goals
tactic: simp [hz.not_lt, mul_rpow_eq_ite]
Theorem: Set.einfsep_insert_le
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
⊢ (insert x s).einfsep ≤ ⨅ y ∈ s, ⨅ (_ : x ≠ y), edist x y
state_after: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
⊢ ∀ i ∈ s, x ≠ i → (insert x s).einfsep ≤ edist x i
tactic: simp_rw [le_iInf_iff]
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
⊢ ∀ i ∈ s, x ≠ i → (insert x s).einfsep ≤ edist x i
state_after: no goals
tactic: exact fun _ hy hxy => einfsep_le_edist_of_mem (mem_insert _ _) (mem_insert_of_mem _ hy) hxy
Theorem: CategoryTheory.biconeCategoryStruct_id
File: Mathlib/CategoryTheory/Limits/Bicones.lean

Proof steps:
state_before: J : Type u₁
inst✝ : Category.{v₁, u₁} J
X✝ Y✝ Z✝ : Bicone J
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ X✝ ⟶ Z✝
state_after: case left_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
g : Bicone.left ⟶ Z✝
⊢ Bicone.left ⟶ Z✝

case right_id
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
g : Bicone.right ⟶ Z✝
⊢ Bicone.right ⟶ Z✝

case left
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
j✝ : J
g : Bicone.diagram j✝ ⟶ Z✝
⊢ Bicone.left ⟶ Z✝

case right
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
j✝ : J
g : Bicone.diagram j✝ ⟶ Z✝
⊢ Bicone.right ⟶ Z✝

case diagram
J : Type u₁
inst✝ : Category.{v₁, u₁} J
Z✝ : Bicone J
j✝ k✝ : J
f : j✝ ⟶ k✝
g : Bicone.diagram k✝ ⟶ Z✝
⊢ Bicone.diagram j✝ ⟶ Z✝
tactic: rcases f with (_ | _ | _ | _ | f)
Theorem: Real.sInf_nonpos
File: Mathlib/Data/Real/Archimedean.lean

Proof steps:
state_before: S : Set ℝ
hS : ∀ x ∈ S, x ≤ 0
⊢ sInf S ≤ 0
state_after: case inl
hS : ∀ x ∈ ∅, x ≤ 0
⊢ sInf ∅ ≤ 0

case inr.intro
S : Set ℝ
hS : ∀ x ∈ S, x ≤ 0
y : ℝ
hy : y ∈ S
⊢ sInf S ≤ 0
tactic: rcases S.eq_empty_or_nonempty with (rfl | ⟨y, hy⟩)
Theorem: Filter.image_mem_map_iff
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
m : α → β
m' : β → γ
s : Set α
t : Set β
hf : Injective m
h : m '' s ∈ map m f
⊢ s ∈ f
state_after: no goals
tactic: rwa [← preimage_image_eq s hf]
Theorem: CanonicallyOrderedCommSemiring.list_prod_pos
File: Mathlib/Algebra/Order/BigOperators/Ring/List.lean

Proof steps:
state_before: R : Type u_1
α : Type u_2
inst✝¹ : CanonicallyOrderedCommSemiring α
inst✝ : Nontrivial α
⊢ 0 < [].prod ↔ ∀ x ∈ [], 0 < x
state_after: no goals
tactic: simp
state_before: R : Type u_1
α : Type u_2
inst✝¹ : CanonicallyOrderedCommSemiring α
inst✝ : Nontrivial α
x : α
xs : List α
⊢ 0 < (x :: xs).prod ↔ ∀ x_1 ∈ x :: xs, 0 < x_1
state_after: no goals
tactic: simp_rw [prod_cons, forall_mem_cons, CanonicallyOrderedCommSemiring.mul_pos,
    list_prod_pos]
Theorem: EReal.inv_nonneg_of_nonneg
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: a : EReal
h : 0 ≤ a
⊢ 0 ≤ a⁻¹
state_after: no goals
tactic: induction a with
  | h_bot | h_top => simp
  | h_real a => rw [← coe_inv a, EReal.coe_nonneg, inv_nonneg]; exact EReal.coe_nonneg.1 h
Theorem: CategoryTheory.Limits.diagramIsoSpan_inv_app
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
j : WalkingSpan
⊢ F.obj j = (span (F.map fst) (F.map snd)).obj j
state_after: no goals
tactic: rcases j with (⟨⟩ | ⟨⟨⟩⟩) <;> rfl
state_before: C : Type u
inst✝ : Category.{v, u} C
F : WalkingSpan ⥤ C
⊢ ∀ {X Y : WalkingSpan} (f : X ⟶ Y),
    F.map f ≫ ((fun j => eqToIso ⋯) Y).hom = ((fun j => eqToIso ⋯) X).hom ≫ (span (F.map fst) (F.map snd)).map f
state_after: no goals
tactic: rintro (⟨⟩ | ⟨⟨⟩⟩) (⟨⟩ | ⟨⟨⟩⟩) f <;> cases f <;> dsimp <;> simp