1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Real.log_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: apply exp_injective
state_before: x✝ y✝ z : ℝ
n : ℕ
x : ℝ
hx : 0 < x
y : ℝ
⊢ log (x ^ y) = y * log x
state_after: case a
x✝ y✝ z : ℝ
n : ℕ
x : ℝ
hx : 0 < x
y : ℝ
⊢ rexp (log (x ^ y)) = rexp (y * log x)

tactic: rw [exp_log (rpow_pos_of_pos hx y), ← exp_log hx, mul_comm, rpow_def_of_pos (exp_pos (log x)) y]
state_before: case a
x✝ y✝ z : ℝ
n : ℕ
x : ℝ
hx : 0 < x
y : ℝ
⊢ rexp (log (x ^ y)) = rexp (y * log x)
state_after: no goals
Theorem: EllipticCurve.ofJ_1728_of_three_eq_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

tactic: rw [ofJ, dif_pos <| by rw [show (1728 : F) = 3 * 576 by norm_num1, h3, zero_mul], dif_pos h3]
state_before: R : Type u
inst✝² : CommRing R
E : EllipticCurve R
F : Type u
inst✝¹ : Field F
j : F
inst✝ : DecidableEq F
h3 : 3 = 0
⊢ ofJ 1728 = ofJ1728 F
state_after: no goals

tactic: rw [show (1728 : F) = 3 * 576 by norm_num1, h3, zero_mul]
state_before: R : Type u
inst✝² : CommRing R
E : EllipticCurve R
F : Type u
inst✝¹ : Field F
j : F
inst✝ : DecidableEq F
h3 : 3 = 0
⊢ 1728 = 0
state_after: no goals

tactic: norm_num1
state_before: R : Type u
inst✝² : CommRing R
E : EllipticCurve R
F : Type u
inst✝¹ : Field F
j : F
inst✝ : DecidableEq F
h3 : 3 = 0
⊢ 1728 = 3 * 576
state_after: no goals
Theorem: Pell.xn_ge_a_pow
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: simp only [_root_.pow_succ, xn_succ]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ a ^ (n + 1) ≤ xn a1 (n + 1)
state_after: a : ℕ
a1 : 1 < a
n : ℕ
⊢ a ^ n * a ≤ xn a1 n * a + Pell.d a1 * yn a1 n

tactic: exact le_trans (Nat.mul_le_mul_right _ (xn_ge_a_pow n)) (Nat.le_add_right _ _)
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ a ^ n * a ≤ xn a1 n * a + Pell.d a1 * yn a1 n
state_after: no goals
Theorem: Sym2.mem_and_mem_iff
File: Mathlib/Data/Sym/Sym2.lean

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
x y : α
z : Sym2 α
hne : x ≠ y
⊢ x ∈ z ∧ y ∈ z ↔ z = s(x, y)
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
x y : α
z : Sym2 α
hne : x ≠ y
⊢ x ∈ z ∧ y ∈ z → z = s(x, y)

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
x y : α
z : Sym2 α
hne : x ≠ y
⊢ z = s(x, y) → x ∈ z ∧ y ∈ z

tactic: induction' z with x' y'
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
x y : α
z : Sym2 α
hne : x ≠ y
⊢ x ∈ z ∧ y ∈ z → z = s(x, y)
state_after: case mp.h
α : Type u_1
β : Type u_2
γ : Type u_3
x y : α
hne : x ≠ y
x' y' : α
⊢ x ∈ s(x', y') ∧ y ∈ s(x', y') → s(x', y') = s(x, y)

tactic: rw [mem_iff, mem_iff]
state_before: case mp.h
α : Type u_1
β : Type u_2
γ : Type u_3
x y : α
hne : x ≠ y
x' y' : α
⊢ x ∈ s(x', y') ∧ y ∈ s(x', y') → s(x', y') = s(x, y)
state_after: case mp.h
α : Type u_1
β : Type u_2
γ : Type u_3
x y : α
hne : x ≠ y
x' y' : α
⊢ (x = x' ∨ x = y') ∧ (y = x' ∨ y = y') → s(x', y') = s(x, y)

tactic: aesop
state_before: case mp.h
α : Type u_1
β : Type u_2
γ : Type u_3
x y : α
hne : x ≠ y
x' y' : α
⊢ (x = x' ∨ x = y') ∧ (y = x' ∨ y = y') → s(x', y') = s(x, y)
state_after: no goals

tactic: rintro rfl
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
x y : α
z : Sym2 α
hne : x ≠ y
⊢ z = s(x, y) → x ∈ z ∧ y ∈ z
state_after: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
x y : α
hne : x ≠ y
⊢ x ∈ s(x, y) ∧ y ∈ s(x, y)

tactic: simp
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
x y : α
hne : x ≠ y
⊢ x ∈ s(x, y) ∧ y ∈ s(x, y)
state_after: no goals
Theorem: Matroid.basis_iff_mem_maximals
File: Mathlib/Data/Matroid/Basic.lean

tactic: rw [Basis, and_iff_left hX]
state_before: α : Type u_1
M : Matroid α
X I : Set α
hX : autoParam (X ⊆ M.E) _auto✝
⊢ M.Basis I X ↔ I ∈ maximals (fun x x_1 => x ⊆ x_1) {I | M.Indep I ∧ I ⊆ X}
state_after: no goals
Theorem: Function.LeftInverse.filter_map
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [map_map, hfg.comp_eq_id, map_id]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
f : α → β
g : β → α
hfg : LeftInverse g f
F : Filter α
⊢ map g (map f F) = F
state_after: no goals
Theorem: Ordinal.sup_iterate_eq_nfp
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: refine funext fun a => le_antisymm ?_ (sup_le fun l => ?_)
state_before: f✝ f : Ordinal.{u} → Ordinal.{u}
⊢ (fun a => sup fun n => f^[n] a) = nfp f
state_after: case refine_1
f✝ f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u}
⊢ (sup fun n => f^[n] a) ≤ nfp f a

case refine_2
f✝ f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u}
l : List Unit
⊢ List.foldr (fun x => f) a l ≤ sup fun n => f^[n] a

tactic: rw [sup_le_iff]
state_before: case refine_1
f✝ f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u}
⊢ (sup fun n => f^[n] a) ≤ nfp f a
state_after: case refine_1
f✝ f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u}
⊢ ∀ (i : ℕ), f^[i] a ≤ nfp f a

tactic: intro n
state_before: case refine_1
f✝ f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u}
⊢ ∀ (i : ℕ), f^[i] a ≤ nfp f a
state_after: case refine_1
f✝ f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u}
n : ℕ
⊢ f^[n] a ≤ nfp f a

tactic: rw [← List.length_replicate n Unit.unit, ← List.foldr_const f a]
state_before: case refine_1
f✝ f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u}
n : ℕ
⊢ f^[n] a ≤ nfp f a
state_after: case refine_1
f✝ f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u}
n : ℕ
⊢ List.foldr (fun x => f) a (List.replicate n ()) ≤ nfp f a

tactic: apply le_sup
state_before: case refine_1
f✝ f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u}
n : ℕ
⊢ List.foldr (fun x => f) a (List.replicate n ()) ≤ nfp f a
state_after: no goals

tactic: rw [List.foldr_const f a l]
state_before: case refine_2
f✝ f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u}
l : List Unit
⊢ List.foldr (fun x => f) a l ≤ sup fun n => f^[n] a
state_after: case refine_2
f✝ f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u}
l : List Unit
⊢ f^[l.length] a ≤ sup fun n => f^[n] a

tactic: exact le_sup _ _
state_before: case refine_2
f✝ f : Ordinal.{u} → Ordinal.{u}
a : Ordinal.{u}
l : List Unit
⊢ f^[l.length] a ≤ sup fun n => f^[n] a
state_after: no goals
Theorem: Real.arcsin_le_iff_le_sin'
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rcases le_total x (-1) with hx₁ | hx₁
state_before: x✝ y✝ x y : ℝ
hy : y ∈ Ico (-(π / 2)) (π / 2)
⊢ arcsin x ≤ y ↔ x ≤ sin y
state_after: case inl
x✝ y✝ x y : ℝ
hy : y ∈ Ico (-(π / 2)) (π / 2)
hx₁ : x ≤ -1
⊢ arcsin x ≤ y ↔ x ≤ sin y

case inr
x✝ y✝ x y : ℝ
hy : y ∈ Ico (-(π / 2)) (π / 2)
hx₁ : -1 ≤ x
⊢ arcsin x ≤ y ↔ x ≤ sin y

tactic: cases' lt_or_le 1 x with hx₂ hx₂
state_before: case inr
x✝ y✝ x y : ℝ
hy : y ∈ Ico (-(π / 2)) (π / 2)
hx₁ : -1 ≤ x
⊢ arcsin x ≤ y ↔ x ≤ sin y
state_after: case inr.inl
x✝ y✝ x y : ℝ
hy : y ∈ Ico (-(π / 2)) (π / 2)
hx₁ : -1 ≤ x
hx₂ : 1 < x
⊢ arcsin x ≤ y ↔ x ≤ sin y

case inr.inr
x✝ y✝ x y : ℝ
hy : y ∈ Ico (-(π / 2)) (π / 2)
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ arcsin x ≤ y ↔ x ≤ sin y

tactic: exact arcsin_le_iff_le_sin ⟨hx₁, hx₂⟩ (mem_Icc_of_Ico hy)
state_before: case inr.inr
x✝ y✝ x y : ℝ
hy : y ∈ Ico (-(π / 2)) (π / 2)
hx₁ : -1 ≤ x
hx₂ : x ≤ 1
⊢ arcsin x ≤ y ↔ x ≤ sin y
state_after: no goals

tactic: simp [arcsin_of_le_neg_one hx₁, hy.1, hx₁.trans (neg_one_le_sin _)]
state_before: case inl
x✝ y✝ x y : ℝ
hy : y ∈ Ico (-(π / 2)) (π / 2)
hx₁ : x ≤ -1
⊢ arcsin x ≤ y ↔ x ≤ sin y
state_after: no goals

tactic: simp [arcsin_of_one_le hx₂.le, hy.2.not_le, (sin_le_one y).trans_lt hx₂]
state_before: case inr.inl
x✝ y✝ x y : ℝ
hy : y ∈ Ico (-(π / 2)) (π / 2)
hx₁ : -1 ≤ x
hx₂ : 1 < x
⊢ arcsin x ≤ y ↔ x ≤ sin y
state_after: no goals
Theorem: SimpleGraph.Walk.map_map
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p with
| nil => rfl
| cons _ _ ih => simp [ih]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : G.Walk u v
⊢ Walk.map f' (Walk.map f p) = Walk.map (f'.comp f) p
state_after: no goals

tactic: rfl
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : G.Walk u v
u✝ : V
⊢ Walk.map f' (Walk.map f nil) = Walk.map (f'.comp f) nil
state_after: no goals

tactic: simp [ih]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : G.Walk u v
u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p✝ : G.Walk v✝ w✝
ih : Walk.map f' (Walk.map f p✝) = Walk.map (f'.comp f) p✝
⊢ Walk.map f' (Walk.map f (cons h✝ p✝)) = Walk.map (f'.comp f) (cons h✝ p✝)
state_after: no goals
Theorem: Complex.hasSum_sin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Series.lean

tactic: convert Complex.hasSum_sin' z using 1
state_before: z : ℂ
⊢ HasSum (fun n => (-1) ^ n * z ^ (2 * n + 1) / ↑(2 * n + 1)!) (sin z)
state_after: case h.e'_5
z : ℂ
⊢ (fun n => (-1) ^ n * z ^ (2 * n + 1) / ↑(2 * n + 1)!) = fun n => (z * I) ^ (2 * n + 1) / ↑(2 * n + 1)! / I

tactic: simp_rw [mul_pow, pow_succ, pow_mul, Complex.I_sq, ← mul_assoc, mul_div_assoc, div_right_comm,
  div_self Complex.I_ne_zero, mul_comm _ ((-1 : ℂ) ^ _), mul_one_div, mul_div_assoc, mul_assoc]
state_before: case h.e'_5
z : ℂ
⊢ (fun n => (-1) ^ n * z ^ (2 * n + 1) / ↑(2 * n + 1)!) = fun n => (z * I) ^ (2 * n + 1) / ↑(2 * n + 1)! / I
state_after: no goals
Theorem: Finset.image_add_right_Ico
File: Mathlib/Algebra/Order/Interval/Finset.lean

tactic: rw [← map_add_right_Ico, map_eq_image, addRightEmbedding, Embedding.coeFn_mk]
state_before: ι : Type u_1
α : Type u_2
inst✝³ : OrderedCancelAddCommMonoid α
inst✝² : ExistsAddOfLE α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
a b c : α
⊢ image (fun x => x + c) (Ico a b) = Ico (a + c) (b + c)
state_after: no goals
Theorem: inv_nonneg
File: Mathlib/Algebra/Order/Field/Defs.lean

tactic: simp only [le_iff_eq_or_lt, inv_pos, zero_eq_inv]
state_before: α : Type u_1
inst✝ : LinearOrderedSemifield α
a b : α
⊢ 0 ≤ a⁻¹ ↔ 0 ≤ a
state_after: no goals
Theorem: IsIntegral.of_pow
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: rcases hx with ⟨p, hmonic, heval⟩
state_before: R : Type u_1
A : Type u_2
B : Type u_3
S : Type u_4
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝¹ : R →+* S
f✝ : R →+* B
f : R →+* S
x : B
n : ℕ
hn : 0 < n
hx : IsIntegral R (x ^ n)
⊢ IsIntegral R x
state_after: case intro.intro
R : Type u_1
A : Type u_2
B : Type u_3
S : Type u_4
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝¹ : R →+* S
f✝ : R →+* B
f : R →+* S
x : B
n : ℕ
hn : 0 < n
p : R[X]
hmonic : p.Monic
heval : eval₂ (algebraMap R B) (x ^ n) p = 0
⊢ IsIntegral R x

tactic: exact ⟨expand R n p, hmonic.expand hn, by rwa [← aeval_def, expand_aeval]⟩
state_before: case intro.intro
R : Type u_1
A : Type u_2
B : Type u_3
S : Type u_4
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝¹ : R →+* S
f✝ : R →+* B
f : R →+* S
x : B
n : ℕ
hn : 0 < n
p : R[X]
hmonic : p.Monic
heval : eval₂ (algebraMap R B) (x ^ n) p = 0
⊢ IsIntegral R x
state_after: no goals

tactic: rwa [← aeval_def, expand_aeval]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
S : Type u_4
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : CommRing S
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f✝¹ : R →+* S
f✝ : R →+* B
f : R →+* S
x : B
n : ℕ
hn : 0 < n
p : R[X]
hmonic : p.Monic
heval : eval₂ (algebraMap R B) (x ^ n) p = 0
⊢ eval₂ (algebraMap R B) x ((expand R n) p) = 0
state_after: no goals
Theorem: BoxIntegral.Prepartition.isPartition_splitMany
File: Mathlib/Analysis/BoxIntegral/Partition/Split.lean

tactic: simp only [splitMany_empty, isPartitionTop]
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
I : Box ι
s : Finset (ι × ℝ)
⊢ (splitMany I ∅).IsPartition
state_after: no goals

tactic: simpa only [splitMany_insert, inf_split] using hs.biUnion fun J _ => isPartitionSplit _ _ _
state_before: ι : Type u_1
M : Type u_2
n : ℕ
I✝ J : Box ι
i : ι
x : ℝ
I : Box ι
s✝ : Finset (ι × ℝ)
a : ι × ℝ
s : Finset (ι × ℝ)
x✝ : a ∉ s
hs : (splitMany I s).IsPartition
⊢ (splitMany I (insert a s)).IsPartition
state_after: no goals
Theorem: CategoryTheory.IsUniversalColimit.of_mapCocone
File: Mathlib/CategoryTheory/Limits/VanKampen.lean

tactic: ext j
state_before: J : Type v'
inst✝⁵ : Category.{u', v'} J
C : Type u
inst✝⁴ : Category.{v, u} C
K : Type u_1
inst✝³ : Category.{?u.45529, u_1} K
D : Type u_2
inst✝² : Category.{u_3, u_2} D
G : C ⥤ D
F : J ⥤ C
c : Cocone F
inst✝¹ : PreservesLimitsOfShape WalkingCospan G
inst✝ : ReflectsColimitsOfShape J G
hc : IsUniversalColimit (G.mapCocone c)
F' : J ⥤ C
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
h : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
H : ∀ (j : J), IsPullback (c'.ι.app j) (α.app j) f (c.ι.app j)
⊢ whiskerRight α G ≫ (G.mapCocone c).ι = (G.mapCocone c').ι ≫ (Functor.const J).map (G.map f)
state_after: case w.h
J : Type v'
inst✝⁵ : Category.{u', v'} J
C : Type u
inst✝⁴ : Category.{v, u} C
K : Type u_1
inst✝³ : Category.{?u.45529, u_1} K
D : Type u_2
inst✝² : Category.{u_3, u_2} D
G : C ⥤ D
F : J ⥤ C
c : Cocone F
inst✝¹ : PreservesLimitsOfShape WalkingCospan G
inst✝ : ReflectsColimitsOfShape J G
hc : IsUniversalColimit (G.mapCocone c)
F' : J ⥤ C
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
h : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
H : ∀ (j : J), IsPullback (c'.ι.app j) (α.app j) f (c.ι.app j)
j : J
⊢ (whiskerRight α G ≫ (G.mapCocone c).ι).app j = ((G.mapCocone c').ι ≫ (Functor.const J).map (G.map f)).app j

tactic: simpa using G.congr_map (NatTrans.congr_app h j)
state_before: case w.h
J : Type v'
inst✝⁵ : Category.{u', v'} J
C : Type u
inst✝⁴ : Category.{v, u} C
K : Type u_1
inst✝³ : Category.{?u.45529, u_1} K
D : Type u_2
inst✝² : Category.{u_3, u_2} D
G : C ⥤ D
F : J ⥤ C
c : Cocone F
inst✝¹ : PreservesLimitsOfShape WalkingCospan G
inst✝ : ReflectsColimitsOfShape J G
hc : IsUniversalColimit (G.mapCocone c)
F' : J ⥤ C
c' : Cocone F'
α : F' ⟶ F
f : c'.pt ⟶ c.pt
h : α ≫ c.ι = c'.ι ≫ (Functor.const J).map f
hα : NatTrans.Equifibered α
H : ∀ (j : J), IsPullback (c'.ι.app j) (α.app j) f (c.ι.app j)
j : J
⊢ (whiskerRight α G ≫ (G.mapCocone c).ι).app j = ((G.mapCocone c').ι ≫ (Functor.const J).map (G.map f)).app j
state_after: no goals
Theorem: IsScalarTower.of_smul_one_mul
File: Mathlib/Algebra/Group/Action/Defs.lean

tactic: rw [← h, smul_eq_mul, mul_assoc, h, smul_eq_mul]
state_before: M✝ : Type u_1
N✝ : Type u_2
G : Type u_3
A : Type u_4
B : Type u_5
α : Type u_6
β : Type u_7
γ : Type u_8
δ : Type u_9
M : Type u_10
N : Type u_11
inst✝¹ : Monoid N
inst✝ : SMul M N
h : ∀ (x : M) (y : N), x • 1 * y = x • y
x : M
y z : N
⊢ (x • y) • z = x • y • z
state_after: no goals
Theorem: Polynomial.roots_prod_X_sub_C
File: Mathlib/Algebra/Polynomial/Roots.lean

tactic: apply (roots_prod (fun a => X - C a) s ?_).trans
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Finset R
⊢ (∏ a ∈ s, (X - C a)).roots = s.val
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Finset R
⊢ (s.val.bind fun i => (X - C i).roots) = s.val

R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Finset R
⊢ ∏ a ∈ s, (X - C a) ≠ 0

tactic: simp_rw [roots_X_sub_C]
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Finset R
⊢ (s.val.bind fun i => (X - C i).roots) = s.val
state_after: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Finset R
⊢ (s.val.bind fun i => {i}) = s.val

tactic: rw [Multiset.bind_singleton, Multiset.map_id']
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Finset R
⊢ (s.val.bind fun i => {i}) = s.val
state_after: no goals

tactic: refine prod_ne_zero_iff.mpr (fun a _ => X_sub_C_ne_zero a)
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
s : Finset R
⊢ ∏ a ∈ s, (X - C a) ≠ 0
state_after: no goals
Theorem: CategoryTheory.MorphismProperty.RightFraction.map_s_comp_map
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

tactic: letI := hL _ φ.hs
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
φ : W.RightFraction X Y
L : C ⥤ D
hL : W.IsInvertedBy L
⊢ L.map φ.s ≫ φ.map L hL = L.map φ.f
state_after: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
φ : W.RightFraction X Y
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map φ.s) := hL φ.s φ.hs
⊢ L.map φ.s ≫ φ.map L hL = L.map φ.f

tactic: simp [map]
state_before: C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
W : MorphismProperty C
X Y : C
φ : W.RightFraction X Y
L : C ⥤ D
hL : W.IsInvertedBy L
this : IsIso (L.map φ.s) := hL φ.s φ.hs
⊢ L.map φ.s ≫ φ.map L hL = L.map φ.f
state_after: no goals
Theorem: CategoryTheory.IsHomLift.id
File: Mathlib/CategoryTheory/FiberedCategory/HomLift.lean

tactic: cases ha
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p✝ p : 𝒳 ⥤ 𝒮
R : 𝒮
a : 𝒳
ha : p.obj a = R
⊢ p.IsHomLift (𝟙 R) (𝟙 a)
state_after: case refl
𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p✝ p : 𝒳 ⥤ 𝒮
a : 𝒳
⊢ p.IsHomLift (𝟙 (p.obj a)) (𝟙 a)

tactic: infer_instance
state_before: case refl
𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p✝ p : 𝒳 ⥤ 𝒮
a : 𝒳
⊢ p.IsHomLift (𝟙 (p.obj a)) (𝟙 a)
state_after: no goals
Theorem: LieIdeal.map_lowerCentralSeries_le
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: induction' k with k ih
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
k : ℕ
f : L →ₗ⁅R⁆ L'
⊢ map f (lowerCentralSeries R L L k) ≤ lowerCentralSeries R L' L' k
state_after: case zero
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
⊢ map f (lowerCentralSeries R L L 0) ≤ lowerCentralSeries R L' L' 0

case succ
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
k : ℕ
ih : map f (lowerCentralSeries R L L k) ≤ lowerCentralSeries R L' L' k
⊢ map f (lowerCentralSeries R L L (k + 1)) ≤ lowerCentralSeries R L' L' (k + 1)

tactic: simp only [Nat.zero_eq, LieModule.lowerCentralSeries_zero, le_top]
state_before: case zero
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
⊢ map f (lowerCentralSeries R L L 0) ≤ lowerCentralSeries R L' L' 0
state_after: no goals

tactic: simp only [LieModule.lowerCentralSeries_succ]
state_before: case succ
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
k : ℕ
ih : map f (lowerCentralSeries R L L k) ≤ lowerCentralSeries R L' L' k
⊢ map f (lowerCentralSeries R L L (k + 1)) ≤ lowerCentralSeries R L' L' (k + 1)
state_after: case succ
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
k : ℕ
ih : map f (lowerCentralSeries R L L k) ≤ lowerCentralSeries R L' L' k
⊢ map f ⁅⊤, lowerCentralSeries R L L k⁆ ≤ ⁅⊤, lowerCentralSeries R L' L' k⁆

tactic: exact le_trans (LieIdeal.map_bracket_le f) (LieSubmodule.mono_lie _ _ _ _ le_top ih)
state_before: case succ
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
f : L →ₗ⁅R⁆ L'
k : ℕ
ih : map f (lowerCentralSeries R L L k) ≤ lowerCentralSeries R L' L' k
⊢ map f ⁅⊤, lowerCentralSeries R L L k⁆ ≤ ⁅⊤, lowerCentralSeries R L' L' k⁆
state_after: no goals
Theorem: Finset.sum_mul_sum
File: Mathlib/Algebra/BigOperators/Ring.lean

tactic: simp_rw [sum_mul, ← mul_sum]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
κ✝ : ι → Type u_5
s✝ s₁ s₂ : Finset ι
i : ι
a : α
f✝ g✝ : ι → α
inst✝ : NonUnitalNonAssocSemiring α
κ : Type u_6
s : Finset ι
t : Finset κ
f : ι → α
g : κ → α
⊢ (∑ i ∈ s, f i) * ∑ j ∈ t, g j = ∑ i ∈ s, ∑ j ∈ t, f i * g j
state_after: no goals
Theorem: NNReal.mul_iSup_le
File: Mathlib/Data/NNReal/Basic.lean

tactic: rw [mul_iSup]
state_before: ι : Sort u_1
f : ι → ℝ≥0
a g : ℝ≥0
h : ι → ℝ≥0
H : ∀ (j : ι), g * h j ≤ a
⊢ g * iSup h ≤ a
state_after: ι : Sort u_1
f : ι → ℝ≥0
a g : ℝ≥0
h : ι → ℝ≥0
H : ∀ (j : ι), g * h j ≤ a
⊢ ⨆ i, g * h i ≤ a

tactic: exact ciSup_le' H
state_before: ι : Sort u_1
f : ι → ℝ≥0
a g : ℝ≥0
h : ι → ℝ≥0
H : ∀ (j : ι), g * h j ≤ a
⊢ ⨆ i, g * h i ≤ a
state_after: no goals
Theorem: integral_one
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: simp only [mul_one, smul_eq_mul, integral_const]
state_before: a b : ℝ
n : ℕ
⊢ ∫ (x : ℝ) in a..b, 1 = b - a
state_after: no goals
Theorem: Filter.isCobounded_principal
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [IsCobounded, subset_def]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
ι' : Type u_5
r : α → α → Prop
f g : Filter α
s : Set α
⊢ IsCobounded r (𝓟 s) ↔ ∃ b, ∀ (a : α), (∀ x ∈ s, r x a) → r b a
state_after: no goals
Theorem: Submodule.sup_span
File: Mathlib/LinearAlgebra/Span.lean

tactic: rw [Submodule.span_union, p.span_eq]
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝⁷ : Semiring R
inst✝⁶ : AddCommMonoid M
inst✝⁵ : Module R M
x : M
p p' : Submodule R M
inst✝⁴ : Semiring R₂
σ₁₂ : R →+* R₂
inst✝³ : AddCommMonoid M₂
inst✝² : Module R₂ M₂
F : Type u_8
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F σ₁₂ M M₂
s t : Set M
⊢ p ⊔ span R s = span R (↑p ∪ s)
state_after: no goals
Theorem: NonUnitalStarAlgebra.mem_sup_left
File: Mathlib/Algebra/Star/NonUnitalSubalgebra.lean

tactic: rw [← SetLike.le_def]
state_before: F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : StarRing R
inst✝¹⁴ : NonUnitalSemiring A
inst✝¹³ : StarRing A
inst✝¹² : Module R A
inst✝¹¹ : IsScalarTower R A A
inst✝¹⁰ : SMulCommClass R A A
inst✝⁹ : StarModule R A
inst✝⁸ : NonUnitalSemiring B
inst✝⁷ : StarRing B
inst✝⁶ : Module R B
inst✝⁵ : IsScalarTower R B B
inst✝⁴ : SMulCommClass R B B
inst✝³ : StarModule R B
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
S T : NonUnitalStarSubalgebra R A
⊢ ∀ {x : A}, x ∈ S → x ∈ S ⊔ T
state_after: F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : StarRing R
inst✝¹⁴ : NonUnitalSemiring A
inst✝¹³ : StarRing A
inst✝¹² : Module R A
inst✝¹¹ : IsScalarTower R A A
inst✝¹⁰ : SMulCommClass R A A
inst✝⁹ : StarModule R A
inst✝⁸ : NonUnitalSemiring B
inst✝⁷ : StarRing B
inst✝⁶ : Module R B
inst✝⁵ : IsScalarTower R B B
inst✝⁴ : SMulCommClass R B B
inst✝³ : StarModule R B
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
S T : NonUnitalStarSubalgebra R A
⊢ S ≤ S ⊔ T

tactic: exact le_sup_left
state_before: F : Type v'
R' : Type u'
R : Type u
A : Type v
B : Type w
C : Type w'
inst✝¹⁶ : CommSemiring R
inst✝¹⁵ : StarRing R
inst✝¹⁴ : NonUnitalSemiring A
inst✝¹³ : StarRing A
inst✝¹² : Module R A
inst✝¹¹ : IsScalarTower R A A
inst✝¹⁰ : SMulCommClass R A A
inst✝⁹ : StarModule R A
inst✝⁸ : NonUnitalSemiring B
inst✝⁷ : StarRing B
inst✝⁶ : Module R B
inst✝⁵ : IsScalarTower R B B
inst✝⁴ : SMulCommClass R B B
inst✝³ : StarModule R B
inst✝² : FunLike F A B
inst✝¹ : NonUnitalAlgHomClass F R A B
inst✝ : NonUnitalStarAlgHomClass F R A B
S T : NonUnitalStarSubalgebra R A
⊢ S ≤ S ⊔ T
state_after: no goals