ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: AddSubgroup.zsmul_mem_zmultiples_iff_exists_sub_div
File: Mathlib/Algebra/CharZero/Quotient.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p r : R
z : ℤ
hz : z ≠ 0
⊢ z • r ∈ zmultiples p ↔ ∃ k, r - ↑k • (p / ↑z) ∈ zmultiples p
state_after: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p r : R
z : ℤ
hz : z ≠ 0
⊢ (∃ k, k • p = z • r) ↔ ∃ k, r - ↑k • (p / ↑z) ∈ zmultiples p
tactic: rw [AddSubgroup.mem_zmultiples_iff]
state_before: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p r : R
z : ℤ
hz : z ≠ 0
⊢ (∃ k, k • p = z • r) ↔ ∃ k, r - ↑k • (p / ↑z) ∈ zmultiples p
state_after: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p r : R
z : ℤ
hz : z ≠ 0
⊢ (∃ k, k • p = z • r) ↔ ∃ k k_1, k_1 • p + ↑k • p * (↑z)⁻¹ = r
tactic: simp_rw [AddSubgroup.mem_zmultiples_iff, div_eq_mul_inv, ← smul_mul_assoc, eq_sub_iff_add_eq]
state_before: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p r : R
z : ℤ
hz : z ≠ 0
⊢ (∃ k, k • p = z • r) ↔ ∃ k k_1, k_1 • p + ↑k • p * (↑z)⁻¹ = r
state_after: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p r : R
z : ℤ
hz : z ≠ 0
hz' : ↑z ≠ 0
⊢ (∃ k, k • p = z • r) ↔ ∃ k k_1, k_1 • p + ↑k • p * (↑z)⁻¹ = r
tactic: have hz' : (z : R) ≠ 0 := Int.cast_ne_zero.mpr hz
state_before: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p r : R
z : ℤ
hz : z ≠ 0
hz' : ↑z ≠ 0
⊢ (∃ k, k • p = z • r) ↔ ∃ k k_1, k_1 • p + ↑k • p * (↑z)⁻¹ = r
state_after: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p r : R
z : ℤ
hz : z ≠ 0
hz' : ↑z ≠ 0
⊢ (∃ k, k • p = z • r) ↔ ∃ k k_1, ↑z * (k_1 • p + ↑k • p * (↑z)⁻¹) = ↑z * r
tactic: conv_rhs => simp (config := { singlePass := true }) only [← (mul_right_injective₀ hz').eq_iff]
state_before: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p r : R
z : ℤ
hz : z ≠ 0
hz' : ↑z ≠ 0
⊢ (∃ k, k • p = z • r) ↔ ∃ k k_1, ↑z * (k_1 • p + ↑k • p * (↑z)⁻¹) = ↑z * r
state_after: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p r : R
z : ℤ
hz : z ≠ 0
hz' : ↑z ≠ 0
⊢ (∃ k, k • p = z • r) ↔ ∃ k k_1, (z * k_1 + ↑↑k) • p = z • r
tactic: simp_rw [← zsmul_eq_mul, smul_add, ← mul_smul_comm, zsmul_eq_mul (z : R)⁻¹, mul_inv_cancel hz',
    mul_one, ← natCast_zsmul, smul_smul, ← add_smul]
state_before: R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p r : R
z : ℤ
hz : z ≠ 0
hz' : ↑z ≠ 0
⊢ (∃ k, k • p = z • r) ↔ ∃ k k_1, (z * k_1 + ↑↑k) • p = z • r
state_after: case mp
R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p r : R
z : ℤ
hz : z ≠ 0
hz' : ↑z ≠ 0
⊢ (∃ k, k • p = z • r) → ∃ k k_1, (z * k_1 + ↑↑k) • p = z • r

case mpr
R : Type u_1
inst✝¹ : DivisionRing R
inst✝ : CharZero R
p r : R
z : ℤ
hz : z ≠ 0
hz' : ↑z ≠ 0
⊢ (∃ k k_1, (z * k_1 + ↑↑k) • p = z • r) → ∃ k, k • p = z • r
tactic: constructor
Theorem: Quiver.Hom.cast_heq
File: Mathlib/Combinatorics/Quiver/Cast.lean

Proof steps:
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
e : u ⟶ v
⊢ HEq (cast hu hv e) e
state_after: U : Type u_1
inst✝ : Quiver U
u' v' : U
e : u' ⟶ v'
⊢ HEq (cast ⋯ ⋯ e) e
tactic: subst_vars
state_before: U : Type u_1
inst✝ : Quiver U
u' v' : U
e : u' ⟶ v'
⊢ HEq (cast ⋯ ⋯ e) e
state_after: no goals
tactic: rfl
Theorem: Multiset.Ico_filter_lt
File: Mathlib/Order/Interval/Multiset.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : LocallyFiniteOrder α
a✝ b✝ c✝ d a b c : α
⊢ filter (fun x => x < c) (Ico a b) = Ico a (min b c)
state_after: no goals
tactic: rw [Ico, Ico, ← Finset.filter_val, Finset.Ico_filter_lt]
Theorem: Complex.arg_ofReal_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

Proof steps:
state_before: a x✝ z : ℂ
x : ℝ
hx : 0 ≤ x
⊢ (↑x).arg = 0
state_after: no goals
tactic: simp [arg, hx]
Theorem: EulerProduct.prod_primesBelow_geometric_eq_tsum_smoothNumbers
File: Mathlib/NumberTheory/EulerProduct/Basic.lean

Proof steps:
state_before: F : Type u_1
inst✝¹ : NormedField F
inst✝ : CompleteSpace F
f : ℕ →* F
hsum : Summable ⇑f
N : ℕ
⊢ ∏ p ∈ N.primesBelow, (1 - f p)⁻¹ = ∑' (m : ↑N.smoothNumbers), f ↑m
state_after: F : Type u_1
inst✝¹ : NormedField F
inst✝ : CompleteSpace F
f : ℕ →* F
hsum : Summable ⇑f
N : ℕ
⊢ ∏ p ∈ filter (fun p => Nat.Prime p) (range N), (1 - f p)⁻¹ = ∑' (m : ↑(factoredNumbers (range N))), f ↑m
tactic: rw [smoothNumbers_eq_factoredNumbers, primesBelow]
state_before: F : Type u_1
inst✝¹ : NormedField F
inst✝ : CompleteSpace F
f : ℕ →* F
hsum : Summable ⇑f
N : ℕ
⊢ ∏ p ∈ filter (fun p => Nat.Prime p) (range N), (1 - f p)⁻¹ = ∑' (m : ↑(factoredNumbers (range N))), f ↑m
state_after: no goals
tactic: exact prod_filter_prime_geometric_eq_tsum_factoredNumbers hsum _
Theorem: Submodule.top_orthogonal_eq_bot
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
⊢ ⊤ᗮ = ⊥
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
x : E
⊢ x ∈ ⊤ᗮ ↔ x ∈ ⊥
tactic: ext x
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
x : E
⊢ x ∈ ⊤ᗮ ↔ x ∈ ⊥
state_after: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
x : E
⊢ (∀ u ∈ ⊤, ⟪u, x⟫_𝕜 = 0) ↔ x = 0
tactic: rw [mem_bot, mem_orthogonal]
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
x : E
⊢ (∀ u ∈ ⊤, ⟪u, x⟫_𝕜 = 0) ↔ x = 0
state_after: no goals
tactic: exact
    ⟨fun h => inner_self_eq_zero.mp (h x mem_top), by
      rintro rfl
      simp⟩
Theorem: Matrix.cramer_subsingleton_apply
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

Proof steps:
state_before: m : Type u
n : Type v
α : Type w
inst✝⁵ : DecidableEq n
inst✝⁴ : Fintype n
inst✝³ : DecidableEq m
inst✝² : Fintype m
inst✝¹ : CommRing α
A✝ : Matrix n n α
b✝ : n → α
inst✝ : Subsingleton n
A : Matrix n n α
b : n → α
i : n
⊢ A.cramer b i = b i
state_after: no goals
tactic: rw [cramer_apply, det_eq_elem_of_subsingleton _ i, updateColumn_self]
Theorem: AlgebraicTopology.NormalizedMooreComplex.d_squared
File: Mathlib/AlgebraicTopology/MooreComplex.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
n : ℕ
⊢ objD X (n + 1) ≫ objD X n = 0
state_after: case zero
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
⊢ (Finset.univ.inf fun k => kernelSubobject (X.δ k.succ)).factorThru
        ((Finset.univ.inf fun k => kernelSubobject (X.δ k.succ)).arrow ≫ X.δ 0) ⋯ ≫
      (Finset.univ.inf fun k => kernelSubobject (X.δ k.succ)).arrow ≫ X.δ 0 ≫ inv ⊤.arrow =
    0

case succ
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X : SimplicialObject C
n : ℕ
⊢ (Finset.univ.inf fun k => kernelSubobject (X.δ k.succ)).factorThru
        ((Finset.univ.inf fun k => kernelSubobject (X.δ k.succ)).arrow ≫ X.δ 0) ⋯ ≫
      (Finset.univ.inf fun k => kernelSubobject (X.δ k.succ)).factorThru
        ((Finset.univ.inf fun k => kernelSubobject (X.δ k.succ)).arrow ≫ X.δ 0) ⋯ =
    0
tactic: rcases n with _ | n <;> dsimp [objD]
Theorem: Cardinal.add_eq_left_iff
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: a b : Cardinal.{u_1}
⊢ a + b = a ↔ max ℵ₀ b ≤ a ∨ b = 0
state_after: a b : Cardinal.{u_1}
⊢ a + b = a ↔ ℵ₀ ≤ a ∧ b ≤ a ∨ b = 0
tactic: rw [max_le_iff]
state_before: a b : Cardinal.{u_1}
⊢ a + b = a ↔ ℵ₀ ≤ a ∧ b ≤ a ∨ b = 0
state_after: case refine_1
a b : Cardinal.{u_1}
h : a + b = a
⊢ ℵ₀ ≤ a ∧ b ≤ a ∨ b = 0

case refine_2
a b : Cardinal.{u_1}
⊢ ℵ₀ ≤ a ∧ b ≤ a ∨ b = 0 → a + b = a
tactic: refine ⟨fun h => ?_, ?_⟩
Theorem: MeasureTheory.OuterMeasure.restrict_apply
File: Mathlib/MeasureTheory/OuterMeasure/Operations.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m✝ : OuterMeasure α
s t : Set α
m : OuterMeasure α
⊢ ((restrict s) m) t = m (t ∩ s)
state_after: no goals
tactic: simp [restrict, inter_comm t]
Theorem: TopCat.pullbackIsoProdSubtype_inv_snd
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
X Y Z : TopCat
f : X ⟶ Z
g : Y ⟶ Z
⊢ (pullbackIsoProdSubtype f g).inv ≫ pullback.snd f g = pullbackSnd f g
state_after: no goals
tactic: simp [pullbackCone, pullbackIsoProdSubtype]
Theorem: StarAlgebra.adjoin_carrier
File: Mathlib/Algebra/Star/Subalgebra.lean

Proof steps:
state_before: F : Type u_1
R : Type u_2
A : Type u_3
B : Type u_4
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : Semiring A
inst✝⁶ : Algebra R A
inst✝⁵ : StarRing A
inst✝⁴ : StarModule R A
inst✝³ : Semiring B
inst✝² : Algebra R B
inst✝¹ : StarRing B
inst✝ : StarModule R B
s : Set A
a✝ : A
hx : a✝ ∈ __src✝.carrier
⊢ star a✝ ∈ __src✝.carrier
state_after: no goals
tactic: rwa [Subalgebra.mem_carrier, ← Subalgebra.mem_star_iff, Subalgebra.star_adjoin_comm,
        Set.union_star, star_star, Set.union_comm]
Theorem: Composition.index_exists
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
c : Composition n
j : ℕ
h : j < n
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length
state_after: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length
tactic: have n_pos : 0 < n := lt_of_le_of_lt (zero_le j) h
state_before: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length
state_after: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this : 0 < c.blocks.sum
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length
tactic: have : 0 < c.blocks.sum := by rwa [← c.blocks_sum] at n_pos
state_before: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this : 0 < c.blocks.sum
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length
state_after: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this : 0 < c.blocks.sum
length_pos : 0 < c.blocks.length
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length
tactic: have length_pos : 0 < c.blocks.length := length_pos_of_sum_pos (blocks c) this
state_before: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this : 0 < c.blocks.sum
length_pos : 0 < c.blocks.length
⊢ ∃ i, j < c.sizeUpTo (i + 1) ∧ i < c.length
state_after: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this : 0 < c.blocks.sum
length_pos : 0 < c.blocks.length
⊢ j < c.sizeUpTo (c.length - 1 + 1)
tactic: refine ⟨c.length - 1, ?_, Nat.pred_lt (ne_of_gt length_pos)⟩
state_before: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this : 0 < c.blocks.sum
length_pos : 0 < c.blocks.length
⊢ j < c.sizeUpTo (c.length - 1 + 1)
state_after: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this✝ : 0 < c.blocks.sum
length_pos : 0 < c.blocks.length
this : c.length - 1 + 1 = c.length
⊢ j < c.sizeUpTo (c.length - 1 + 1)
tactic: have : c.length - 1 + 1 = c.length := Nat.succ_pred_eq_of_pos length_pos
state_before: n : ℕ
c : Composition n
j : ℕ
h : j < n
n_pos : 0 < n
this✝ : 0 < c.blocks.sum
length_pos : 0 < c.blocks.length
this : c.length - 1 + 1 = c.length
⊢ j < c.sizeUpTo (c.length - 1 + 1)
state_after: no goals
tactic: simp [this, h]
Theorem: CategoryTheory.Presieve.restrict_inj
File: Mathlib/CategoryTheory/Sites/IsSheafFor.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x₁ x₂ : FamilyOfElements P (generate R).arrows
t₁ : x₁.Compatible
t₂ : x₂.Compatible
h : FamilyOfElements.restrict ⋯ x₁ = FamilyOfElements.restrict ⋯ x₂
⊢ x₁ = x₂
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x₁ x₂ : FamilyOfElements P (generate R).arrows
t₁ : x₁.Compatible
t₂ : x₂.Compatible
h : FamilyOfElements.restrict ⋯ x₁ = FamilyOfElements.restrict ⋯ x₂
⊢ (FamilyOfElements.restrict ⋯ x₁).sieveExtend = (FamilyOfElements.restrict ⋯ x₂).sieveExtend
tactic: rw [← extend_restrict t₁, ← extend_restrict t₂]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x₁ x₂ : FamilyOfElements P (generate R).arrows
t₁ : x₁.Compatible
t₂ : x₂.Compatible
h : FamilyOfElements.restrict ⋯ x₁ = FamilyOfElements.restrict ⋯ x₂
⊢ (FamilyOfElements.restrict ⋯ x₁).sieveExtend = (FamilyOfElements.restrict ⋯ x₂).sieveExtend
state_after: case h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x₁ x₂ : FamilyOfElements P (generate R).arrows
t₁ : x₁.Compatible
t₂ : x₂.Compatible
h : FamilyOfElements.restrict ⋯ x₁ = FamilyOfElements.restrict ⋯ x₂
⊢ FamilyOfElements.restrict ⋯ x₁ = FamilyOfElements.restrict ⋯ x₂
tactic: apply congr_arg
state_before: case h
C : Type u₁
inst✝ : Category.{v₁, u₁} C
P Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
x₁ x₂ : FamilyOfElements P (generate R).arrows
t₁ : x₁.Compatible
t₂ : x₂.Compatible
h : FamilyOfElements.restrict ⋯ x₁ = FamilyOfElements.restrict ⋯ x₂
⊢ FamilyOfElements.restrict ⋯ x₁ = FamilyOfElements.restrict ⋯ x₂
state_after: no goals
tactic: exact h
Theorem: LSeriesHasSum.smul
File: Mathlib/NumberTheory/LSeries/Linearity.lean

Proof steps:
state_before: f : ℕ → ℂ
c s a : ℂ
hf : LSeriesHasSum f s a
⊢ LSeriesHasSum (c • f) s (c * a)
state_after: no goals
tactic: simpa only [LSeriesHasSum, term_smul, smul_eq_mul] using hf.const_smul c
Theorem: heq_const_of_unique
File: Mathlib/Logic/Unique.lean

Proof steps:
state_before: α : Sort u_1
inst✝ : Unique α
β : α → Sort v
f : (a : α) → β a
i x✝¹ : α
x✝ : HEq i x✝¹
⊢ HEq (f i) (Function.const α (f default) x✝¹)
state_after: α : Sort u_1
inst✝ : Unique α
β : α → Sort v
f : (a : α) → β a
i x✝¹ : α
x✝ : HEq i x✝¹
⊢ HEq (f default) (Function.const α (f default) x✝¹)
tactic: rw [Subsingleton.elim i default]
state_before: α : Sort u_1
inst✝ : Unique α
β : α → Sort v
f : (a : α) → β a
i x✝¹ : α
x✝ : HEq i x✝¹
⊢ HEq (f default) (Function.const α (f default) x✝¹)
state_after: no goals
tactic: rfl
Theorem: Fin.cast_eq_cast'
File: Mathlib/Data/Fintype/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
n m : ℕ
h : Fin n = Fin m
⊢ _root_.cast h = cast ⋯
state_after: case refl
α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
h : Fin n = Fin n
⊢ _root_.cast h = cast ⋯
tactic: cases fin_injective h
state_before: case refl
α : Type u_1
β : Type u_2
γ : Type u_3
n : ℕ
h : Fin n = Fin n
⊢ _root_.cast h = cast ⋯
state_after: no goals
tactic: rfl
Theorem: Finset.map_cast_heq
File: Mathlib/Data/Finset/Image.lean

Proof steps:
state_before: α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
f : α✝ ↪ β✝
s✝ : Finset α✝
α β : Type u_4
h : α = β
s : Finset α
⊢ HEq (map (Equiv.cast h).toEmbedding s) s
state_after: α✝ : Type u_1
β : Type u_2
γ : Type u_3
f : α✝ ↪ β
s✝ : Finset α✝
α : Type u_4
s : Finset α
⊢ HEq (map (Equiv.cast ⋯).toEmbedding s) s
tactic: subst h
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
f : α✝ ↪ β
s✝ : Finset α✝
α : Type u_4
s : Finset α
⊢ HEq (map (Equiv.cast ⋯).toEmbedding s) s
state_after: no goals
tactic: simp
Theorem: Commute.orderOf_mul_eq_mul_orderOf_of_coprime
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : Commute x y
hco : (orderOf x).Coprime (orderOf y)
⊢ orderOf (x * y) = orderOf x * orderOf y
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : Commute x y
hco : (orderOf x).Coprime (orderOf y)
⊢ minimalPeriod ((fun x_1 => x * x_1) ∘ fun x => y * x) 1 = orderOf x * orderOf y
tactic: rw [orderOf, ← comp_mul_left]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : Commute x y
hco : (orderOf x).Coprime (orderOf y)
⊢ minimalPeriod ((fun x_1 => x * x_1) ∘ fun x => y * x) 1 = orderOf x * orderOf y
state_after: no goals
tactic: exact h.function_commute_mul_left.minimalPeriod_of_comp_eq_mul_of_coprime hco
Theorem: Complex.cos_three_mul
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ cos (3 * x) = 4 * cos x ^ 3 - 3 * cos x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cos (3 * x) = 4 * cos x ^ 3 - 3 * cos x
tactic: have h1 : x + 2 * x = 3 * x := by ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cos (3 * x) = 4 * cos x ^ 3 - 3 * cos x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cos x * cos (2 * x) - sin x * sin (2 * x) = 4 * cos x ^ 3 - 3 * cos x
tactic: rw [← h1, cos_add x (2 * x)]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cos x * cos (2 * x) - sin x * sin (2 * x) = 4 * cos x ^ 3 - 3 * cos x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cos x * (2 * (cos x * cos x)) - cos x - sin x * (2 * sin x * cos x) = 4 * cos x ^ 3 - 3 * cos x
tactic: simp only [cos_two_mul, sin_two_mul, mul_add, mul_sub, mul_one, sq]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cos x * (2 * (cos x * cos x)) - cos x - sin x * (2 * sin x * cos x) = 4 * cos x ^ 3 - 3 * cos x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : 4 * cos x ^ 3 = 2 * cos x * cos x * cos x + 2 * cos x * cos x ^ 2
⊢ cos x * (2 * (cos x * cos x)) - cos x - sin x * (2 * sin x * cos x) = 4 * cos x ^ 3 - 3 * cos x
tactic: have h2 : 4 * cos x ^ 3 = 2 * cos x * cos x * cos x + 2 * cos x * cos x ^ 2 := by ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : 4 * cos x ^ 3 = 2 * cos x * cos x * cos x + 2 * cos x * cos x ^ 2
⊢ cos x * (2 * (cos x * cos x)) - cos x - sin x * (2 * sin x * cos x) = 4 * cos x ^ 3 - 3 * cos x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : 4 * cos x ^ 3 = 2 * cos x * cos x * cos x + 2 * cos x * cos x ^ 2
⊢ cos x * (2 * (cos x * cos x)) - cos x - sin x * (2 * sin x * cos x) =
    2 * cos x * cos x * cos x + 2 * cos x * (1 - sin x ^ 2) - 3 * cos x
tactic: rw [h2, cos_sq']
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : 4 * cos x ^ 3 = 2 * cos x * cos x * cos x + 2 * cos x * cos x ^ 2
⊢ cos x * (2 * (cos x * cos x)) - cos x - sin x * (2 * sin x * cos x) =
    2 * cos x * cos x * cos x + 2 * cos x * (1 - sin x ^ 2) - 3 * cos x
state_after: no goals
tactic: ring
Theorem: minpoly.coeff_zero_eq_zero
File: Mathlib/FieldTheory/Minpoly/Field.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
⊢ (minpoly A x).coeff 0 = 0 ↔ x = 0
state_after: case mp
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
⊢ (minpoly A x).coeff 0 = 0 → x = 0

case mpr
A : Type u_1
B : Type u_2
inst✝³ : Field A
inst✝² : Ring B
inst✝¹ : IsDomain B
inst✝ : Algebra A B
x : B
hx : IsIntegral A x
⊢ x = 0 → (minpoly A x).coeff 0 = 0
tactic: constructor
Theorem: WittVector.wittOne_zero_eq_one
File: Mathlib/RingTheory/WittVector/Defs.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ wittOne p 0 = 1
state_after: case a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ (map (Int.castRingHom ℚ)) (wittOne p 0) = (map (Int.castRingHom ℚ)) 1
tactic: apply MvPolynomial.map_injective (Int.castRingHom ℚ) Int.cast_injective
state_before: case a
p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
⊢ (map (Int.castRingHom ℚ)) (wittOne p 0) = (map (Int.castRingHom ℚ)) 1
state_after: no goals
tactic: simp only [wittOne, wittStructureRat, xInTermsOfW_zero, map_one, bind₁_X_right,
    map_wittStructureInt]
Theorem: ENNReal.Tendsto.div_const
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a b : ℝ≥0∞
hm : Tendsto m f (𝓝 a)
ha : a ≠ 0 ∨ b ≠ 0
⊢ Tendsto (fun x => m x / b) f (𝓝 (a / b))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a b : ℝ≥0∞
hm : Tendsto m f (𝓝 a)
ha : a ≠ 0 ∨ b ≠ 0
⊢ a ≠ 0 ∨ b⁻¹ ≠ ⊤
tactic: apply Tendsto.mul_const hm
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a b : ℝ≥0∞
hm : Tendsto m f (𝓝 a)
ha : a ≠ 0 ∨ b ≠ 0
⊢ a ≠ 0 ∨ b⁻¹ ≠ ⊤
state_after: no goals
tactic: simp [ha]
Theorem: UniqueFactorizationMonoid.dvd_of_dvd_mul_right_of_no_prime_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝¹ : CancelCommMonoidWithZero R
inst✝ : UniqueFactorizationMonoid R
a b c : R
ha : a ≠ 0
no_factors : ∀ {d : R}, d ∣ a → d ∣ b → ¬Prime d
⊢ a ∣ b * c → a ∣ c
state_after: no goals
tactic: simpa [mul_comm b c] using dvd_of_dvd_mul_left_of_no_prime_factors ha @no_factors
Theorem: Set.multiset_prod_mem_multiset_prod
File: Mathlib/Data/Set/Pointwise/BigOperators.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
t : Multiset ι
f : ι → Set α
g : ι → α
hg : ∀ i ∈ t, g i ∈ f i
⊢ (Multiset.map g t).prod ∈ (Multiset.map f t).prod
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
f : ι → Set α
g : ι → α
a✝ : List ι
hg : ∀ i ∈ ⟦a✝⟧, g i ∈ f i
⊢ (Multiset.map g ⟦a✝⟧).prod ∈ (Multiset.map f ⟦a✝⟧).prod
tactic: induction t using Quotient.inductionOn
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
f : ι → Set α
g : ι → α
a✝ : List ι
hg : ∀ i ∈ ⟦a✝⟧, g i ∈ f i
⊢ (Multiset.map g ⟦a✝⟧).prod ∈ (Multiset.map f ⟦a✝⟧).prod
state_after: case h
ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
f : ι → Set α
g : ι → α
a✝ : List ι
hg : ∀ i ∈ ⟦a✝⟧, g i ∈ f i
⊢ (List.map g a✝).prod ∈ (List.map f a✝).prod
tactic: simp_rw [Multiset.quot_mk_to_coe, Multiset.map_coe, Multiset.prod_coe]
state_before: case h
ι : Type u_1
α : Type u_2
β : Type u_3
F : Type u_4
inst✝³ : FunLike F α β
inst✝² : CommMonoid α
inst✝¹ : CommMonoid β
inst✝ : MonoidHomClass F α β
f : ι → Set α
g : ι → α
a✝ : List ι
hg : ∀ i ∈ ⟦a✝⟧, g i ∈ f i
⊢ (List.map g a✝).prod ∈ (List.map f a✝).prod
state_after: no goals
tactic: exact list_prod_mem_list_prod _ _ _ hg
Theorem: PowerSeries.coeff_trunc
File: Mathlib/RingTheory/PowerSeries/Trunc.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
m n : ℕ
φ : R⟦X⟧
⊢ (trunc n φ).coeff m = if m < n then (coeff R m) φ else 0
state_after: no goals
tactic: simp [trunc, Polynomial.coeff_sum, Polynomial.coeff_monomial, Nat.lt_succ_iff]