1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Complex.cosh_three_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: have h1 : x + 2 * x = 3 * x := by ring
state_before: x y : ℂ
⊢ cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x

tactic: rw [← h1, cosh_add x (2 * x)]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh (3 * x) = 4 * cosh x ^ 3 - 3 * cosh x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * cosh (2 * x) + sinh x * sinh (2 * x) = 4 * cosh x ^ 3 - 3 * cosh x

tactic: simp only [cosh_two_mul, sinh_two_mul]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * cosh (2 * x) + sinh x * sinh (2 * x) = 4 * cosh x ^ 3 - 3 * cosh x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * (cosh x ^ 2 + sinh x ^ 2) + sinh x * (2 * sinh x * cosh x) = 4 * cosh x ^ 3 - 3 * cosh x

tactic: have h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2 := by ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ cosh x * (cosh x ^ 2 + sinh x ^ 2) + sinh x * (2 * sinh x * cosh x) = 4 * cosh x ^ 3 - 3 * cosh x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
⊢ cosh x * (cosh x ^ 2 + sinh x ^ 2) + sinh x * (2 * sinh x * cosh x) = 4 * cosh x ^ 3 - 3 * cosh x

tactic: rw [h2, sinh_sq]
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
⊢ cosh x * (cosh x ^ 2 + sinh x ^ 2) + sinh x * (2 * sinh x * cosh x) = 4 * cosh x ^ 3 - 3 * cosh x
state_after: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
⊢ cosh x * (cosh x ^ 2 + (cosh x ^ 2 - 1)) + 2 * cosh x * (cosh x ^ 2 - 1) = 4 * cosh x ^ 3 - 3 * cosh x

tactic: ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
h2 : sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
⊢ cosh x * (cosh x ^ 2 + (cosh x ^ 2 - 1)) + 2 * cosh x * (cosh x ^ 2 - 1) = 4 * cosh x ^ 3 - 3 * cosh x
state_after: no goals

tactic: ring
state_before: x y : ℂ
⊢ x + 2 * x = 3 * x
state_after: no goals

tactic: ring
state_before: x y : ℂ
h1 : x + 2 * x = 3 * x
⊢ sinh x * (2 * sinh x * cosh x) = 2 * cosh x * sinh x ^ 2
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.negAddY_self
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: rw [negAddY]
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
⊢ W'.negAddY P P = 0
state_after: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
⊢ -P y * P x ^ 3 * P z ^ 3 + 2 * P y * P y ^ 2 * P z ^ 3 - 3 * P x ^ 2 * P x * P y * P z ^ 2 * P z +
                                      3 * P x * P y * P x ^ 2 * P z * P z ^ 2 +
                                    P x ^ 3 * P y * P z ^ 3 -
                                  2 * P y ^ 2 * P y * P z ^ 3 +
                                W'.a₁ * P x * P y ^ 2 * P z ^ 4 +
                              W'.a₁ * P y * P x * P y * P z ^ 3 * P z -
                            W'.a₁ * P x * P y * P y * P z * P z ^ 3 -
                          W'.a₁ * P y ^ 2 * P x * P z ^ 4 -
                        2 * W'.a₂ * P x * P x * P y * P z ^ 4 * P z +
                      2 * W'.a₂ * P x * P y * P x * P z * P z ^ 4 +
                    W'.a₃ * P y ^ 2 * P z ^ 6 -
                  W'.a₃ * P y ^ 2 * P z ^ 6 -
                W'.a₄ * P x * P y * P z ^ 6 * P z -
              W'.a₄ * P x * P y * P z ^ 4 * P z ^ 3 +
            W'.a₄ * P y * P x * P z ^ 3 * P z ^ 4 +
          W'.a₄ * P x * P y * P z * P z ^ 6 -
        2 * W'.a₆ * P y * P z ^ 6 * P z ^ 3 +
      2 * W'.a₆ * P y * P z ^ 3 * P z ^ 6 =
    0

tactic: ring
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → R
⊢ -P y * P x ^ 3 * P z ^ 3 + 2 * P y * P y ^ 2 * P z ^ 3 - 3 * P x ^ 2 * P x * P y * P z ^ 2 * P z +
                                      3 * P x * P y * P x ^ 2 * P z * P z ^ 2 +
                                    P x ^ 3 * P y * P z ^ 3 -
                                  2 * P y ^ 2 * P y * P z ^ 3 +
                                W'.a₁ * P x * P y ^ 2 * P z ^ 4 +
                              W'.a₁ * P y * P x * P y * P z ^ 3 * P z -
                            W'.a₁ * P x * P y * P y * P z * P z ^ 3 -
                          W'.a₁ * P y ^ 2 * P x * P z ^ 4 -
                        2 * W'.a₂ * P x * P x * P y * P z ^ 4 * P z +
                      2 * W'.a₂ * P x * P y * P x * P z * P z ^ 4 +
                    W'.a₃ * P y ^ 2 * P z ^ 6 -
                  W'.a₃ * P y ^ 2 * P z ^ 6 -
                W'.a₄ * P x * P y * P z ^ 6 * P z -
              W'.a₄ * P x * P y * P z ^ 4 * P z ^ 3 +
            W'.a₄ * P y * P x * P z ^ 3 * P z ^ 4 +
          W'.a₄ * P x * P y * P z * P z ^ 6 -
        2 * W'.a₆ * P y * P z ^ 6 * P z ^ 3 +
      2 * W'.a₆ * P y * P z ^ 3 * P z ^ 6 =
    0
state_after: no goals
Theorem: Int.le_floor_add_floor
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← sub_le_iff_le_add, le_floor, Int.cast_sub, sub_le_comm, Int.cast_sub, Int.cast_one]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ⌊a + b⌋ - 1 ≤ ⌊a⌋ + ⌊b⌋
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌊a + b⌋ - 1 - a ≤ ↑⌊b⌋

tactic: refine le_trans ?_ (sub_one_lt_floor _).le
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌊a + b⌋ - 1 - a ≤ ↑⌊b⌋
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌊a + b⌋ - 1 - a ≤ b - 1

tactic: rw [sub_le_iff_le_add', ← add_sub_assoc, sub_le_sub_iff_right]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌊a + b⌋ - 1 - a ≤ b - 1
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌊a + b⌋ ≤ a + b

tactic: exact floor_le _
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ ↑⌊a + b⌋ ≤ a + b
state_after: no goals
Theorem: Rat.cast_commute
File: Mathlib/Data/Rat/Cast/Defs.lean

tactic: simpa only [cast_def] using (r.1.cast_commute a).div_left (r.2.cast_commute a)
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
inst✝ : DivisionRing α
p q r : ℚ
a : α
⊢ Commute (↑r) a
state_after: no goals
Theorem: DFinsupp.mk_sub
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: simp only [sub_apply, mk_apply]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → AddGroup (β i)
s : Finset ι
x y : (i : ↑↑s) → β ↑i
i : ι
⊢ (mk s (x - y)) i = (mk s x - mk s y) i
state_after: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → AddGroup (β i)
s : Finset ι
x y : (i : ↑↑s) → β ↑i
i : ι
⊢ (if H : i ∈ s then (x - y) ⟨i, H⟩ else 0) = (if H : i ∈ s then x ⟨i, H⟩ else 0) - if H : i ∈ s then y ⟨i, H⟩ else 0

tactic: split_ifs <;> [rfl; rw [sub_zero]]
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝¹ : DecidableEq ι
inst✝ : (i : ι) → AddGroup (β i)
s : Finset ι
x y : (i : ↑↑s) → β ↑i
i : ι
⊢ (if H : i ∈ s then (x - y) ⟨i, H⟩ else 0) = (if H : i ∈ s then x ⟨i, H⟩ else 0) - if H : i ∈ s then y ⟨i, H⟩ else 0
state_after: no goals
Theorem: StrictMonoOn.Iic_union_Ici
File: Mathlib/Order/Monotone/Union.lean

tactic: rw [← strictMonoOn_univ, ← @Iic_union_Ici _ _ a]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
h₁ : StrictMonoOn f (Iic a)
h₂ : StrictMonoOn f (Ici a)
⊢ StrictMono f
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
h₁ : StrictMonoOn f (Iic a)
h₂ : StrictMonoOn f (Ici a)
⊢ StrictMonoOn f (Iic a ∪ Ici a)

tactic: exact StrictMonoOn.union h₁ h₂ isGreatest_Iic isLeast_Ici
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : Preorder β
a : α
f : α → β
h₁ : StrictMonoOn f (Iic a)
h₂ : StrictMonoOn f (Ici a)
⊢ StrictMonoOn f (Iic a ∪ Ici a)
state_after: no goals
Theorem: MeasureTheory.Measure.toSphere_apply_univ
File: Mathlib/MeasureTheory/Constructions/HaarToSphere.lean

tactic: nontriviality E
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
⊢ μ.toSphere univ = ↑(dim E) * μ (ball 0 1)
state_after: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
a✝ : Nontrivial E
⊢ μ.toSphere univ = ↑(dim E) * μ (ball 0 1)

tactic: rw [toSphere_apply_univ', measure_diff_null (measure_singleton _)]
state_before: E : Type u_1
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace ℝ E
inst✝³ : FiniteDimensional ℝ E
inst✝² : MeasurableSpace E
inst✝¹ : BorelSpace E
μ : Measure E
inst✝ : μ.IsAddHaarMeasure
a✝ : Nontrivial E
⊢ μ.toSphere univ = ↑(dim E) * μ (ball 0 1)
state_after: no goals
Theorem: Batteries.UnionFind.parent_link
File: .lake/packages/batteries/Batteries/Data/UnionFind/Lemmas.lean

tactic: simp [rankD_eq]
state_before: self : UnionFind
x y : Fin self.size
yroot : self.parent ↑y = ↑y
i : Nat
⊢ (self.link x y yroot).parent i =
    if ↑x = ↑y then self.parent i
    else
      if self.rank ↑y < self.rank ↑x then if ↑y = i then ↑x else self.parent i else if ↑x = i then ↑y else self.parent i
state_after: self : UnionFind
x y : Fin self.size
yroot : self.parent ↑y = ↑y
i : Nat
⊢ (self.link x y yroot).parent i =
    if ↑x = ↑y then self.parent i
    else
      if self.arr[↑y].rank < self.arr[↑x].rank then if ↑y = i then ↑x else self.parent i
      else if ↑x = i then ↑y else self.parent i

tactic: exact parentD_linkAux
state_before: self : UnionFind
x y : Fin self.size
yroot : self.parent ↑y = ↑y
i : Nat
⊢ (self.link x y yroot).parent i =
    if ↑x = ↑y then self.parent i
    else
      if self.arr[↑y].rank < self.arr[↑x].rank then if ↑y = i then ↑x else self.parent i
      else if ↑x = i then ↑y else self.parent i
state_after: no goals
Theorem: UniqueFactorizationMonoid.of_exists_unique_irreducible_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: convert eif using 7
state_before: α : Type u_1
inst✝ : CancelCommMonoidWithZero α
eif : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Irreducible b) ∧ f.prod ~ᵤ a
uif :
  ∀ (f g : Multiset α),
    (∀ x ∈ f, Irreducible x) → (∀ x ∈ g, Irreducible x) → f.prod ~ᵤ g.prod → Multiset.Rel Associated f g
⊢ ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Prime b) ∧ f.prod ~ᵤ a
state_after: case h.h'.h.e'_2.h.h.e'_1.h.h'.a
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
eif : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Irreducible b) ∧ f.prod ~ᵤ a
uif :
  ∀ (f g : Multiset α),
    (∀ x ∈ f, Irreducible x) → (∀ x ∈ g, Irreducible x) → f.prod ~ᵤ g.prod → Multiset.Rel Associated f g
a✝³ : α
a✝² : a✝³ ≠ 0
x✝ : Multiset α
a✝¹ : α
a✝ : a✝¹ ∈ x✝
⊢ Prime a✝¹ ↔ Irreducible a✝¹

tactic: simp_rw [irreducible_iff_prime_of_exists_unique_irreducible_factors eif uif]
state_before: case h.h'.h.e'_2.h.h.e'_1.h.h'.a
α : Type u_1
inst✝ : CancelCommMonoidWithZero α
eif : ∀ (a : α), a ≠ 0 → ∃ f, (∀ b ∈ f, Irreducible b) ∧ f.prod ~ᵤ a
uif :
  ∀ (f g : Multiset α),
    (∀ x ∈ f, Irreducible x) → (∀ x ∈ g, Irreducible x) → f.prod ~ᵤ g.prod → Multiset.Rel Associated f g
a✝³ : α
a✝² : a✝³ ≠ 0
x✝ : Multiset α
a✝¹ : α
a✝ : a✝¹ ∈ x✝
⊢ Prime a✝¹ ↔ Irreducible a✝¹
state_after: no goals
Theorem: FractionalIdeal.count_finsupp_prod
File: Mathlib/RingTheory/DedekindDomain/Factorization.lean

tactic: rw [Finsupp.prod, count_prod]
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
exps : HeightOneSpectrum R →₀ ℤ
⊢ count K v (exps.prod fun x x_1 => ↑x.asIdeal ^ x_1) = exps v
state_after: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
exps : HeightOneSpectrum R →₀ ℤ
⊢ ∑ i ∈ exps.support, count K v (↑i.asIdeal ^ exps i) = exps v

case hS
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
exps : HeightOneSpectrum R →₀ ℤ
⊢ ∀ i ∈ exps.support, ↑i.asIdeal ^ exps i ≠ 0

tactic: simp only [count_zpow, count_maximal, mul_ite, mul_one, mul_zero, Finset.sum_ite_eq',
  exps.mem_support_iff, ne_eq, ite_not, ite_eq_right_iff, @eq_comm ℤ 0, imp_self]
state_before: R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
exps : HeightOneSpectrum R →₀ ℤ
⊢ ∑ i ∈ exps.support, count K v (↑i.asIdeal ^ exps i) = exps v
state_after: no goals

tactic: exact fun v hv ↦ zpow_ne_zero _ (coeIdeal_ne_zero.mpr v.ne_bot)
state_before: case hS
R : Type u_1
inst✝⁴ : CommRing R
K : Type u_2
inst✝³ : Field K
inst✝² : Algebra R K
inst✝¹ : IsFractionRing R K
inst✝ : IsDedekindDomain R
v : HeightOneSpectrum R
exps : HeightOneSpectrum R →₀ ℤ
⊢ ∀ i ∈ exps.support, ↑i.asIdeal ^ exps i ≠ 0
state_after: no goals
Theorem: Filter.map_div_atTop_eq_nat
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [← Nat.lt_succ_iff, Nat.div_lt_iff_lt_mul hk, Nat.succ_eq_add_one,
add_assoc, tsub_add_cancel_of_le (Nat.one_le_iff_ne_zero.2 hk.ne'), add_mul, one_mul]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
k : ℕ
hk : 0 < k
a b : ℕ
x✝ : b ≥ 1
⊢ a / k ≤ b ↔ a ≤ (fun b => b * k + (k - 1)) b
state_after: no goals

tactic: rw [Nat.mul_div_cancel b hk]
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
k : ℕ
hk : 0 < k
b : ℕ
x✝ : b ≥ 1
⊢ b = b * k / k
state_after: no goals
Theorem: SimpleGraph.Walk.darts_dropUntil_subset
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rw [← take_spec p h, darts_append, List.mem_append]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ x✝ y : V
inst✝ : DecidableEq V
u v w : V
p : G.Walk v w
h : u ∈ p.support
x : G.Dart
hx : x ∈ (p.dropUntil u h).darts
⊢ x ∈ p.darts
state_after: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ x✝ y : V
inst✝ : DecidableEq V
u v w : V
p : G.Walk v w
h : u ∈ p.support
x : G.Dart
hx : x ∈ (p.dropUntil u h).darts
⊢ x ∈ (p.takeUntil u h).darts ∨ x ∈ (p.dropUntil u h).darts

tactic: exact Or.inr hx
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ x✝ y : V
inst✝ : DecidableEq V
u v w : V
p : G.Walk v w
h : u ∈ p.support
x : G.Dart
hx : x ∈ (p.dropUntil u h).darts
⊢ x ∈ (p.takeUntil u h).darts ∨ x ∈ (p.dropUntil u h).darts
state_after: no goals
Theorem: List.foldrIdx_eq_foldrIdxSpec
File: Mathlib/Data/List/Indexes.lean

tactic: induction as generalizing start
state_before: α : Type u
β : Type v
f : ℕ → α → β → β
b : β
as : List α
start : ℕ
⊢ foldrIdx f b as start = foldrIdxSpec f b as start
state_after: case nil
α : Type u
β : Type v
f : ℕ → α → β → β
b : β
start : ℕ
⊢ foldrIdx f b [] start = foldrIdxSpec f b [] start

case cons
α : Type u
β : Type v
f : ℕ → α → β → β
b : β
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (start : ℕ), foldrIdx f b tail✝ start = foldrIdxSpec f b tail✝ start
start : ℕ
⊢ foldrIdx f b (head✝ :: tail✝) start = foldrIdxSpec f b (head✝ :: tail✝) start

tactic: rfl
state_before: case nil
α : Type u
β : Type v
f : ℕ → α → β → β
b : β
start : ℕ
⊢ foldrIdx f b [] start = foldrIdxSpec f b [] start
state_after: no goals

tactic: simp only [foldrIdx, foldrIdxSpec_cons, *]
state_before: case cons
α : Type u
β : Type v
f : ℕ → α → β → β
b : β
head✝ : α
tail✝ : List α
tail_ih✝ : ∀ (start : ℕ), foldrIdx f b tail✝ start = foldrIdxSpec f b tail✝ start
start : ℕ
⊢ foldrIdx f b (head✝ :: tail✝) start = foldrIdxSpec f b (head✝ :: tail✝) start
state_after: no goals
Theorem: Mathlib.Meta.NormNum.IsRat.to_isNat
File: Mathlib/Tactic/NormNum/Result.lean

tactic: simp
state_before: α : Type u_1
inst✝ : Ring α
a✝ : ℕ
inv : Invertible ↑1
this : Invertible 1
⊢ ↑(Int.ofNat a✝) * ⅟↑1 = ↑a✝
state_after: no goals
Theorem: Polynomial.Chebyshev.U_neg_sub_two
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: simpa [sub_eq_add_neg, add_comm] using U_neg R (n + 2)
state_before: R : Type u_1
S : Type u_2
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℤ
⊢ U R (-n - 2) = -U R n
state_after: no goals
Theorem: csSup_inv
File: Mathlib/Algebra/Order/Pointwise.lean

tactic: rw [← image_inv]
state_before: α : Type u_1
inst✝³ : ConditionallyCompleteLattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
s t : Set α
hs₀ : s.Nonempty
hs₁ : BddBelow s
⊢ sSup s⁻¹ = (sInf s)⁻¹
state_after: α : Type u_1
inst✝³ : ConditionallyCompleteLattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
s t : Set α
hs₀ : s.Nonempty
hs₁ : BddBelow s
⊢ sSup (Inv.inv '' s) = (sInf s)⁻¹

tactic: exact ((OrderIso.inv α).map_csInf' hs₀ hs₁).symm
state_before: α : Type u_1
inst✝³ : ConditionallyCompleteLattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
s t : Set α
hs₀ : s.Nonempty
hs₁ : BddBelow s
⊢ sSup (Inv.inv '' s) = (sInf s)⁻¹
state_after: no goals
Theorem: Rat.mkRat_eq_zero
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

tactic: simp [mkRat_def, d0]
state_before: d : Nat
n : Int
d0 : d ≠ 0
⊢ mkRat n d = 0 ↔ n = 0
state_after: no goals
Theorem: List.ofFn_mul
File: Mathlib/Data/List/OfFn.lean

tactic: rw [Nat.add_mul, Nat.one_mul]
state_before: α : Type u
m n : ℕ
f : Fin (m * n) → α
i : Fin m
j : Fin n
⊢ ↑i * n + n = (↑i + 1) * n
state_after: no goals

tactic: induction' m with m IH
state_before: α : Type u
m n : ℕ
f : Fin (m * n) → α
⊢ ofFn f = (ofFn fun i => ofFn fun j => f ⟨↑i * n + ↑j, ⋯⟩).join
state_after: case zero
α : Type u
n : ℕ
f : Fin (0 * n) → α
⊢ ofFn f = (ofFn fun i => ofFn fun j => f ⟨↑i * n + ↑j, ⋯⟩).join

case succ
α : Type u
n m : ℕ
IH : ∀ (f : Fin (m * n) → α), ofFn f = (ofFn fun i => ofFn fun j => f ⟨↑i * n + ↑j, ⋯⟩).join
f : Fin ((m + 1) * n) → α
⊢ ofFn f = (ofFn fun i => ofFn fun j => f ⟨↑i * n + ↑j, ⋯⟩).join

tactic: simp [ofFn_zero, Nat.zero_mul, ofFn_zero, join]
state_before: case zero
α : Type u
n : ℕ
f : Fin (0 * n) → α
⊢ ofFn f = (ofFn fun i => ofFn fun j => f ⟨↑i * n + ↑j, ⋯⟩).join
state_after: no goals

tactic: simp_rw [ofFn_succ', succ_mul, join_concat, ofFn_add, IH]
state_before: case succ
α : Type u
n m : ℕ
IH : ∀ (f : Fin (m * n) → α), ofFn f = (ofFn fun i => ofFn fun j => f ⟨↑i * n + ↑j, ⋯⟩).join
f : Fin ((m + 1) * n) → α
⊢ ofFn f = (ofFn fun i => ofFn fun j => f ⟨↑i * n + ↑j, ⋯⟩).join
state_after: case succ
α : Type u
n m : ℕ
IH : ∀ (f : Fin (m * n) → α), ofFn f = (ofFn fun i => ofFn fun j => f ⟨↑i * n + ↑j, ⋯⟩).join
f : Fin ((m + 1) * n) → α
⊢ ((ofFn fun i => ofFn fun j => f (Fin.cast ⋯ (Fin.castAdd n ⟨↑i * n + ↑j, ⋯⟩))).join ++
      ofFn fun j => f (Fin.cast ⋯ (Fin.natAdd (m * n) j))) =
    (ofFn fun i => ofFn fun j => f ⟨↑i.castSucc * n + ↑j, ⋯⟩).join ++ ofFn fun j => f ⟨↑(Fin.last m) * n + ↑j, ⋯⟩

tactic: rfl
state_before: case succ
α : Type u
n m : ℕ
IH : ∀ (f : Fin (m * n) → α), ofFn f = (ofFn fun i => ofFn fun j => f ⟨↑i * n + ↑j, ⋯⟩).join
f : Fin ((m + 1) * n) → α
⊢ ((ofFn fun i => ofFn fun j => f (Fin.cast ⋯ (Fin.castAdd n ⟨↑i * n + ↑j, ⋯⟩))).join ++
      ofFn fun j => f (Fin.cast ⋯ (Fin.natAdd (m * n) j))) =
    (ofFn fun i => ofFn fun j => f ⟨↑i.castSucc * n + ↑j, ⋯⟩).join ++ ofFn fun j => f ⟨↑(Fin.last m) * n + ↑j, ⋯⟩
state_after: no goals
Theorem: Set.unbounded_le_inter_le
File: Mathlib/Order/Bounded.lean

tactic: rw [← not_bounded_iff, ← not_bounded_iff, not_iff_not]
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : LinearOrder α
a : α
⊢ Unbounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a ≤ b}) ↔ Unbounded (fun x x_1 => x ≤ x_1) s
state_after: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : LinearOrder α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a ≤ b}) ↔ Bounded (fun x x_1 => x ≤ x_1) s

tactic: exact bounded_le_inter_le a
state_before: α : Type u_1
r : α → α → Prop
s t : Set α
inst✝ : LinearOrder α
a : α
⊢ Bounded (fun x x_1 => x ≤ x_1) (s ∩ {b | a ≤ b}) ↔ Bounded (fun x x_1 => x ≤ x_1) s
state_after: no goals
Theorem: norm_mk_eq_zero
File: Mathlib/Analysis/Normed/Group/Quotient.lean

tactic: rwa [quotient_norm_eq_zero_iff, hS.closure_eq] at h
state_before: M : Type u_1
N : Type u_2
inst✝¹ : SeminormedAddCommGroup M
inst✝ : SeminormedAddCommGroup N
S : AddSubgroup M
hS : IsClosed ↑S
m : M
h : ‖(mk' S) m‖ = 0
⊢ m ∈ S
state_after: no goals
Theorem: Finsupp.neLocus_zero_right
File: Mathlib/Data/Finsupp/NeLocus.lean

tactic: ext
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : Zero N
f g : α →₀ N
⊢ f.neLocus 0 = f.support
state_after: case a
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : Zero N
f g : α →₀ N
a✝ : α
⊢ a✝ ∈ f.neLocus 0 ↔ a✝ ∈ f.support

tactic: rw [mem_neLocus, mem_support_iff, coe_zero, Pi.zero_apply]
state_before: case a
α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
inst✝² : DecidableEq α
inst✝¹ : DecidableEq N
inst✝ : Zero N
f g : α →₀ N
a✝ : α
⊢ a✝ ∈ f.neLocus 0 ↔ a✝ ∈ f.support
state_after: no goals
Theorem: riemannZeta_two_mul_nat
File: Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean

tactic: convert congr_arg ((↑) : ℝ → ℂ) (hasSum_zeta_nat hk).tsum_eq
state_before: k : ℕ
hk : k ≠ 0
⊢ riemannZeta (2 * ↑k) = (-1) ^ (k + 1) * 2 ^ (2 * k - 1) * ↑π ^ (2 * k) * ↑(bernoulli (2 * k)) / ↑(2 * k)!
state_after: case h.e'_2
k : ℕ
hk : k ≠ 0
⊢ riemannZeta (2 * ↑k) = ↑(∑' (b : ℕ), 1 / ↑b ^ (2 * k))

case h.e'_3
k : ℕ
hk : k ≠ 0
⊢ (-1) ^ (k + 1) * 2 ^ (2 * k - 1) * ↑π ^ (2 * k) * ↑(bernoulli (2 * k)) / ↑(2 * k)! =
    ↑((-1) ^ (k + 1) * 2 ^ (2 * k - 1) * π ^ (2 * k) * ↑(bernoulli (2 * k)) / ↑(2 * k)!)

tactic: rw [← Nat.cast_two, ← Nat.cast_mul, zeta_nat_eq_tsum_of_gt_one (by omega)]
state_before: case h.e'_2
k : ℕ
hk : k ≠ 0
⊢ riemannZeta (2 * ↑k) = ↑(∑' (b : ℕ), 1 / ↑b ^ (2 * k))
state_after: case h.e'_2
k : ℕ
hk : k ≠ 0
⊢ ∑' (n : ℕ), 1 / ↑n ^ (2 * k) = ↑(∑' (b : ℕ), 1 / ↑b ^ (2 * k))

tactic: simp only [push_cast]
state_before: case h.e'_2
k : ℕ
hk : k ≠ 0
⊢ ∑' (n : ℕ), 1 / ↑n ^ (2 * k) = ↑(∑' (b : ℕ), 1 / ↑b ^ (2 * k))
state_after: no goals

tactic: omega
state_before: k : ℕ
hk : k ≠ 0
⊢ 1 < 2 * k
state_after: no goals

tactic: norm_cast
state_before: case h.e'_3
k : ℕ
hk : k ≠ 0
⊢ (-1) ^ (k + 1) * 2 ^ (2 * k - 1) * ↑π ^ (2 * k) * ↑(bernoulli (2 * k)) / ↑(2 * k)! =
    ↑((-1) ^ (k + 1) * 2 ^ (2 * k - 1) * π ^ (2 * k) * ↑(bernoulli (2 * k)) / ↑(2 * k)!)
state_after: no goals