1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Stream'.WSeq.tail_nil
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [tail]
state_before: α : Type u
β : Type v
γ : Type w
⊢ nil.tail = nil
state_after: no goals
Theorem: NNReal.list_prod_map_rpow'
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rw [← list_prod_map_rpow, List.map_map]
state_before: w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ≥0
r : ℝ
⊢ (List.map (fun x => f x ^ r) l).prod = (List.map f l).prod ^ r
state_after: w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ≥0
r : ℝ
⊢ (List.map (fun x => f x ^ r) l).prod = (List.map ((fun x => x ^ r) ∘ f) l).prod

tactic: rfl
state_before: w x y z : ℝ
ι : Type u_1
l : List ι
f : ι → ℝ≥0
r : ℝ
⊢ (List.map (fun x => f x ^ r) l).prod = (List.map ((fun x => x ^ r) ∘ f) l).prod
state_after: no goals
Theorem: max_div_div_left'
File: Mathlib/Algebra/Order/Group/MinMax.lean

tactic: simp only [div_eq_mul_inv, max_mul_mul_left, max_inv_inv']
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b✝ c✝ a b c : α
⊢ max (a / b) (a / c) = a / min b c
state_after: no goals
Theorem: MeasureTheory.IntegrableAtFilter.add
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: rcases hf with ⟨s, sl, hs⟩
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ g✝ : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
f g : α → E
hf : IntegrableAtFilter f l μ
hg : IntegrableAtFilter g l μ
⊢ IntegrableAtFilter (f + g) l μ
state_after: case intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ g✝ : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
f g : α → E
hg : IntegrableAtFilter g l μ
s : Set α
sl : s ∈ l
hs : IntegrableOn f s μ
⊢ IntegrableAtFilter (f + g) l μ

tactic: rcases hg with ⟨t, tl, ht⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ g✝ : α → E
s✝ t : Set α
μ ν : Measure α
l l' : Filter α
f g : α → E
hg : IntegrableAtFilter g l μ
s : Set α
sl : s ∈ l
hs : IntegrableOn f s μ
⊢ IntegrableAtFilter (f + g) l μ
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ g✝ : α → E
s✝ t✝ : Set α
μ ν : Measure α
l l' : Filter α
f g : α → E
s : Set α
sl : s ∈ l
hs : IntegrableOn f s μ
t : Set α
tl : t ∈ l
ht : IntegrableOn g t μ
⊢ IntegrableAtFilter (f + g) l μ

tactic: refine ⟨s ∩ t, inter_mem sl tl, ?_⟩
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ g✝ : α → E
s✝ t✝ : Set α
μ ν : Measure α
l l' : Filter α
f g : α → E
s : Set α
sl : s ∈ l
hs : IntegrableOn f s μ
t : Set α
tl : t ∈ l
ht : IntegrableOn g t μ
⊢ IntegrableAtFilter (f + g) l μ
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ g✝ : α → E
s✝ t✝ : Set α
μ ν : Measure α
l l' : Filter α
f g : α → E
s : Set α
sl : s ∈ l
hs : IntegrableOn f s μ
t : Set α
tl : t ∈ l
ht : IntegrableOn g t μ
⊢ IntegrableOn (f + g) (s ∩ t) μ

tactic: exact (hs.mono_set inter_subset_left).add (ht.mono_set inter_subset_right)
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f✝ g✝ : α → E
s✝ t✝ : Set α
μ ν : Measure α
l l' : Filter α
f g : α → E
s : Set α
sl : s ∈ l
hs : IntegrableOn f s μ
t : Set α
tl : t ∈ l
ht : IntegrableOn g t μ
⊢ IntegrableOn (f + g) (s ∩ t) μ
state_after: no goals
Theorem: Set.eq_of_not_mem_uIoc_of_not_mem_uIoc
File: Mathlib/Order/Interval/Set/UnorderedInterval.lean

tactic: simp_rw [not_mem_uIoc]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
ha : a ≤ c
hb : b ≤ c
⊢ a ∉ Ι b c → b ∉ Ι a c → a = b
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
ha : a ≤ c
hb : b ≤ c
⊢ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a → b ≤ a ∧ b ≤ c ∨ c < b ∧ a < b → a = b

tactic: rintro (⟨_, _⟩ | ⟨_, _⟩) (⟨_, _⟩ | ⟨_, _⟩) <;>
    apply le_antisymm <;>
  first |assumption|exact le_of_lt ‹_›|
  exact absurd hb (not_le_of_lt ‹c < b›)|exact absurd ha (not_le_of_lt ‹c < a›)
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
ha : a ≤ c
hb : b ≤ c
⊢ a ≤ b ∧ a ≤ c ∨ c < a ∧ b < a → b ≤ a ∧ b ≤ c ∨ c < b ∧ a < b → a = b
state_after: no goals

tactic: assumption
state_before: case inr.intro.inl.intro.a
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
ha : a ≤ c
hb : b ≤ c
left✝¹ : c < a
right✝¹ : b < a
left✝ : b ≤ a
right✝ : b ≤ c
⊢ b ≤ a
state_after: no goals

tactic: exact le_of_lt ‹_›
state_before: case inr.intro.inr.intro.a
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
ha : a ≤ c
hb : b ≤ c
left✝¹ : c < a
right✝¹ : b < a
left✝ : c < b
right✝ : a < b
⊢ b ≤ a
state_after: no goals

tactic: exact absurd hb (not_le_of_lt ‹c < b›)
state_before: case inl.intro.inr.intro.a
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
ha : a ≤ c
hb : b ≤ c
left✝¹ : a ≤ b
right✝¹ : a ≤ c
left✝ : c < b
right✝ : a < b
⊢ b ≤ a
state_after: no goals

tactic: exact absurd ha (not_le_of_lt ‹c < a›)
state_before: case inr.intro.inl.intro.a
α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
s : Set α
a a₁ a₂ b b₁ b₂ c d x : α
ha : a ≤ c
hb : b ≤ c
left✝¹ : c < a
right✝¹ : b < a
left✝ : b ≤ a
right✝ : b ≤ c
⊢ a ≤ b
state_after: no goals
Theorem: Mathlib.Tactic.PushNeg.empty_ne_eq_nonempty
File: Mathlib/Tactic/PushNeg.lean

tactic: rw [ne_comm, ne_empty_eq_nonempty]
state_before: α : Sort ?u.1352
p q : Prop
s✝ : α → Prop
β : Type u
inst✝ : LinearOrder β
γ : Type u_1
s : Set γ
⊢ (∅ ≠ s) = s.Nonempty
state_after: no goals
Theorem: List.tails_eq_inits
File: Mathlib/Data/List/Infix.lean

tactic: simp
state_before: α : Type u_1
β : Type u_2
l l₁ l₂ l₃ : List α
a b : α
m n : ℕ
⊢ [].tails = (map reverse [].reverse.inits).reverse
state_after: no goals

tactic: simp [tails_eq_inits l, append_left_inj]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
a : α
l : List α
⊢ (a :: l).tails = (map reverse (a :: l).reverse.inits).reverse
state_after: no goals
Theorem: sdiff_eq_self_iff_disjoint
File: Mathlib/Order/BooleanAlgebra.lean

tactic: rw [sdiff_bot]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x \ y = x ↔ x \ y = x \ ⊥
state_after: no goals

tactic: rw [inf_bot_eq, inf_comm, disjoint_iff]
state_before: α : Type u
β : Type u_1
w x y z : α
inst✝ : GeneralizedBooleanAlgebra α
⊢ x ⊓ y = x ⊓ ⊥ ↔ Disjoint y x
state_after: no goals
Theorem: CategoryTheory.Functor.inv_fun_map
File: Mathlib/CategoryTheory/Equivalence.lean

tactic: erw [NatIso.naturality_1]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : F.IsEquivalence
X Y : C
f : X ⟶ Y
⊢ F.inv.map (F.map f) = F.asEquivalence.unitInv.app X ≫ f ≫ F.asEquivalence.unit.app Y
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : F.IsEquivalence
X Y : C
f : X ⟶ Y
⊢ F.inv.map (F.map f) = (F.asEquivalence.functor ⋙ F.asEquivalence.inverse).map f

tactic: rfl
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : F.IsEquivalence
X Y : C
f : X ⟶ Y
⊢ F.inv.map (F.map f) = (F.asEquivalence.functor ⋙ F.asEquivalence.inverse).map f
state_after: no goals
Theorem: Set.image_update_uIcc_left
File: Mathlib/Order/Interval/Set/Pi.lean

tactic: simpa using image_update_uIcc f i a (f i)
state_before: ι : Type u_1
α : ι → Type u_2
inst✝¹ : (i : ι) → Lattice (α i)
inst✝ : DecidableEq ι
f : (i : ι) → α i
i : ι
a : α i
⊢ update f i '' uIcc a (f i) = uIcc (update f i a) f
state_after: no goals
Theorem: not_nontrivial_iff_subsingleton
File: Mathlib/Logic/Nontrivial/Defs.lean

tactic: simp only [nontrivial_iff, subsingleton_iff, not_exists, Classical.not_not]
state_before: α : Type u_1
β : Type u_2
⊢ ¬Nontrivial α ↔ Subsingleton α
state_after: no goals
Theorem: AlgebraicGeometry.StructureSheaf.const_zero
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: rw [RingHom.map_zero]
state_before: R : Type u
inst✝ : CommRing R
f : R
U : Opens ↑(PrimeSpectrum.Top R)
hu : ∀ x ∈ U, f ∈ x.asIdeal.primeCompl
x : ↥{ unop := U }.unop
⊢ (algebraMap R (Localizations R ↑x)) 0 = ↑0 x * (algebraMap R (Localizations R ↑x)) ↑⟨f, ⋯⟩
state_after: R : Type u
inst✝ : CommRing R
f : R
U : Opens ↑(PrimeSpectrum.Top R)
hu : ∀ x ∈ U, f ∈ x.asIdeal.primeCompl
x : ↥{ unop := U }.unop
⊢ 0 = ↑0 x * (algebraMap R (Localizations R ↑x)) ↑⟨f, ⋯⟩

tactic: exact (mul_eq_zero_of_left rfl ((algebraMap R (Localizations R x)) _)).symm
state_before: R : Type u
inst✝ : CommRing R
f : R
U : Opens ↑(PrimeSpectrum.Top R)
hu : ∀ x ∈ U, f ∈ x.asIdeal.primeCompl
x : ↥{ unop := U }.unop
⊢ 0 = ↑0 x * (algebraMap R (Localizations R ↑x)) ↑⟨f, ⋯⟩
state_after: no goals
Theorem: neg_one_pow_eq_pow_mod_two
File: Mathlib/Algebra/Ring/Commute.lean

tactic: rw [← Nat.mod_add_div n 2, pow_add, pow_mul]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Ring R
a b : R
n✝ : ℕ
inst✝ : NoZeroDivisors R
n : ℕ
⊢ (-1) ^ n = (-1) ^ (n % 2)
state_after: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Ring R
a b : R
n✝ : ℕ
inst✝ : NoZeroDivisors R
n : ℕ
⊢ (-1) ^ (n % 2) * ((-1) ^ 2) ^ (n / 2) = (-1) ^ ((n % 2 + 2 * (n / 2)) % 2)

tactic: simp [sq]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Ring R
a b : R
n✝ : ℕ
inst✝ : NoZeroDivisors R
n : ℕ
⊢ (-1) ^ (n % 2) * ((-1) ^ 2) ^ (n / 2) = (-1) ^ ((n % 2 + 2 * (n / 2)) % 2)
state_after: no goals
Theorem: SimplicialObject.Split.cofan_inj_naturality_symm
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

tactic: erw [S₁.s.cofan_inj_eq, S₂.s.cofan_inj_eq, assoc, Φ.F.naturality, ← Φ.comm_assoc]
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
S₁ S₂ : Split C
Φ : S₁ ⟶ S₂
Δ : SimplexCategoryᵒᵖ
A : Splitting.IndexSet Δ
⊢ (S₁.s.cofan Δ).inj A ≫ Φ.F.app Δ = Φ.f A.fst.unop.len ≫ (S₂.s.cofan Δ).inj A
state_after: no goals
Theorem: ContractingWith.edist_inequality
File: Mathlib/Topology/MetricSpace/Contracting.lean

tactic: rwa [ENNReal.le_div_iff_mul_le (Or.inl hf.one_sub_K_ne_zero) (Or.inl one_sub_K_ne_top),
  mul_comm, ENNReal.sub_mul fun _ _ ↦ h, one_mul, tsub_le_iff_right]
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
h : edist x y ≠ ⊤
this : edist x y ≤ edist x (f x) + edist y (f y) + ↑K * edist x y
⊢ edist x y ≤ (edist x (f x) + edist y (f y)) / (1 - ↑K)
state_after: no goals

tactic: rw [edist_comm y, add_right_comm]
state_before: α : Type u_1
inst✝ : EMetricSpace α
cs : CompleteSpace α
K : ℝ≥0
f : α → α
hf : ContractingWith K f
x y : α
h : edist x y ≠ ⊤
⊢ edist x (f x) + edist (f x) (f y) + edist (f y) y = edist x (f x) + edist y (f y) + edist (f x) (f y)
state_after: no goals
Theorem: Ordinal.cof_add
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rcases zero_or_succ_or_limit b with (rfl | ⟨c, rfl⟩ | hb)
state_before: α : Type u_1
r : α → α → Prop
a b : Ordinal.{u_2}
h : b ≠ 0
⊢ (a + b).cof = b.cof
state_after: case inl
α : Type u_1
r : α → α → Prop
a : Ordinal.{u_2}
h : 0 ≠ 0
⊢ (a + 0).cof = cof 0

case inr.inl.intro
α : Type u_1
r : α → α → Prop
a c : Ordinal.{u_2}
h : succ c ≠ 0
⊢ (a + succ c).cof = (succ c).cof

case inr.inr
α : Type u_1
r : α → α → Prop
a b : Ordinal.{u_2}
h : b ≠ 0
hb : b.IsLimit
⊢ (a + b).cof = b.cof

tactic: contradiction
state_before: case inl
α : Type u_1
r : α → α → Prop
a : Ordinal.{u_2}
h : 0 ≠ 0
⊢ (a + 0).cof = cof 0
state_after: no goals

tactic: rw [add_succ, cof_succ, cof_succ]
state_before: case inr.inl.intro
α : Type u_1
r : α → α → Prop
a c : Ordinal.{u_2}
h : succ c ≠ 0
⊢ (a + succ c).cof = (succ c).cof
state_after: no goals

tactic: exact (add_isNormal a).cof_eq hb
state_before: case inr.inr
α : Type u_1
r : α → α → Prop
a b : Ordinal.{u_2}
h : b ≠ 0
hb : b.IsLimit
⊢ (a + b).cof = b.cof
state_after: no goals
Theorem: Finset.card_sigmaLift
File: Mathlib/Data/Finset/Sigma.lean

tactic: simp_rw [sigmaLift]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
⊢ (sigmaLift f a b).card = if h : a.fst = b.fst then (f (h ▸ a.snd) b.snd).card else 0
state_after: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
⊢ (if h : a.fst = b.fst then map (Embedding.sigmaMk b.fst) (f (h ▸ a.snd) b.snd) else ∅).card =
    if h : a.fst = b.fst then (f (h ▸ a.snd) b.snd).card else 0

tactic: split_ifs with h <;> simp [h]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f g : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : (i : ι) × α i
b : (i : ι) × β i
⊢ (if h : a.fst = b.fst then map (Embedding.sigmaMk b.fst) (f (h ▸ a.snd) b.snd) else ∅).card =
    if h : a.fst = b.fst then (f (h ▸ a.snd) b.snd).card else 0
state_after: no goals
Theorem: CategoryTheory.FreeMonoidalCategory.tensorFunc_obj_map
File: Mathlib/CategoryTheory/Monoidal/Free/Coherence.lean

tactic: cases n
state_before: C : Type u
Z : F C
n n' : (Discrete ∘ NormalMonoidalObject) C
f : n ⟶ n'
⊢ ((tensorFunc C).obj Z).map f = inclusion.map f ▷ Z
state_after: case mk
C : Type u
Z : F C
n' : (Discrete ∘ NormalMonoidalObject) C
as✝ : NormalMonoidalObject C
f : { as := as✝ } ⟶ n'
⊢ ((tensorFunc C).obj Z).map f = inclusion.map f ▷ Z

tactic: cases n'
state_before: case mk
C : Type u
Z : F C
n' : (Discrete ∘ NormalMonoidalObject) C
as✝ : NormalMonoidalObject C
f : { as := as✝ } ⟶ n'
⊢ ((tensorFunc C).obj Z).map f = inclusion.map f ▷ Z
state_after: case mk.mk
C : Type u
Z : F C
as✝¹ as✝ : NormalMonoidalObject C
f : { as := as✝¹ } ⟶ { as := as✝ }
⊢ ((tensorFunc C).obj Z).map f = inclusion.map f ▷ Z

tactic: rcases f with ⟨⟨h⟩⟩
state_before: case mk.mk
C : Type u
Z : F C
as✝¹ as✝ : NormalMonoidalObject C
f : { as := as✝¹ } ⟶ { as := as✝ }
⊢ ((tensorFunc C).obj Z).map f = inclusion.map f ▷ Z
state_after: case mk.mk.up.up
C : Type u
Z : F C
as✝¹ as✝ : NormalMonoidalObject C
h : { as := as✝¹ }.as = { as := as✝ }.as
⊢ ((tensorFunc C).obj Z).map { down := { down := h } } = inclusion.map { down := { down := h } } ▷ Z

tactic: dsimp at h
state_before: case mk.mk.up.up
C : Type u
Z : F C
as✝¹ as✝ : NormalMonoidalObject C
h : { as := as✝¹ }.as = { as := as✝ }.as
⊢ ((tensorFunc C).obj Z).map { down := { down := h } } = inclusion.map { down := { down := h } } ▷ Z
state_after: case mk.mk.up.up
C : Type u
Z : F C
as✝¹ as✝ : NormalMonoidalObject C
h : as✝¹ = as✝
⊢ ((tensorFunc C).obj Z).map { down := { down := h } } = inclusion.map { down := { down := h } } ▷ Z

tactic: subst h
state_before: case mk.mk.up.up
C : Type u
Z : F C
as✝¹ as✝ : NormalMonoidalObject C
h : as✝¹ = as✝
⊢ ((tensorFunc C).obj Z).map { down := { down := h } } = inclusion.map { down := { down := h } } ▷ Z
state_after: case mk.mk.up.up
C : Type u
Z : F C
as✝ : NormalMonoidalObject C
⊢ ((tensorFunc C).obj Z).map { down := { down := ⋯ } } = inclusion.map { down := { down := ⋯ } } ▷ Z

tactic: simp
state_before: case mk.mk.up.up
C : Type u
Z : F C
as✝ : NormalMonoidalObject C
⊢ ((tensorFunc C).obj Z).map { down := { down := ⋯ } } = inclusion.map { down := { down := ⋯ } } ▷ Z
state_after: no goals
Theorem: UniqueFactorizationMonoid.factors_prod
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [factors, dif_neg ane0]
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ (factors a).prod ~ᵤ a
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ (Classical.choose ⋯).prod ~ᵤ a

tactic: exact (Classical.choose_spec (exists_prime_factors a ane0)).2
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : UniqueFactorizationMonoid α
a : α
ane0 : a ≠ 0
⊢ (Classical.choose ⋯).prod ~ᵤ a
state_after: no goals
Theorem: PowerSeries.coeff_derivativeFun
File: Mathlib/RingTheory/PowerSeries/Derivative.lean

tactic: rw [derivativeFun, coeff_mk]
state_before: R : Type u_1
inst✝ : CommSemiring R
f : R⟦X⟧
n : ℕ
⊢ (coeff R n) f.derivativeFun = (coeff R (n + 1)) f * (↑n + 1)
state_after: no goals
Theorem: PrimeMultiset.to_ofPNatMultiset
File: Mathlib/Data/PNat/Factors.lean

tactic: dsimp [ofPNatMultiset, toPNatMultiset]
state_before: v : Multiset ℕ+
h : ∀ p ∈ v, p.Prime
⊢ (ofPNatMultiset v h).toPNatMultiset = v
state_after: v : Multiset ℕ+
h : ∀ p ∈ v, p.Prime
⊢ Multiset.map Coe.coe (Multiset.pmap (fun p hp => ⟨↑p, hp⟩) v h) = v

tactic: have : (fun (p : ℕ+) (h : p.Prime) => (Coe.coe : Nat.Primes → ℕ+) ⟨p, h⟩) = fun p _ => id p := by
  funext p h
  apply Subtype.eq
  rfl
state_before: v : Multiset ℕ+
h : ∀ p ∈ v, p.Prime
⊢ Multiset.map Coe.coe (Multiset.pmap (fun p hp => ⟨↑p, hp⟩) v h) = v
state_after: v : Multiset ℕ+
h : ∀ p ∈ v, p.Prime
this : (fun p h => Coe.coe ⟨↑p, h⟩) = fun p x => id p
⊢ Multiset.map Coe.coe (Multiset.pmap (fun p hp => ⟨↑p, hp⟩) v h) = v

tactic: rw [Multiset.map_pmap, this, Multiset.pmap_eq_map, Multiset.map_id]
state_before: v : Multiset ℕ+
h : ∀ p ∈ v, p.Prime
this : (fun p h => Coe.coe ⟨↑p, h⟩) = fun p x => id p
⊢ Multiset.map Coe.coe (Multiset.pmap (fun p hp => ⟨↑p, hp⟩) v h) = v
state_after: no goals

tactic: funext p h
state_before: v : Multiset ℕ+
h : ∀ p ∈ v, p.Prime
⊢ (fun p h => Coe.coe ⟨↑p, h⟩) = fun p x => id p
state_after: case h.h
v : Multiset ℕ+
h✝ : ∀ p ∈ v, p.Prime
p : ℕ+
h : p.Prime
⊢ Coe.coe ⟨↑p, h⟩ = id p

tactic: apply Subtype.eq
state_before: case h.h
v : Multiset ℕ+
h✝ : ∀ p ∈ v, p.Prime
p : ℕ+
h : p.Prime
⊢ Coe.coe ⟨↑p, h⟩ = id p
state_after: case h.h.a
v : Multiset ℕ+
h✝ : ∀ p ∈ v, p.Prime
p : ℕ+
h : p.Prime
⊢ ↑(Coe.coe ⟨↑p, h⟩) = ↑(id p)

tactic: rfl
state_before: case h.h.a
v : Multiset ℕ+
h✝ : ∀ p ∈ v, p.Prime
p : ℕ+
h : p.Prime
⊢ ↑(Coe.coe ⟨↑p, h⟩) = ↑(id p)
state_after: no goals
Theorem: IsWellOrderLimitElement.neq_bot
File: Mathlib/Order/IsWellOrderLimitElement.lean

tactic: rintro rfl
state_before: α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : IsWellOrder α fun x x_1 => x < x_1
a : α
ha : IsWellOrderLimitElement a
inst✝ : OrderBot α
⊢ a ≠ ⊥
state_after: α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : IsWellOrder α fun x x_1 => x < x_1
inst✝ : OrderBot α
ha : IsWellOrderLimitElement ⊥
⊢ False

tactic: obtain ⟨b, hb⟩ := ha.not_bot
state_before: α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : IsWellOrder α fun x x_1 => x < x_1
inst✝ : OrderBot α
ha : IsWellOrderLimitElement ⊥
⊢ False
state_after: case intro
α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : IsWellOrder α fun x x_1 => x < x_1
inst✝ : OrderBot α
ha : IsWellOrderLimitElement ⊥
b : α
hb : b < ⊥
⊢ False

tactic: simp at hb
state_before: case intro
α : Type u_1
inst✝² : LinearOrder α
inst✝¹ : IsWellOrder α fun x x_1 => x < x_1
inst✝ : OrderBot α
ha : IsWellOrderLimitElement ⊥
b : α
hb : b < ⊥
⊢ False
state_after: no goals
Theorem: LeftOrdContinuous.map_sup
File: Mathlib/Order/OrdContinuous.lean

tactic: simp only [image_pair, isLUB_pair]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝¹ : SemilatticeSup α
inst✝ : SemilatticeSup β
f : α → β
hf : LeftOrdContinuous f
x y : α
⊢ IsLUB (f '' {x, y}) (f x ⊔ f y)
state_after: no goals
Theorem: CategoryTheory.Bicategory.pentagon_hom_hom_inv_inv_hom
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ inv ((α_ f (g ≫ h) i).hom ≫ f ◁ (α_ g h i).hom ≫ (α_ f g (h ≫ i)).inv) =
    inv ((α_ f g h).inv ▷ i ≫ (α_ (f ≫ g) h i).hom)
state_after: no goals
Theorem: PrimeSpectrum.isIrreducible_iff_vanishingIdeal_isPrime
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: rw [← isIrreducible_iff_closure, ← zeroLocus_vanishingIdeal_eq_closure,
  isIrreducible_zeroLocus_iff_of_radical _ (isRadical_vanishingIdeal s)]
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
s : Set (PrimeSpectrum R)
⊢ IsIrreducible s ↔ (vanishingIdeal s).IsPrime
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.addX_of_X_eq
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [addU, neg_sq, div_pow, ← addX_of_X_eq' hP hQ hx,
  mul_div_cancel_right₀ _ <| pow_ne_zero 2 <| mul_ne_zero hPz hQz]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hP : W.Equation P
hQ : W.Equation Q
hPz : P z ≠ 0
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 = Q x * P z ^ 2
⊢ W.addX P Q = addU P Q ^ 2
state_after: no goals
Theorem: Finset.mul_prod_Ico_eq_prod_Icc
File: Mathlib/Algebra/BigOperators/Intervals.lean

tactic: rw [Icc_eq_cons_Ico h, prod_cons]
state_before: α : Type u_1
M : Type u_2
inst✝² : PartialOrder α
inst✝¹ : CommMonoid M
f : α → M
a b : α
inst✝ : LocallyFiniteOrder α
h : a ≤ b
⊢ f b * ∏ x ∈ Ico a b, f x = ∏ x ∈ Icc a b, f x
state_after: no goals
Theorem: LiouvilleNumber.remainder_summable
File: Mathlib/NumberTheory/Liouville/LiouvilleNumber.lean

tactic: convert (summable_nat_add_iff (k + 1)).2 (LiouvilleNumber.summable hm)
state_before: m : ℝ
hm : 1 < m
k : ℕ
⊢ Summable fun i => 1 / m ^ (i + (k + 1))!
state_after: no goals
Theorem: tsum_riemannZetaSummand
File: Mathlib/NumberTheory/EulerProduct/DirichletLSeries.lean

tactic: have hsum := summable_riemannZetaSummand hs
state_before: s : ℂ
hs : 1 < s.re
⊢ ∑' (n : ℕ), (riemannZetaSummandHom ⋯) n = riemannZeta s
state_after: s : ℂ
hs : 1 < s.re
hsum : Summable fun n => ‖(riemannZetaSummandHom ⋯) n‖
⊢ ∑' (n : ℕ), (riemannZetaSummandHom ⋯) n = riemannZeta s

tactic: rw [zeta_eq_tsum_one_div_nat_add_one_cpow hs, tsum_eq_zero_add hsum.of_norm, map_zero, zero_add]
state_before: s : ℂ
hs : 1 < s.re
hsum : Summable fun n => ‖(riemannZetaSummandHom ⋯) n‖
⊢ ∑' (n : ℕ), (riemannZetaSummandHom ⋯) n = riemannZeta s
state_after: s : ℂ
hs : 1 < s.re
hsum : Summable fun n => ‖(riemannZetaSummandHom ⋯) n‖
⊢ ∑' (b : ℕ), (riemannZetaSummandHom ⋯) (b + 1) = ∑' (n : ℕ), 1 / (↑n + 1) ^ s

tactic: simp only [riemannZetaSummandHom, cpow_neg, MonoidWithZeroHom.coe_mk, ZeroHom.coe_mk,
  Nat.cast_add, Nat.cast_one, one_div]
state_before: s : ℂ
hs : 1 < s.re
hsum : Summable fun n => ‖(riemannZetaSummandHom ⋯) n‖
⊢ ∑' (b : ℕ), (riemannZetaSummandHom ⋯) (b + 1) = ∑' (n : ℕ), 1 / (↑n + 1) ^ s
state_after: no goals
Theorem: List.inter_reverse
File: Mathlib/Data/List/Lattice.lean

tactic: simp only [List.inter, elem_eq_mem, mem_reverse]
state_before: α : Type u_1
l l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
xs ys : List α
⊢ xs.inter ys.reverse = xs.inter ys
state_after: no goals