ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: isClosedMap_smul_left
File: Mathlib/Topology/Algebra/Module/FiniteDimension.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : CompleteSpace 𝕜
inst✝¹¹ : AddCommGroup E
inst✝¹⁰ : TopologicalSpace E
inst✝⁹ : T2Space E
inst✝⁸ : TopologicalAddGroup E
inst✝⁷ : Module 𝕜 E
inst✝⁶ : ContinuousSMul 𝕜 E
inst✝⁵ : AddCommGroup F
inst✝⁴ : TopologicalSpace F
inst✝³ : T2Space F
inst✝² : TopologicalAddGroup F
inst✝¹ : Module 𝕜 F
inst✝ : ContinuousSMul 𝕜 F
c : E
⊢ IsClosedMap fun x => x • c
state_after: case pos
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : CompleteSpace 𝕜
inst✝¹¹ : AddCommGroup E
inst✝¹⁰ : TopologicalSpace E
inst✝⁹ : T2Space E
inst✝⁸ : TopologicalAddGroup E
inst✝⁷ : Module 𝕜 E
inst✝⁶ : ContinuousSMul 𝕜 E
inst✝⁵ : AddCommGroup F
inst✝⁴ : TopologicalSpace F
inst✝³ : T2Space F
inst✝² : TopologicalAddGroup F
inst✝¹ : Module 𝕜 F
inst✝ : ContinuousSMul 𝕜 F
c : E
hc : c = 0
⊢ IsClosedMap fun x => x • c

case neg
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝¹³ : NontriviallyNormedField 𝕜
inst✝¹² : CompleteSpace 𝕜
inst✝¹¹ : AddCommGroup E
inst✝¹⁰ : TopologicalSpace E
inst✝⁹ : T2Space E
inst✝⁸ : TopologicalAddGroup E
inst✝⁷ : Module 𝕜 E
inst✝⁶ : ContinuousSMul 𝕜 E
inst✝⁵ : AddCommGroup F
inst✝⁴ : TopologicalSpace F
inst✝³ : T2Space F
inst✝² : TopologicalAddGroup F
inst✝¹ : Module 𝕜 F
inst✝ : ContinuousSMul 𝕜 F
c : E
hc : ¬c = 0
⊢ IsClosedMap fun x => x • c
tactic: by_cases hc : c = 0
Theorem: Mathlib.Tactic.RingNF.nat_rawCast_0
File: Mathlib/Tactic/Ring/RingNF.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommSemiring R
n d : ℕ
⊢ Nat.rawCast 0 = 0
state_after: no goals
tactic: simp
Theorem: Nat.Partrec.Code.encode_lt_prec
File: Mathlib/Computability/PartrecCode.lean

Proof steps:
state_before: cf cg : Code
⊢ encode cf < encode (cf.prec cg) ∧ encode cg < encode (cf.prec cg)
state_after: cf cg : Code
this : encode (cf.pair cg) < encode (cf.prec cg)
⊢ encode cf < encode (cf.prec cg) ∧ encode cg < encode (cf.prec cg)
tactic: have : encode (pair cf cg) < encode (prec cf cg) := by simp [encodeCode_eq, encodeCode]
state_before: cf cg : Code
this : encode (cf.pair cg) < encode (cf.prec cg)
⊢ encode cf < encode (cf.prec cg) ∧ encode cg < encode (cf.prec cg)
state_after: no goals
tactic: exact (encode_lt_pair cf cg).imp (fun h => lt_trans h this) fun h => lt_trans h this
Theorem: CategoryTheory.Idempotents.Karoubi.hom_ext
File: Mathlib/CategoryTheory/Idempotents/Karoubi.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
P Q : Karoubi C
f g : P ⟶ Q
h : f.f = g.f
⊢ f = g
state_after: no goals
tactic: simpa [hom_ext_iff] using h
Theorem: IsOfFinAddOrder.addOrderOf_nsmul
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 : IsOfFinOrder x
⊢ orderOf (x ^ n) = orderOf x / (orderOf x).gcd n
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 : IsOfFinOrder x
⊢ minimalPeriod (fun x_1 => x ^ n * x_1) 1 =
    minimalPeriod (fun x_1 => x * x_1) 1 / (minimalPeriod (fun x_1 => x * x_1) 1).gcd n
tactic: unfold orderOf
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 : IsOfFinOrder x
⊢ minimalPeriod (fun x_1 => x ^ n * x_1) 1 =
    minimalPeriod (fun x_1 => x * x_1) 1 / (minimalPeriod (fun x_1 => x * x_1) 1).gcd n
state_after: no goals
tactic: rw [← minimalPeriod_iterate_eq_div_gcd' h, mul_left_iterate]
Theorem: Nat.fermatPsp_base_one
File: Mathlib/NumberTheory/FermatPsp.lean

Proof steps:
state_before: n : ℕ
h₁ : 1 < n
h₂ : ¬Prime n
⊢ n.FermatPsp 1
state_after: n : ℕ
h₁ : 1 < n
h₂ : ¬Prime n
⊢ n ∣ 1 ^ (n - 1) - 1
tactic: refine ⟨show n ∣ 1 ^ (n - 1) - 1 from ?_, h₂, h₁⟩
state_before: n : ℕ
h₁ : 1 < n
h₂ : ¬Prime n
⊢ n ∣ 1 ^ (n - 1) - 1
state_after: no goals
tactic: exact show 0 = 1 ^ (n - 1) - 1 by norm_num ▸ dvd_zero n
Theorem: CategoryTheory.Limits.map_inl_inv_coprodComparison
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

Proof steps:
state_before: C : Type u
inst✝⁶ : Category.{v, u} C
X Y : C
D : Type u₂
inst✝⁵ : Category.{w, u₂} D
F : C ⥤ D
A A' B B' : C
inst✝⁴ : HasBinaryCoproduct A B
inst✝³ : HasBinaryCoproduct A' B'
inst✝² : HasBinaryCoproduct (F.obj A) (F.obj B)
inst✝¹ : HasBinaryCoproduct (F.obj A') (F.obj B')
inst✝ : IsIso (coprodComparison F A B)
⊢ F.map coprod.inl ≫ inv (coprodComparison F A B) = coprod.inl
state_after: no goals
tactic: simp [IsIso.inv_comp_eq]
Theorem: Matrix.det_eq_sign_charpoly_coeff
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean

Proof steps:
state_before: R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M✝ M : Matrix n n R
⊢ M.det = (-1) ^ Fintype.card n * M.charpoly.coeff 0
state_after: R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M✝ M : Matrix n n R
⊢ M.det = (-1 • eval ((scalar n) 0) (X - C M)).det
tactic: rw [coeff_zero_eq_eval_zero, charpoly, eval_det, matPolyEquiv_charmatrix, ← det_smul]
state_before: R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M✝ M : Matrix n n R
⊢ M.det = (-1 • eval ((scalar n) 0) (X - C M)).det
state_after: no goals
tactic: simp
Theorem: Pretrivialization.symm_proj_apply
File: Mathlib/Topology/FiberBundle/Trivialization.lean

Proof steps:
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e' : Pretrivialization F TotalSpace.proj
x' : TotalSpace F E
b : B
y : E b
inst✝ : (x : B) → Zero (E x)
e : Pretrivialization F TotalSpace.proj
z : TotalSpace F E
hz : z.proj ∈ e.baseSet
⊢ e.symm z.proj (↑e z).2 = z.snd
state_after: no goals
tactic: rw [e.symm_apply hz, cast_eq_iff_heq, e.mk_proj_snd' hz, e.symm_apply_apply (e.mem_source.mpr hz)]
Theorem: LieSubmodule.lie_top_eq_of_span_sup_eq_top
File: Mathlib/Algebra/Lie/Engel.lean

Proof steps:
state_before: R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
I : LieIdeal R L
x : L
hxI : Submodule.span R {x} ⊔ (lieIdealSubalgebra R L I).toSubmodule = ⊤
N : LieSubmodule R L M
⊢ ↑⁅⊤, N⁆ = Submodule.map ((toEnd R L M) x) ↑N ⊔ ↑⁅I, N⁆
state_after: R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
I : LieIdeal R L
x : L
hxI : Submodule.span R {x} ⊔ (lieIdealSubalgebra R L I).toSubmodule = ⊤
N : LieSubmodule R L M
⊢ Submodule.span R {m | ∃ x, ∃ n ∈ N, ⁅x, n⁆ = m} =
    Submodule.span R ((fun a => ⁅x, a⁆) '' ↑↑N ∪ {m | ∃ x ∈ I, ∃ n ∈ N, ⁅x, n⁆ = m})
tactic: simp only [lieIdeal_oper_eq_linear_span', Submodule.sup_span, mem_top, exists_prop,
    true_and, Submodule.map_coe, toEnd_apply_apply]
state_before: R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
I : LieIdeal R L
x : L
hxI : Submodule.span R {x} ⊔ (lieIdealSubalgebra R L I).toSubmodule = ⊤
N : LieSubmodule R L M
⊢ Submodule.span R {m | ∃ x, ∃ n ∈ N, ⁅x, n⁆ = m} =
    Submodule.span R ((fun a => ⁅x, a⁆) '' ↑↑N ∪ {m | ∃ x ∈ I, ∃ n ∈ N, ⁅x, n⁆ = m})
state_after: case refine_1
R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
I : LieIdeal R L
x : L
hxI : Submodule.span R {x} ⊔ (lieIdealSubalgebra R L I).toSubmodule = ⊤
N : LieSubmodule R L M
⊢ {m | ∃ x, ∃ n ∈ N, ⁅x, n⁆ = m} ⊆ ↑(Submodule.span R ((fun a => ⁅x, a⁆) '' ↑↑N ∪ {m | ∃ x ∈ I, ∃ n ∈ N, ⁅x, n⁆ = m}))

case refine_2
R : Type u₁
L : Type u₂
L₂ : Type u₃
M : Type u₄
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieRing L₂
inst✝⁴ : LieAlgebra R L₂
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
I : LieIdeal R L
x : L
hxI : Submodule.span R {x} ⊔ (lieIdealSubalgebra R L I).toSubmodule = ⊤
N : LieSubmodule R L M
z : M
hz : z ∈ (fun a => ⁅x, a⁆) '' ↑↑N ∪ {m | ∃ x ∈ I, ∃ n ∈ N, ⁅x, n⁆ = m}
⊢ z ∈ {m | ∃ x, ∃ n ∈ N, ⁅x, n⁆ = m}
tactic: refine le_antisymm (Submodule.span_le.mpr ?_) (Submodule.span_mono fun z hz => ?_)
Theorem: Nat.totient_super_multiplicative
File: Mathlib/Data/Nat/Totient.lean

Proof steps:
state_before: a b : ℕ
⊢ φ a * φ b ≤ φ (a * b)
state_after: a b : ℕ
d : ℕ := a.gcd b
⊢ φ a * φ b ≤ φ (a * b)
tactic: let d := a.gcd b
state_before: a b : ℕ
d : ℕ := a.gcd b
⊢ φ a * φ b ≤ φ (a * b)
state_after: case inl
b : ℕ
d : ℕ := gcd 0 b
⊢ φ 0 * φ b ≤ φ (0 * b)

case inr
a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
⊢ φ a * φ b ≤ φ (a * b)
tactic: rcases (zero_le a).eq_or_lt with (rfl | ha0)
state_before: case inr
a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
⊢ φ a * φ b ≤ φ (a * b)
state_after: case inr
a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
hd0 : 0 < d
⊢ φ a * φ b ≤ φ (a * b)
tactic: have hd0 : 0 < d := Nat.gcd_pos_of_pos_left _ ha0
state_before: case inr
a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
hd0 : 0 < d
⊢ φ a * φ b ≤ φ (a * b)
state_after: a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
hd0 : 0 < d
⊢ φ a * φ b * d ≤ φ (a * b) * d
tactic: apply le_of_mul_le_mul_right _ hd0
state_before: a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
hd0 : 0 < d
⊢ φ a * φ b * d ≤ φ (a * b) * d
state_after: a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
hd0 : 0 < d
⊢ φ (a * b) * φ (a.gcd b) ≤ φ (a * b) * d
tactic: rw [← totient_gcd_mul_totient_mul a b, mul_comm]
state_before: a b : ℕ
d : ℕ := a.gcd b
ha0 : 0 < a
hd0 : 0 < d
⊢ φ (a * b) * φ (a.gcd b) ≤ φ (a * b) * d
state_after: no goals
tactic: apply mul_le_mul_left' (Nat.totient_le d)
Theorem: Real.Angle.tan_eq_of_two_zsmul_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ ψ : Angle
h : 2 • θ = 2 • ψ
⊢ θ.tan = ψ.tan
state_after: no goals
tactic: exact tan_eq_of_two_nsmul_eq h
Theorem: List.tail_eq_tail?
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
l : List α
⊢ l.tail = l.tail?.getD []
state_after: no goals
tactic: simp [tail_eq_tailD]
Theorem: Real.negMulLog_mul
File: Mathlib/Analysis/SpecialFunctions/Log/NegMulLog.lean

Proof steps:
state_before: x y : ℝ
⊢ (x * y).negMulLog = y * x.negMulLog + x * y.negMulLog
state_after: x y : ℝ
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)
tactic: simp only [negMulLog, neg_mul, neg_add_rev]
state_before: x y : ℝ
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)
state_after: case pos
x y : ℝ
hx : x = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)

case neg
x y : ℝ
hx : ¬x = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)
tactic: by_cases hx : x = 0
state_before: case neg
x y : ℝ
hx : ¬x = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)
state_after: case pos
x y : ℝ
hx : ¬x = 0
hy : y = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)

case neg
x y : ℝ
hx : ¬x = 0
hy : ¬y = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)
tactic: by_cases hy : y = 0
state_before: case neg
x y : ℝ
hx : ¬x = 0
hy : ¬y = 0
⊢ -(x * y * log (x * y)) = y * -(x * log x) + x * -(y * log y)
state_after: case neg
x y : ℝ
hx : ¬x = 0
hy : ¬y = 0
⊢ -(x * y * (log x + log y)) = y * -(x * log x) + x * -(y * log y)
tactic: rw [log_mul hx hy]
state_before: case neg
x y : ℝ
hx : ¬x = 0
hy : ¬y = 0
⊢ -(x * y * (log x + log y)) = y * -(x * log x) + x * -(y * log y)
state_after: no goals
tactic: ring
Theorem: Basis.constr_apply_fintype
File: Mathlib/LinearAlgebra/Basis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
R₂ : Type u_4
K : Type u_5
M : Type u_6
M' : Type u_7
M'' : Type u_8
V : Type u
V' : Type u_9
inst✝⁸ : Semiring R
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : Module R M'
S : Type u_10
inst✝³ : Semiring S
inst✝² : Module S M'
inst✝¹ : SMulCommClass R S M'
inst✝ : Fintype ι
b : Basis ι R M
f : ι → M'
x : M
⊢ ((b.constr S) f) x = ∑ i : ι, b.equivFun x i • f i
state_after: no goals
tactic: simp [b.constr_apply, b.equivFun_apply, Finsupp.sum_fintype]
Theorem: Monoid.Coprod.comp_lift
File: Mathlib/GroupTheory/Coprod/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : Monoid P
P' : Type u_4
inst✝ : Monoid P'
f : P →* P'
g₁ : M →* P
g₂ : N →* P
⊢ (f.comp (lift g₁ g₂)).comp inl = (lift (f.comp g₁) (f.comp g₂)).comp inl
state_after: no goals
tactic: rw [MonoidHom.comp_assoc, lift_comp_inl, lift_comp_inl]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : Monoid P
P' : Type u_4
inst✝ : Monoid P'
f : P →* P'
g₁ : M →* P
g₂ : N →* P
⊢ (f.comp (lift g₁ g₂)).comp inr = (lift (f.comp g₁) (f.comp g₂)).comp inr
state_after: no goals
tactic: rw [MonoidHom.comp_assoc, lift_comp_inr, lift_comp_inr]
Theorem: AddChar.compAddMonoidHom_injective_right
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
ψ : AddChar B M
hψ : Injective ⇑ψ
⊢ Injective fun f => ψ.compAddMonoidHom f
state_after: 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
ψ : AddChar B M
hψ : Injective ⇑ψ
f g : A →+ B
h : (fun f => ψ.compAddMonoidHom f) f = (fun f => ψ.compAddMonoidHom f) g
⊢ f = g
tactic: rintro f g h
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
ψ : AddChar B M
hψ : Injective ⇑ψ
f g : A →+ B
h : (fun f => ψ.compAddMonoidHom f) f = (fun f => ψ.compAddMonoidHom f) g
⊢ f = g
state_after: 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
ψ : AddChar B M
hψ : Injective ⇑ψ
f g : A →+ B
h : ⇑((fun f => ψ.compAddMonoidHom f) f) = ⇑((fun f => ψ.compAddMonoidHom f) g)
⊢ ⇑f = ⇑g
tactic: rw [DFunLike.ext'_iff] at h ⊢
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
ψ : AddChar B M
hψ : Injective ⇑ψ
f g : A →+ B
h : ⇑((fun f => ψ.compAddMonoidHom f) f) = ⇑((fun f => ψ.compAddMonoidHom f) g)
⊢ ⇑f = ⇑g
state_after: no goals
tactic: exact hψ.comp_left h
Theorem: Polynomial.nodup_of_separable_prod
File: Mathlib/FieldTheory/Separable.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
s : Multiset R
hs : (Multiset.map (fun a => X - C a) s).prod.Separable
⊢ s.Nodup
state_after: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
s : Multiset R
hs : (Multiset.map (fun a => X - C a) s).prod.Separable
⊢ ∀ (a : R) (t : Multiset R), s ≠ a ::ₘ a ::ₘ t
tactic: rw [Multiset.nodup_iff_ne_cons_cons]
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
s : Multiset R
hs : (Multiset.map (fun a => X - C a) s).prod.Separable
⊢ ∀ (a : R) (t : Multiset R), s ≠ a ::ₘ a ::ₘ t
state_after: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
a : R
t : Multiset R
hs : (Multiset.map (fun a => X - C a) (a ::ₘ a ::ₘ t)).prod.Separable
⊢ False
tactic: rintro a t rfl
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
a : R
t : Multiset R
hs : (Multiset.map (fun a => X - C a) (a ::ₘ a ::ₘ t)).prod.Separable
⊢ False
state_after: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
a : R
t : Multiset R
hs : (Multiset.map (fun a => X - C a) (a ::ₘ a ::ₘ t)).prod.Separable
⊢ (X - C a) * (X - C a) ∣ (Multiset.map (fun a => X - C a) (a ::ₘ a ::ₘ t)).prod
tactic: refine not_isUnit_X_sub_C a (isUnit_of_self_mul_dvd_separable hs ?_)
state_before: R : Type u
inst✝¹ : CommRing R
inst✝ : Nontrivial R
a : R
t : Multiset R
hs : (Multiset.map (fun a => X - C a) (a ::ₘ a ::ₘ t)).prod.Separable
⊢ (X - C a) * (X - C a) ∣ (Multiset.map (fun a => X - C a) (a ::ₘ a ::ₘ t)).prod
state_after: no goals
tactic: simpa only [Multiset.map_cons, Multiset.prod_cons] using mul_dvd_mul_left _ (dvd_mul_right _ _)
Theorem: differentiableOn_neg_iff
File: Mathlib/Analysis/Calculus/FDeriv/Add.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
h : DifferentiableOn 𝕜 (fun y => -f y) s
⊢ DifferentiableOn 𝕜 f s
state_after: no goals
tactic: simpa only [neg_neg] using h.neg
Theorem: AddMonoidAlgebra.supDegree_prod_le
File: Mathlib/Algebra/MonoidAlgebra/Degree.lean

Proof steps:
state_before: R✝ : Type u_1
R' : Type u_2
A✝ : Type u_3
T : Type u_4
B✝ : Type u_5
ι✝ : Type u_6
inst✝¹² : Semiring R✝
inst✝¹¹ : Ring R'
inst✝¹⁰ : AddZeroClass A✝
inst✝⁹ : SemilatticeSup B✝
inst✝⁸ : Add B✝
inst✝⁷ : OrderBot B✝
D✝ : A✝ → B✝
p q : R✝[A✝]
hadd✝ : ∀ (a1 a2 : A✝), D✝ (a1 + a2) = D✝ a1 + D✝ a2
R : Type u_7
A : Type u_8
B : Type u_9
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : SemilatticeSup B
inst✝² : OrderBot B
inst✝¹ : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
D : A → B
hzero : D 0 = 0
hadd : ∀ (a1 a2 : A), D (a1 + a2) = D a1 + D a2
ι : Type u_10
s : Finset ι
f : ι → R[A]
⊢ supDegree D (∏ i ∈ s, f i) ≤ ∑ i ∈ s, supDegree D (f i)
state_after: case refine_1
R✝ : Type u_1
R' : Type u_2
A✝ : Type u_3
T : Type u_4
B✝ : Type u_5
ι✝ : Type u_6
inst✝¹² : Semiring R✝
inst✝¹¹ : Ring R'
inst✝¹⁰ : AddZeroClass A✝
inst✝⁹ : SemilatticeSup B✝
inst✝⁸ : Add B✝
inst✝⁷ : OrderBot B✝
D✝ : A✝ → B✝
p q : R✝[A✝]
hadd✝ : ∀ (a1 a2 : A✝), D✝ (a1 + a2) = D✝ a1 + D✝ a2
R : Type u_7
A : Type u_8
B : Type u_9
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : SemilatticeSup B
inst✝² : OrderBot B
inst✝¹ : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
D : A → B
hzero : D 0 = 0
hadd : ∀ (a1 a2 : A), D (a1 + a2) = D a1 + D a2
ι : Type u_10
s : Finset ι
f : ι → R[A]
⊢ supDegree D (∏ i ∈ ∅, f i) ≤ ∑ i ∈ ∅, supDegree D (f i)

case refine_2
R✝ : Type u_1
R' : Type u_2
A✝ : Type u_3
T : Type u_4
B✝ : Type u_5
ι✝ : Type u_6
inst✝¹² : Semiring R✝
inst✝¹¹ : Ring R'
inst✝¹⁰ : AddZeroClass A✝
inst✝⁹ : SemilatticeSup B✝
inst✝⁸ : Add B✝
inst✝⁷ : OrderBot B✝
D✝ : A✝ → B✝
p q : R✝[A✝]
hadd✝ : ∀ (a1 a2 : A✝), D✝ (a1 + a2) = D✝ a1 + D✝ a2
R : Type u_7
A : Type u_8
B : Type u_9
inst✝⁶ : CommSemiring R
inst✝⁵ : AddCommMonoid A
inst✝⁴ : AddCommMonoid B
inst✝³ : SemilatticeSup B
inst✝² : OrderBot B
inst✝¹ : CovariantClass B B (fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass B B (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
D : A → B
hzero : D 0 = 0
hadd : ∀ (a1 a2 : A), D (a1 + a2) = D a1 + D a2
ι : Type u_10
s : Finset ι
f : ι → R[A]
⊢ ∀ ⦃a : ι⦄ {s : Finset ι},
    a ∉ s →
      supDegree D (∏ i ∈ s, f i) ≤ ∑ i ∈ s, supDegree D (f i) →
        supDegree D (∏ i ∈ insert a s, f i) ≤ ∑ i ∈ insert a s, supDegree D (f i)
tactic: refine s.induction ?_ ?_
Theorem: Finset.sum_pow
File: Mathlib/Data/Nat/Choose/Multinomial.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝² : DecidableEq α
inst✝¹ : CommSemiring R
f : α → R
s : Finset α
inst✝ : CommSemiring R
x : α → R
n : ℕ
⊢ s.sum x ^ n = ∑ k ∈ s.sym n, ↑(↑k).multinomial * (Multiset.map x ↑k).prod
state_after: α : Type u_1
R : Type u_2
inst✝² : DecidableEq α
inst✝¹ : CommSemiring R
f : α → R
s : Finset α
inst✝ : CommSemiring R
x : α → R
n : ℕ
⊢ s.sum x ^ n = ∑ i : { x // x ∈ s.sym n }, ↑(↑↑i).multinomial * (Multiset.map x ↑↑i).prod
tactic: conv_rhs => rw [← sum_coe_sort]
state_before: α : Type u_1
R : Type u_2
inst✝² : DecidableEq α
inst✝¹ : CommSemiring R
f : α → R
s : Finset α
inst✝ : CommSemiring R
x : α → R
n : ℕ
⊢ s.sum x ^ n = ∑ i : { x // x ∈ s.sym n }, ↑(↑↑i).multinomial * (Multiset.map x ↑↑i).prod
state_after: case h.e'_3.a.h.e'_6
α : Type u_1
R : Type u_2
inst✝² : DecidableEq α
inst✝¹ : CommSemiring R
f : α → R
s : Finset α
inst✝ : CommSemiring R
x : α → R
n : ℕ
x✝ : { x // x ∈ s.sym n }
a✝ : x✝ ∈ univ
⊢ (Multiset.map x ↑↑x✝).prod = (Multiset.map x ↑↑x✝).noncommProd ⋯
tactic: convert sum_pow_of_commute x s (fun _ _ _ _ _ ↦ Commute.all ..) n
state_before: case h.e'_3.a.h.e'_6
α : Type u_1
R : Type u_2
inst✝² : DecidableEq α
inst✝¹ : CommSemiring R
f : α → R
s : Finset α
inst✝ : CommSemiring R
x : α → R
n : ℕ
x✝ : { x // x ∈ s.sym n }
a✝ : x✝ ∈ univ
⊢ (Multiset.map x ↑↑x✝).prod = (Multiset.map x ↑↑x✝).noncommProd ⋯
state_after: no goals
tactic: rw [Multiset.noncommProd_eq_prod]
Theorem: CochainComplex.HomComplex.Cochain.shift_v'
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a p q : ℤ
hpq : p + n = q
⊢ p + a + n = q + a
state_after: no goals
tactic: omega
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a p q : ℤ
hpq : p + n = q
⊢ (γ.shift a).v p q hpq = γ.v (p + a) (q + a) ⋯
state_after: no goals
tactic: simp only [shift_v γ a p q hpq _ _ rfl rfl, shiftFunctor_obj_X, shiftFunctorObjXIso,
    HomologicalComplex.XIsoOfEq_rfl, Iso.refl_hom, Iso.refl_inv, comp_id, id_comp]
Theorem: Encodable.decode_prod_val
File: Mathlib/Logic/Encodable/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Encodable α
inst✝ : Encodable β
n : ℕ
⊢ decode n = (decode (unpair n).1).bind fun a => Option.map (Prod.mk a) (decode (unpair n).2)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Encodable α
inst✝ : Encodable β
n : ℕ
⊢ Option.map (⇑(Equiv.sigmaEquivProd α β))
      ((decode (unpair n).1).bind fun a => Option.map (Sigma.mk a) (decode (unpair n).2)) =
    (decode (unpair n).1).bind fun a => Option.map (Prod.mk a) (decode (unpair n).2)
tactic: simp only [decode_ofEquiv, Equiv.symm_symm, decode_sigma_val]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Encodable α
inst✝ : Encodable β
n : ℕ
⊢ Option.map (⇑(Equiv.sigmaEquivProd α β))
      ((decode (unpair n).1).bind fun a => Option.map (Sigma.mk a) (decode (unpair n).2)) =
    (decode (unpair n).1).bind fun a => Option.map (Prod.mk a) (decode (unpair n).2)
state_after: no goals
tactic: cases (decode n.unpair.1 : Option α) <;> cases (decode n.unpair.2 : Option β)
  <;> rfl
Theorem: Set.image_image2_distrib
File: Mathlib/Data/Set/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f f'✝ : α → β → γ
g✝ g' : α → β → γ → δ
s s' : Set α
t t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
g : γ → δ
f' : α' → β' → δ
g₁ : α → α'
g₂ : β → β'
h_distrib : ∀ (a : α) (b : β), g (f a b) = f' (g₁ a) (g₂ b)
⊢ g '' image2 f s t = image2 f' (g₁ '' s) (g₂ '' t)
state_after: no goals
tactic: simp_rw [image_image2, image2_image_left, image2_image_right, h_distrib]