1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finset.prod_primes_dvd
File: Mathlib/Algebra/BigOperators/Associated.lean

tactic: classical
  exact
    Multiset.prod_primes_dvd n (by simpa only [Multiset.map_id', Finset.mem_def] using h)
      (by simpa only [Multiset.map_id', Finset.mem_def] using div)
      (by
        simp only [Multiset.map_id', associated_eq_eq, Multiset.countP_eq_card_filter,
          ← s.val.count_eq_card_filter_eq, ← Multiset.nodup_iff_count_le_one, s.nodup])
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : Unique αˣ
s : Finset α
n : α
h : ∀ a ∈ s, Prime a
div : ∀ a ∈ s, a ∣ n
⊢ ∏ p ∈ s, p ∣ n
state_after: no goals

tactic: exact
  Multiset.prod_primes_dvd n (by simpa only [Multiset.map_id', Finset.mem_def] using h)
    (by simpa only [Multiset.map_id', Finset.mem_def] using div)
    (by
      simp only [Multiset.map_id', associated_eq_eq, Multiset.countP_eq_card_filter,
        ← s.val.count_eq_card_filter_eq, ← Multiset.nodup_iff_count_le_one, s.nodup])
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : Unique αˣ
s : Finset α
n : α
h : ∀ a ∈ s, Prime a
div : ∀ a ∈ s, a ∣ n
⊢ ∏ p ∈ s, p ∣ n
state_after: no goals

tactic: simpa only [Multiset.map_id', Finset.mem_def] using h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : Unique αˣ
s : Finset α
n : α
h : ∀ a ∈ s, Prime a
div : ∀ a ∈ s, a ∣ n
⊢ ∀ a ∈ Multiset.map (fun p => p) s.val, Prime a
state_after: no goals

tactic: simpa only [Multiset.map_id', Finset.mem_def] using div
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : Unique αˣ
s : Finset α
n : α
h : ∀ a ∈ s, Prime a
div : ∀ a ∈ s, a ∣ n
⊢ ∀ a ∈ Multiset.map (fun p => p) s.val, a ∣ n
state_after: no goals

tactic: simp only [Multiset.map_id', associated_eq_eq, Multiset.countP_eq_card_filter,
  ← s.val.count_eq_card_filter_eq, ← Multiset.nodup_iff_count_le_one, s.nodup]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : Unique αˣ
s : Finset α
n : α
h : ∀ a ∈ s, Prime a
div : ∀ a ∈ s, a ∣ n
⊢ ∀ (a : α), Multiset.countP (Associated a) (Multiset.map (fun p => p) s.val) ≤ 1
state_after: no goals
Theorem: padicValInt.zero
File: Mathlib/NumberTheory/Padics/PadicVal.lean

tactic: simp [padicValInt]
state_before: p : ℕ
⊢ padicValInt p 0 = 0
state_after: no goals
Theorem: smul_univ_pi
File: Mathlib/Algebra/Module/PointwisePi.lean

tactic: refine ⟨fun i ↦ Classical.choose (h i <| Set.mem_univ _), fun i _ ↦ ?_, funext fun i ↦ ?_⟩
state_before: K : Type u_1
ι : Type u_2
R : ι → Type u_3
inst✝ : (i : ι) → SMul K (R i)
r : K
t : (i : ι) → Set (R i)
x : (i : ι) → R i
h : x ∈ univ.pi (r • t)
⊢ x ∈ r • univ.pi t
state_after: case refine_1
K : Type u_1
ι : Type u_2
R : ι → Type u_3
inst✝ : (i : ι) → SMul K (R i)
r : K
t : (i : ι) → Set (R i)
x : (i : ι) → R i
h : x ∈ univ.pi (r • t)
i : ι
x✝ : i ∈ univ
⊢ (fun i => Classical.choose ⋯) i ∈ t i

case refine_2
K : Type u_1
ι : Type u_2
R : ι → Type u_3
inst✝ : (i : ι) → SMul K (R i)
r : K
t : (i : ι) → Set (R i)
x : (i : ι) → R i
h : x ∈ univ.pi (r • t)
i : ι
⊢ (fun x => r • x) (fun i => Classical.choose ⋯) i = x i

tactic: exact (Classical.choose_spec (h i <| Set.mem_univ i)).left
state_before: case refine_1
K : Type u_1
ι : Type u_2
R : ι → Type u_3
inst✝ : (i : ι) → SMul K (R i)
r : K
t : (i : ι) → Set (R i)
x : (i : ι) → R i
h : x ∈ univ.pi (r • t)
i : ι
x✝ : i ∈ univ
⊢ (fun i => Classical.choose ⋯) i ∈ t i
state_after: no goals

tactic: exact (Classical.choose_spec (h i <| Set.mem_univ i)).right
state_before: case refine_2
K : Type u_1
ι : Type u_2
R : ι → Type u_3
inst✝ : (i : ι) → SMul K (R i)
r : K
t : (i : ι) → Set (R i)
x : (i : ι) → R i
h : x ∈ univ.pi (r • t)
i : ι
⊢ (fun x => r • x) (fun i => Classical.choose ⋯) i = x i
state_after: no goals
Theorem: normal_of_eq_cosets
File: Mathlib/GroupTheory/Coset.lean

tactic: rw [← mem_rightCoset_iff, ← h]
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
h : ∀ (g : α), g • ↑s = op g • ↑s
a : α
ha : a ∈ s
g : α
⊢ g * a * g⁻¹ ∈ ↑s
state_after: α : Type u_1
inst✝ : Group α
s : Subgroup α
h : ∀ (g : α), g • ↑s = op g • ↑s
a : α
ha : a ∈ s
g : α
⊢ g * a ∈ g • ↑s

tactic: exact mem_leftCoset g ha
state_before: α : Type u_1
inst✝ : Group α
s : Subgroup α
h : ∀ (g : α), g • ↑s = op g • ↑s
a : α
ha : a ∈ s
g : α
⊢ g * a ∈ g • ↑s
state_after: no goals
Theorem: Finsupp.unique_ext
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rwa [Unique.eq_default a]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝¹ : Zero M
inst✝ : Unique α
f g : α →₀ M
h : f default = g default
a : α
⊢ f a = g a
state_after: no goals
Theorem: OrderMonoidHom.cancel_right
File: Mathlib/Algebra/Order/Hom/Monoid.lean

tactic: congr
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁷ : Preorder α
inst✝⁶ : Preorder β
inst✝⁵ : Preorder γ
inst✝⁴ : Preorder δ
inst✝³ : MulOneClass α
inst✝² : MulOneClass β
inst✝¹ : MulOneClass γ
inst✝ : MulOneClass δ
f✝ g : α →*o β
g₁ g₂ : β →*o γ
f : α →*o β
hf : Surjective ⇑f
x✝ : g₁ = g₂
⊢ g₁.comp f = g₂.comp f
state_after: no goals
Theorem: Orientation.left_ne_zero_of_oangle_sign_eq_neg_one
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

tactic: decide
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (o.oangle x y).sign = -1
⊢ -1 ≠ 0
state_after: no goals
Theorem: List.support_formPerm_of_nodup
File: Mathlib/GroupTheory/Perm/List.lean

tactic: rw [← Finset.coe_inj]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
l✝ : List α
x : α
inst✝ : Fintype α
l : List α
h : l.Nodup
h' : ∀ (x : α), l ≠ [x]
⊢ l.formPerm.support = l.toFinset
state_after: α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
l✝ : List α
x : α
inst✝ : Fintype α
l : List α
h : l.Nodup
h' : ∀ (x : α), l ≠ [x]
⊢ ↑l.formPerm.support = ↑l.toFinset

tactic: convert support_formPerm_of_nodup' _ h h'
state_before: α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
l✝ : List α
x : α
inst✝ : Fintype α
l : List α
h : l.Nodup
h' : ∀ (x : α), l ≠ [x]
⊢ ↑l.formPerm.support = ↑l.toFinset
state_after: case h.e'_2
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
l✝ : List α
x : α
inst✝ : Fintype α
l : List α
h : l.Nodup
h' : ∀ (x : α), l ≠ [x]
⊢ ↑l.formPerm.support = {x | l.formPerm x ≠ x}

tactic: simp [Set.ext_iff]
state_before: case h.e'_2
α : Type u_1
β : Type u_2
inst✝¹ : DecidableEq α
l✝ : List α
x : α
inst✝ : Fintype α
l : List α
h : l.Nodup
h' : ∀ (x : α), l ≠ [x]
⊢ ↑l.formPerm.support = {x | l.formPerm x ≠ x}
state_after: no goals
Theorem: eq_of_div_eq_one
File: Mathlib/Algebra/Group/Basic.lean

tactic: rwa [← div_eq_mul_inv]
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
h : a / b = 1
⊢ a * b⁻¹ = 1
state_after: no goals
Theorem: LSeriesSummable.of_re_le_re
File: Mathlib/NumberTheory/LSeries/Basic.lean

tactic: rw [LSeriesSummable, ← summable_norm_iff] at hf ⊢
state_before: f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
hf : LSeriesSummable f s
⊢ LSeriesSummable f s'
state_after: f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
hf : Summable fun x => ‖term f s x‖
⊢ Summable fun x => ‖term f s' x‖

tactic: exact hf.of_nonneg_of_le (fun _ ↦ norm_nonneg _) (norm_term_le_of_re_le_re f h)
state_before: f : ℕ → ℂ
s s' : ℂ
h : s.re ≤ s'.re
hf : Summable fun x => ‖term f s x‖
⊢ Summable fun x => ‖term f s' x‖
state_after: no goals
Theorem: OmegaCompletePartialOrder.continuous_id
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: intro c
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
⊢ Continuous OrderHom.id
state_after: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
c : Chain α
⊢ OrderHom.id (ωSup c) = ωSup (c.map OrderHom.id)

tactic: rw [c.map_id]
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
c : Chain α
⊢ OrderHom.id (ωSup c) = ωSup (c.map OrderHom.id)
state_after: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
c : Chain α
⊢ OrderHom.id (ωSup c) = ωSup c

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝² : OmegaCompletePartialOrder α
inst✝¹ : OmegaCompletePartialOrder β
inst✝ : OmegaCompletePartialOrder γ
f : α →o β
g : β →o γ
c : Chain α
⊢ OrderHom.id (ωSup c) = ωSup c
state_after: no goals
Theorem: bernsteinPolynomial.flip
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

tactic: simp [bernsteinPolynomial, h, tsub_tsub_assoc, mul_right_comm]
state_before: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
h : ν ≤ n
⊢ (bernsteinPolynomial R n ν).comp (1 - X) = bernsteinPolynomial R n (n - ν)
state_after: no goals
Theorem: ClusterPt.of_le_nhds
File: Mathlib/Topology/Basic.lean

tactic: rwa [ClusterPt, inf_eq_right.mpr H]
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝¹ : TopologicalSpace X
f : Filter X
H : f ≤ 𝓝 x
inst✝ : f.NeBot
⊢ ClusterPt x f
state_after: no goals
Theorem: Stream'.WSeq.flatten_think
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [flatten, think]
state_before: α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
⊢ Seq.destruct (flatten c.think) = some (none, flatten c)
state_after: no goals
Theorem: Ctop.Realizer.ext'
File: Mathlib/Data/Analysis/Topology.lean

tactic: refine TopologicalSpace.ext_nhds fun x ↦ ?_
state_before: α : Type u_1
β : Type u_2
σ✝ : Type u_3
τ : Type u_4
T : TopologicalSpace α
σ : Type u_5
F : Ctop α σ
H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ F.f b ∧ F.f b ⊆ s
⊢ F.toTopsp = T
state_after: α : Type u_1
β : Type u_2
σ✝ : Type u_3
τ : Type u_4
T : TopologicalSpace α
σ : Type u_5
F : Ctop α σ
H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ F.f b ∧ F.f b ⊆ s
x : α
⊢ 𝓝 x = 𝓝 x

tactic: ext s
state_before: α : Type u_1
β : Type u_2
σ✝ : Type u_3
τ : Type u_4
T : TopologicalSpace α
σ : Type u_5
F : Ctop α σ
H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ F.f b ∧ F.f b ⊆ s
x : α
⊢ 𝓝 x = 𝓝 x
state_after: case a
α : Type u_1
β : Type u_2
σ✝ : Type u_3
τ : Type u_4
T : TopologicalSpace α
σ : Type u_5
F : Ctop α σ
H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ F.f b ∧ F.f b ⊆ s
x : α
s : Set α
⊢ s ∈ 𝓝 x ↔ s ∈ 𝓝 x

tactic: rw [mem_nhds_toTopsp, H]
state_before: case a
α : Type u_1
β : Type u_2
σ✝ : Type u_3
τ : Type u_4
T : TopologicalSpace α
σ : Type u_5
F : Ctop α σ
H : ∀ (a : α) (s : Set α), s ∈ 𝓝 a ↔ ∃ b, a ∈ F.f b ∧ F.f b ⊆ s
x : α
s : Set α
⊢ s ∈ 𝓝 x ↔ s ∈ 𝓝 x
state_after: no goals
Theorem: Real.volume_le_diam
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: by_cases hs : Bornology.IsBounded s
state_before: ι : Type u_1
inst✝ : Fintype ι
s : Set ℝ
⊢ volume s ≤ EMetric.diam s
state_after: case pos
ι : Type u_1
inst✝ : Fintype ι
s : Set ℝ
hs : Bornology.IsBounded s
⊢ volume s ≤ EMetric.diam s

case neg
ι : Type u_1
inst✝ : Fintype ι
s : Set ℝ
hs : ¬Bornology.IsBounded s
⊢ volume s ≤ EMetric.diam s

tactic: rw [Real.ediam_eq hs, ← volume_Icc]
state_before: case pos
ι : Type u_1
inst✝ : Fintype ι
s : Set ℝ
hs : Bornology.IsBounded s
⊢ volume s ≤ EMetric.diam s
state_after: case pos
ι : Type u_1
inst✝ : Fintype ι
s : Set ℝ
hs : Bornology.IsBounded s
⊢ volume s ≤ volume (Icc (sInf s) (sSup s))

tactic: exact volume.mono hs.subset_Icc_sInf_sSup
state_before: case pos
ι : Type u_1
inst✝ : Fintype ι
s : Set ℝ
hs : Bornology.IsBounded s
⊢ volume s ≤ volume (Icc (sInf s) (sSup s))
state_after: no goals

tactic: rw [Metric.ediam_of_unbounded hs]
state_before: case neg
ι : Type u_1
inst✝ : Fintype ι
s : Set ℝ
hs : ¬Bornology.IsBounded s
⊢ volume s ≤ EMetric.diam s
state_after: case neg
ι : Type u_1
inst✝ : Fintype ι
s : Set ℝ
hs : ¬Bornology.IsBounded s
⊢ volume s ≤ ⊤

tactic: exact le_top
state_before: case neg
ι : Type u_1
inst✝ : Fintype ι
s : Set ℝ
hs : ¬Bornology.IsBounded s
⊢ volume s ≤ ⊤
state_after: no goals
Theorem: singleton_mul_mem_nhds_of_nhds_one
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simpa only [mul_one] using singleton_mul_mem_nhds a h
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝² : TopologicalSpace α
inst✝¹ : Group α
inst✝ : ContinuousConstSMul α α
s t : Set α
a : α
h : s ∈ 𝓝 1
⊢ {a} * s ∈ 𝓝 a
state_after: no goals
Theorem: List.cyclicPermutations_rotate
File: Mathlib/Data/List/Rotate.lean

tactic: refine ext_get this fun n hn hn' => ?_
state_before: α : Type u
l✝ l' l : List α
k : ℕ
this : (l.rotate k).cyclicPermutations.length = (l.cyclicPermutations.rotate k).length
⊢ (l.rotate k).cyclicPermutations = l.cyclicPermutations.rotate k
state_after: α : Type u
l✝ l' l : List α
k : ℕ
this : (l.rotate k).cyclicPermutations.length = (l.cyclicPermutations.rotate k).length
n : ℕ
hn : n < (l.rotate k).cyclicPermutations.length
hn' : n < (l.cyclicPermutations.rotate k).length
⊢ (l.rotate k).cyclicPermutations.get ⟨n, hn⟩ = (l.cyclicPermutations.rotate k).get ⟨n, hn'⟩

tactic: rw [get_rotate, get_cyclicPermutations, rotate_rotate, ← rotate_mod, Nat.add_comm]
state_before: α : Type u
l✝ l' l : List α
k : ℕ
this : (l.rotate k).cyclicPermutations.length = (l.cyclicPermutations.rotate k).length
n : ℕ
hn : n < (l.rotate k).cyclicPermutations.length
hn' : n < (l.cyclicPermutations.rotate k).length
⊢ (l.rotate k).cyclicPermutations.get ⟨n, hn⟩ = (l.cyclicPermutations.rotate k).get ⟨n, hn'⟩
state_after: α : Type u
l✝ l' l : List α
k : ℕ
this : (l.rotate k).cyclicPermutations.length = (l.cyclicPermutations.rotate k).length
n : ℕ
hn : n < (l.rotate k).cyclicPermutations.length
hn' : n < (l.cyclicPermutations.rotate k).length
⊢ l.rotate ((↑⟨n, hn⟩ + k) % l.length) = l.cyclicPermutations.get ⟨(↑⟨n, hn'⟩ + k) % l.cyclicPermutations.length, ⋯⟩

tactic: cases l <;> simp
state_before: α : Type u
l✝ l' l : List α
k : ℕ
this : (l.rotate k).cyclicPermutations.length = (l.cyclicPermutations.rotate k).length
n : ℕ
hn : n < (l.rotate k).cyclicPermutations.length
hn' : n < (l.cyclicPermutations.rotate k).length
⊢ l.rotate ((↑⟨n, hn⟩ + k) % l.length) = l.cyclicPermutations.get ⟨(↑⟨n, hn'⟩ + k) % l.cyclicPermutations.length, ⋯⟩
state_after: no goals

tactic: cases l
state_before: α : Type u
l✝ l' l : List α
k : ℕ
⊢ (l.rotate k).cyclicPermutations.length = (l.cyclicPermutations.rotate k).length
state_after: case nil
α : Type u
l l' : List α
k : ℕ
⊢ ([].rotate k).cyclicPermutations.length = ([].cyclicPermutations.rotate k).length

case cons
α : Type u
l l' : List α
k : ℕ
head✝ : α
tail✝ : List α
⊢ ((head✝ :: tail✝).rotate k).cyclicPermutations.length = ((head✝ :: tail✝).cyclicPermutations.rotate k).length

tactic: simp
state_before: case nil
α : Type u
l l' : List α
k : ℕ
⊢ ([].rotate k).cyclicPermutations.length = ([].cyclicPermutations.rotate k).length
state_after: no goals

tactic: rw [length_cyclicPermutations_of_ne_nil] <;> simp
state_before: case cons
α : Type u
l l' : List α
k : ℕ
head✝ : α
tail✝ : List α
⊢ ((head✝ :: tail✝).rotate k).cyclicPermutations.length = ((head✝ :: tail✝).cyclicPermutations.rotate k).length
state_after: no goals
Theorem: Polynomial.coeff_restriction
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: simp only [restriction, coeff_monomial, finset_sum_coeff, mem_support_iff, Finset.sum_ite_eq',
  Ne, ite_not]
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
⊢ ↑(p.restriction.coeff n) = p.coeff n
state_after: R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
⊢ ↑(if p.coeff n = 0 then 0 else ⟨p.coeff n, ⋯⟩) = p.coeff n

tactic: split_ifs with h
state_before: R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
⊢ ↑(if p.coeff n = 0 then 0 else ⟨p.coeff n, ⋯⟩) = p.coeff n
state_after: case pos
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
h : p.coeff n = 0
⊢ ↑0 = p.coeff n

case neg
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
h : ¬p.coeff n = 0
⊢ ↑⟨p.coeff n, ⋯⟩ = p.coeff n

tactic: rw [h]
state_before: case pos
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
h : p.coeff n = 0
⊢ ↑0 = p.coeff n
state_after: case pos
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
h : p.coeff n = 0
⊢ ↑0 = 0

tactic: rfl
state_before: case pos
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
h : p.coeff n = 0
⊢ ↑0 = 0
state_after: no goals

tactic: rfl
state_before: case neg
R : Type u
S : Type u_1
inst✝ : Ring R
p : R[X]
n : ℕ
h : ¬p.coeff n = 0
⊢ ↑⟨p.coeff n, ⋯⟩ = p.coeff n
state_after: no goals
Theorem: CategoryTheory.Triangulated.Subcategory.W.shift
File: Mathlib/CategoryTheory/Triangulated/Subcategory.lean

tactic: rw [← smul_mem_W_iff _ _ (n.negOnePow)]
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : HasZeroObject C
inst✝³ : HasShift C ℤ
inst✝² : Preadditive C
inst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝ : Pretriangulated C
S : Subcategory C
X₁ X₂ : C
f : X₁ ⟶ X₂
hf : S.W f
n : ℤ
⊢ S.W ((shiftFunctor C n).map f)
state_after: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : HasZeroObject C
inst✝³ : HasShift C ℤ
inst✝² : Preadditive C
inst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝ : Pretriangulated C
S : Subcategory C
X₁ X₂ : C
f : X₁ ⟶ X₂
hf : S.W f
n : ℤ
⊢ S.W (n.negOnePow • (shiftFunctor C n).map f)

tactic: obtain ⟨X₃, g, h, hT, mem⟩ := hf
state_before: C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : HasZeroObject C
inst✝³ : HasShift C ℤ
inst✝² : Preadditive C
inst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝ : Pretriangulated C
S : Subcategory C
X₁ X₂ : C
f : X₁ ⟶ X₂
hf : S.W f
n : ℤ
⊢ S.W (n.negOnePow • (shiftFunctor C n).map f)
state_after: case intro.intro.intro.intro
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : HasZeroObject C
inst✝³ : HasShift C ℤ
inst✝² : Preadditive C
inst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝ : Pretriangulated C
S : Subcategory C
X₁ X₂ : C
f : X₁ ⟶ X₂
n : ℤ
X₃ : C
g : X₂ ⟶ X₃
h : X₃ ⟶ (shiftFunctor C 1).obj X₁
hT : Triangle.mk f g h ∈ distinguishedTriangles
mem : S.P X₃
⊢ S.W (n.negOnePow • (shiftFunctor C n).map f)

tactic: exact ⟨_, _, _, Pretriangulated.Triangle.shift_distinguished _ hT n, S.shift _ _ mem⟩
state_before: case intro.intro.intro.intro
C : Type u_1
inst✝⁵ : Category.{u_2, u_1} C
inst✝⁴ : HasZeroObject C
inst✝³ : HasShift C ℤ
inst✝² : Preadditive C
inst✝¹ : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝ : Pretriangulated C
S : Subcategory C
X₁ X₂ : C
f : X₁ ⟶ X₂
n : ℤ
X₃ : C
g : X₂ ⟶ X₃
h : X₃ ⟶ (shiftFunctor C 1).obj X₁
hT : Triangle.mk f g h ∈ distinguishedTriangles
mem : S.P X₃
⊢ S.W (n.negOnePow • (shiftFunctor C n).map f)
state_after: no goals
Theorem: Finset.disjSups_union_right
File: Mathlib/Data/Finset/Sups.lean

tactic: simp [disjSups, filter_union, image_union]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : DecidableEq α
inst✝³ : DecidableEq β
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
inst✝ : DecidableRel Disjoint
s s₁ s₂ t t₁ t₂ u : Finset α
a b c : α
⊢ s ○ (t₁ ∪ t₂) = s ○ t₁ ∪ s ○ t₂
state_after: no goals
Theorem: CategoryTheory.kernel_zero_of_nonzero_from_simple
File: Mathlib/CategoryTheory/Simple.lean

tactic: classical
  by_contra h
  haveI := isIso_of_mono_of_nonzero h
  exact w (eq_zero_of_epi_kernel f)
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
X Y : C
inst✝¹ : Simple X
f : X ⟶ Y
inst✝ : HasKernel f
w : f ≠ 0
⊢ kernel.ι f = 0
state_after: no goals

tactic: by_contra h
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
X Y : C
inst✝¹ : Simple X
f : X ⟶ Y
inst✝ : HasKernel f
w : f ≠ 0
⊢ kernel.ι f = 0
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
X Y : C
inst✝¹ : Simple X
f : X ⟶ Y
inst✝ : HasKernel f
w : f ≠ 0
h : ¬kernel.ι f = 0
⊢ False

tactic: haveI := isIso_of_mono_of_nonzero h
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
X Y : C
inst✝¹ : Simple X
f : X ⟶ Y
inst✝ : HasKernel f
w : f ≠ 0
h : ¬kernel.ι f = 0
⊢ False
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
X Y : C
inst✝¹ : Simple X
f : X ⟶ Y
inst✝ : HasKernel f
w : f ≠ 0
h : ¬kernel.ι f = 0
this : IsIso (kernel.ι f)
⊢ False

tactic: exact w (eq_zero_of_epi_kernel f)
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : HasZeroMorphisms C
X Y : C
inst✝¹ : Simple X
f : X ⟶ Y
inst✝ : HasKernel f
w : f ≠ 0
h : ¬kernel.ι f = 0
this : IsIso (kernel.ι f)
⊢ False
state_after: no goals
Theorem: infEdist_inv_inv
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [← image_inv, infEdist_image isometry_inv]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s✝ t : Set E
x✝ y x : E
s : Set E
⊢ infEdist x⁻¹ s⁻¹ = infEdist x s
state_after: no goals
Theorem: Topology.WithLowerSet.toLowerSet_specializes_toLowerSet
File: Mathlib/Topology/Order/UpperLowerSetTopology.lean

tactic: simp_rw [specializes_iff_closure_subset, IsLowerSet.closure_singleton, Ici_subset_Ici,
  toLowerSet_le_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
a b : α
⊢ toLowerSet a ⤳ toLowerSet b ↔ a ≤ b
state_after: no goals
Theorem: IsPGroup.of_bot
File: Mathlib/GroupTheory/PGroup.lean

tactic: rw [← Nat.card_eq_fintype_card, Subgroup.card_bot, pow_zero]
state_before: p : ℕ
G : Type u_1
inst✝ : Group G
⊢ card ↥⊥ = p ^ ?m.2807
state_after: no goals
Theorem: geom_sum₂_self
File: Mathlib/Algebra/GeomSum.lean

tactic: simp_rw [← pow_add]
state_before: α✝ : Type u
α : Type u_1
inst✝ : CommRing α
x : α
n : ℕ
⊢ ∑ i ∈ range n, x ^ i * x ^ (n - 1 - i) = ∑ i ∈ range n, x ^ (i + (n - 1 - i))
state_after: no goals

tactic: rw [Finset.card_range, nsmul_eq_mul]
state_before: α✝ : Type u
α : Type u_1
inst✝ : CommRing α
x : α
n : ℕ
⊢ (range n).card • x ^ (n - 1) = ↑n * x ^ (n - 1)
state_after: no goals
Theorem: mem_ball_one_iff
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [mem_ball, dist_one_right]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ a ∈ ball 1 r ↔ ‖a‖ < r
state_after: no goals
Theorem: UpperHalfPlane.IsBoundedAtImInfty.mul
File: Mathlib/Analysis/Complex/UpperHalfPlane/FunctionsBoundedAtInfty.lean

tactic: simpa only [Pi.one_apply, mul_one, norm_eq_abs] using hf.mul hg
state_before: f g : ℍ → ℂ
hf : IsBoundedAtImInfty f
hg : IsBoundedAtImInfty g
⊢ IsBoundedAtImInfty (f * g)
state_after: no goals
Theorem: Real.convergent_of_zero
File: Mathlib/NumberTheory/DiophantineApproximation.lean

tactic: induction' n with n ih
state_before: n : ℕ
⊢ convergent 0 n = 0
state_after: case zero

⊢ convergent 0 0 = 0

case succ
n : ℕ
ih : convergent 0 n = 0
⊢ convergent 0 (n + 1) = 0

tactic: simp only [Nat.zero_eq, convergent_zero, floor_zero, cast_zero]
state_before: case zero

⊢ convergent 0 0 = 0
state_after: no goals

tactic: simp only [ih, convergent_succ, floor_zero, cast_zero, fract_zero, add_zero, inv_zero]
state_before: case succ
n : ℕ
ih : convergent 0 n = 0
⊢ convergent 0 (n + 1) = 0
state_after: no goals