1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: summable_sigma_of_nonneg
File: Mathlib/Topology/Algebra/InfiniteSum/Real.lean

tactic: lift f to (Σx, β x) → ℝ≥0 using hf
state_before: α : Type u_1
β✝ : Type u_2
inst✝ : PseudoMetricSpace α
f✝ : ℕ → α
a : α
β : α → Type u_3
f : (x : α) × β x → ℝ
hf : ∀ (x : (x : α) × β x), 0 ≤ f x
⊢ Summable f ↔ (∀ (x : α), Summable fun y => f ⟨x, y⟩) ∧ Summable fun x => ∑' (y : β x), f ⟨x, y⟩
state_after: case intro
α : Type u_1
β✝ : Type u_2
inst✝ : PseudoMetricSpace α
f✝ : ℕ → α
a : α
β : α → Type u_3
f : (x : α) × β x → ℝ≥0
⊢ (Summable fun i => ↑(f i)) ↔
    (∀ (x : α), Summable fun y => (fun i => ↑(f i)) ⟨x, y⟩) ∧ Summable fun x => ∑' (y : β x), (fun i => ↑(f i)) ⟨x, y⟩

tactic: exact mod_cast NNReal.summable_sigma
state_before: case intro
α : Type u_1
β✝ : Type u_2
inst✝ : PseudoMetricSpace α
f✝ : ℕ → α
a : α
β : α → Type u_3
f : (x : α) × β x → ℝ≥0
⊢ (Summable fun i => ↑(f i)) ↔
    (∀ (x : α), Summable fun y => (fun i => ↑(f i)) ⟨x, y⟩) ∧ Summable fun x => ∑' (y : β x), (fun i => ↑(f i)) ⟨x, y⟩
state_after: no goals
Theorem: Polynomial.scaleRoots.isWeaklyEisensteinAt
File: Mathlib/RingTheory/Polynomial/Eisenstein/Basic.lean

tactic: refine ⟨fun i => ?_⟩
state_before: R : Type u
A : Type u_1
inst✝¹ : CommRing R
inst✝ : CommRing A
p : R[X]
x : R
P : Ideal R
hP : x ∈ P
⊢ (p.scaleRoots x).IsWeaklyEisensteinAt P
state_after: R : Type u
A : Type u_1
inst✝¹ : CommRing R
inst✝ : CommRing A
p : R[X]
x : R
P : Ideal R
hP : x ∈ P
n✝ : ℕ
i : n✝ < (p.scaleRoots x).natDegree
⊢ (p.scaleRoots x).coeff n✝ ∈ P

tactic: rw [coeff_scaleRoots]
state_before: R : Type u
A : Type u_1
inst✝¹ : CommRing R
inst✝ : CommRing A
p : R[X]
x : R
P : Ideal R
hP : x ∈ P
n✝ : ℕ
i : n✝ < (p.scaleRoots x).natDegree
⊢ (p.scaleRoots x).coeff n✝ ∈ P
state_after: R : Type u
A : Type u_1
inst✝¹ : CommRing R
inst✝ : CommRing A
p : R[X]
x : R
P : Ideal R
hP : x ∈ P
n✝ : ℕ
i : n✝ < (p.scaleRoots x).natDegree
⊢ p.coeff n✝ * x ^ (p.natDegree - n✝) ∈ P

tactic: rw [natDegree_scaleRoots, ← tsub_pos_iff_lt] at i
state_before: R : Type u
A : Type u_1
inst✝¹ : CommRing R
inst✝ : CommRing A
p : R[X]
x : R
P : Ideal R
hP : x ∈ P
n✝ : ℕ
i : n✝ < (p.scaleRoots x).natDegree
⊢ p.coeff n✝ * x ^ (p.natDegree - n✝) ∈ P
state_after: R : Type u
A : Type u_1
inst✝¹ : CommRing R
inst✝ : CommRing A
p : R[X]
x : R
P : Ideal R
hP : x ∈ P
n✝ : ℕ
i : 0 < p.natDegree - n✝
⊢ p.coeff n✝ * x ^ (p.natDegree - n✝) ∈ P

tactic: exact Ideal.mul_mem_left _ _ (Ideal.pow_mem_of_mem P hP _ i)
state_before: R : Type u
A : Type u_1
inst✝¹ : CommRing R
inst✝ : CommRing A
p : R[X]
x : R
P : Ideal R
hP : x ∈ P
n✝ : ℕ
i : 0 < p.natDegree - n✝
⊢ p.coeff n✝ * x ^ (p.natDegree - n✝) ∈ P
state_after: no goals
Theorem: zpow_eq_one_iff_modEq
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [Int.modEq_zero_iff_dvd, orderOf_dvd_iff_zpow_eq_one]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Finite G
x y : G
n : ℤ
⊢ x ^ n = 1 ↔ n ≡ 0 [ZMOD ↑(orderOf x)]
state_after: no goals
Theorem: Multiset.revzip_powersetAux
File: Mathlib/Data/Multiset/Powerset.lean

tactic: rw [revzip, powersetAux_eq_map_coe, ← map_reverse, zip_map, ← revzip, List.mem_map] at h
state_before: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : x ∈ (powersetAux l).revzip
⊢ x.1 + x.2 = ↑l
state_after: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a ∈ l.sublists.revzip, Prod.map ofList ofList a = x
⊢ x.1 + x.2 = ↑l

tactic: simp only [Prod.map_apply, Prod.exists] at h
state_before: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a ∈ l.sublists.revzip, Prod.map ofList ofList a = x
⊢ x.1 + x.2 = ↑l
state_after: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a b, (a, b) ∈ l.sublists.revzip ∧ (↑a, ↑b) = x
⊢ x.1 + x.2 = ↑l

tactic: rcases h with ⟨l₁, l₂, h, rfl, rfl⟩
state_before: α : Type u_1
l : List α
x : Multiset α × Multiset α
h : ∃ a b, (a, b) ∈ l.sublists.revzip ∧ (↑a, ↑b) = x
⊢ x.1 + x.2 = ↑l
state_after: case intro.intro.intro.refl
α : Type u_1
l l₁ l₂ : List α
h : (l₁, l₂) ∈ l.sublists.revzip
⊢ (↑l₁, ↑l₂).1 + (↑l₁, ↑l₂).2 = ↑l

tactic: exact Quot.sound (revzip_sublists _ _ _ h)
state_before: case intro.intro.intro.refl
α : Type u_1
l l₁ l₂ : List α
h : (l₁, l₂) ∈ l.sublists.revzip
⊢ (↑l₁, ↑l₂).1 + (↑l₁, ↑l₂).2 = ↑l
state_after: no goals
Theorem: selfZPow_neg_natCast
File: Mathlib/RingTheory/Localization/Away/Basic.lean

tactic: simp [selfZPow_of_nonpos _ _ (neg_nonpos.mpr (Int.natCast_nonneg d))]
state_before: R : Type u_1
inst✝³ : CommRing R
x : R
B : Type u_2
inst✝² : CommRing B
inst✝¹ : Algebra R B
inst✝ : IsLocalization.Away x B
d : ℕ
⊢ selfZPow x B (-↑d) = mk' B 1 (Submonoid.pow x d)
state_after: no goals
Theorem: Matrix.transvection_mul_apply_same
File: Mathlib/LinearAlgebra/Matrix/Transvection.lean

tactic: simp [transvection, Matrix.add_mul]
state_before: n : Type u_1
p : Type u_2
R : Type u₂
𝕜 : Type u_3
inst✝⁴ : Field 𝕜
inst✝³ : DecidableEq n
inst✝² : DecidableEq p
inst✝¹ : CommRing R
i j : n
inst✝ : Fintype n
b : n
c : R
M : Matrix n n R
⊢ (transvection i j c * M) i b = M i b + c * M j b
state_after: no goals
Theorem: CoxeterSystem.exists_reduced_word'
File: Mathlib/GroupTheory/Coxeter/Length.lean

tactic: rcases cs.exists_reduced_word w with ⟨ω, hω, rfl⟩
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ ∃ ω, cs.IsReduced ω ∧ w = cs.wordProd ω
state_after: case intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
hω : ω.length = cs.length (cs.wordProd ω)
⊢ ∃ ω_1, cs.IsReduced ω_1 ∧ cs.wordProd ω = cs.wordProd ω_1

tactic: use ω
state_before: case intro.intro
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
hω : ω.length = cs.length (cs.wordProd ω)
⊢ ∃ ω_1, cs.IsReduced ω_1 ∧ cs.wordProd ω = cs.wordProd ω_1
state_after: case h
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
hω : ω.length = cs.length (cs.wordProd ω)
⊢ cs.IsReduced ω ∧ cs.wordProd ω = cs.wordProd ω

tactic: tauto
state_before: case h
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
hω : ω.length = cs.length (cs.wordProd ω)
⊢ cs.IsReduced ω ∧ cs.wordProd ω = cs.wordProd ω
state_after: no goals
Theorem: WeierstrassCurve.variableChange_b₈
File: Mathlib/AlgebraicGeometry/EllipticCurve/Weierstrass.lean

tactic: simp only [b₂, b₄, b₆, b₈, variableChange_a₁, variableChange_a₂, variableChange_a₃,
  variableChange_a₄, variableChange_a₆]
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
C : VariableChange R
⊢ (W.variableChange C).b₈ = ↑C.u⁻¹ ^ 8 * (W.b₈ + 3 * C.r * W.b₆ + 3 * C.r ^ 2 * W.b₄ + C.r ^ 3 * W.b₂ + 3 * C.r ^ 4)
state_after: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
C : VariableChange R
⊢ (↑C.u⁻¹ * (W.a₁ + 2 * C.s)) ^ 2 *
              (↑C.u⁻¹ ^ 6 * (W.a₆ + C.r * W.a₄ + C.r ^ 2 * W.a₂ + C.r ^ 3 - C.t * W.a₃ - C.t ^ 2 - C.r * C.t * W.a₁)) +
            4 * (↑C.u⁻¹ ^ 2 * (W.a₂ - C.s * W.a₁ + 3 * C.r - C.s ^ 2)) *
              (↑C.u⁻¹ ^ 6 * (W.a₆ + C.r * W.a₄ + C.r ^ 2 * W.a₂ + C.r ^ 3 - C.t * W.a₃ - C.t ^ 2 - C.r * C.t * W.a₁)) -
          ↑C.u⁻¹ * (W.a₁ + 2 * C.s) * (↑C.u⁻¹ ^ 3 * (W.a₃ + C.r * W.a₁ + 2 * C.t)) *
            (↑C.u⁻¹ ^ 4 *
              (W.a₄ - C.s * W.a₃ + 2 * C.r * W.a₂ - (C.t + C.r * C.s) * W.a₁ + 3 * C.r ^ 2 - 2 * C.s * C.t)) +
        ↑C.u⁻¹ ^ 2 * (W.a₂ - C.s * W.a₁ + 3 * C.r - C.s ^ 2) * (↑C.u⁻¹ ^ 3 * (W.a₃ + C.r * W.a₁ + 2 * C.t)) ^ 2 -
      (↑C.u⁻¹ ^ 4 * (W.a₄ - C.s * W.a₃ + 2 * C.r * W.a₂ - (C.t + C.r * C.s) * W.a₁ + 3 * C.r ^ 2 - 2 * C.s * C.t)) ^ 2 =
    ↑C.u⁻¹ ^ 8 *
      (W.a₁ ^ 2 * W.a₆ + 4 * W.a₂ * W.a₆ - W.a₁ * W.a₃ * W.a₄ + W.a₂ * W.a₃ ^ 2 - W.a₄ ^ 2 +
              3 * C.r * (W.a₃ ^ 2 + 4 * W.a₆) +
            3 * C.r ^ 2 * (2 * W.a₄ + W.a₁ * W.a₃) +
          C.r ^ 3 * (W.a₁ ^ 2 + 4 * W.a₂) +
        3 * C.r ^ 4)

tactic: ring1
state_before: R : Type u
inst✝ : CommRing R
W : WeierstrassCurve R
C : VariableChange R
⊢ (↑C.u⁻¹ * (W.a₁ + 2 * C.s)) ^ 2 *
              (↑C.u⁻¹ ^ 6 * (W.a₆ + C.r * W.a₄ + C.r ^ 2 * W.a₂ + C.r ^ 3 - C.t * W.a₃ - C.t ^ 2 - C.r * C.t * W.a₁)) +
            4 * (↑C.u⁻¹ ^ 2 * (W.a₂ - C.s * W.a₁ + 3 * C.r - C.s ^ 2)) *
              (↑C.u⁻¹ ^ 6 * (W.a₆ + C.r * W.a₄ + C.r ^ 2 * W.a₂ + C.r ^ 3 - C.t * W.a₃ - C.t ^ 2 - C.r * C.t * W.a₁)) -
          ↑C.u⁻¹ * (W.a₁ + 2 * C.s) * (↑C.u⁻¹ ^ 3 * (W.a₃ + C.r * W.a₁ + 2 * C.t)) *
            (↑C.u⁻¹ ^ 4 *
              (W.a₄ - C.s * W.a₃ + 2 * C.r * W.a₂ - (C.t + C.r * C.s) * W.a₁ + 3 * C.r ^ 2 - 2 * C.s * C.t)) +
        ↑C.u⁻¹ ^ 2 * (W.a₂ - C.s * W.a₁ + 3 * C.r - C.s ^ 2) * (↑C.u⁻¹ ^ 3 * (W.a₃ + C.r * W.a₁ + 2 * C.t)) ^ 2 -
      (↑C.u⁻¹ ^ 4 * (W.a₄ - C.s * W.a₃ + 2 * C.r * W.a₂ - (C.t + C.r * C.s) * W.a₁ + 3 * C.r ^ 2 - 2 * C.s * C.t)) ^ 2 =
    ↑C.u⁻¹ ^ 8 *
      (W.a₁ ^ 2 * W.a₆ + 4 * W.a₂ * W.a₆ - W.a₁ * W.a₃ * W.a₄ + W.a₂ * W.a₃ ^ 2 - W.a₄ ^ 2 +
              3 * C.r * (W.a₃ ^ 2 + 4 * W.a₆) +
            3 * C.r ^ 2 * (2 * W.a₄ + W.a₁ * W.a₃) +
          C.r ^ 3 * (W.a₁ ^ 2 + 4 * W.a₂) +
        3 * C.r ^ 4)
state_after: no goals
Theorem: exists_dual_vector''
File: Mathlib/Analysis/NormedSpace/HahnBanach/Extension.lean

tactic: by_cases hx : x = 0
state_before: 𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
⊢ ∃ g, ‖g‖ ≤ 1 ∧ g x = ↑‖x‖
state_after: case pos
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : x = 0
⊢ ∃ g, ‖g‖ ≤ 1 ∧ g x = ↑‖x‖

case neg
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : ¬x = 0
⊢ ∃ g, ‖g‖ ≤ 1 ∧ g x = ↑‖x‖

tactic: refine ⟨0, by simp, ?_⟩
state_before: case pos
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : x = 0
⊢ ∃ g, ‖g‖ ≤ 1 ∧ g x = ↑‖x‖
state_after: case pos
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : x = 0
⊢ 0 x = ↑‖x‖

tactic: symm
state_before: case pos
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : x = 0
⊢ 0 x = ↑‖x‖
state_after: case pos
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : x = 0
⊢ ↑‖x‖ = 0 x

tactic: simp [hx]
state_before: case pos
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : x = 0
⊢ ↑‖x‖ = 0 x
state_after: no goals

tactic: simp
state_before: 𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : x = 0
⊢ ‖0‖ ≤ 1
state_after: no goals

tactic: rcases exists_dual_vector 𝕜 x hx with ⟨g, g_norm, g_eq⟩
state_before: case neg
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : ¬x = 0
⊢ ∃ g, ‖g‖ ≤ 1 ∧ g x = ↑‖x‖
state_after: case neg.intro.intro
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : ¬x = 0
g : E →L[𝕜] 𝕜
g_norm : ‖g‖ = 1
g_eq : g x = ↑‖x‖
⊢ ∃ g, ‖g‖ ≤ 1 ∧ g x = ↑‖x‖

tactic: exact ⟨g, g_norm.le, g_eq⟩
state_before: case neg.intro.intro
𝕜 : Type v
inst✝² : RCLike 𝕜
E : Type u
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : E
hx : ¬x = 0
g : E →L[𝕜] 𝕜
g_norm : ‖g‖ = 1
g_eq : g x = ↑‖x‖
⊢ ∃ g, ‖g‖ ≤ 1 ∧ g x = ↑‖x‖
state_after: no goals
Theorem: Pell.pell_eq
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: repeat' rw [Int.ofNat_mul]; exact pn
state_before: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
⊢ ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1
state_after: no goals

tactic: rw [Int.ofNat_mul]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
⊢ ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1
state_after: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
⊢ ↑(xn a1 n) * ↑(xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1

tactic: exact pn
state_before: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
⊢ ↑(xn a1 n) * ↑(xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1
state_after: no goals

tactic: rw [Int.ofNat_sub hl]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
h : ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1
hl : Pell.d a1 * yn a1 n * yn a1 n ≤ xn a1 n * xn a1 n
⊢ ↑(xn a1 n * xn a1 n - Pell.d a1 * yn a1 n * yn a1 n) = ↑1
state_after: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
h : ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1
hl : Pell.d a1 * yn a1 n * yn a1 n ≤ xn a1 n * xn a1 n
⊢ ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = ↑1

tactic: exact h
state_before: a : ℕ
a1 : 1 < a
n : ℕ
pn : xz a1 n * xz a1 n - ↑(Pell.d a1) * yz a1 n * yz a1 n = 1 := pell_eqz a1 n
h : ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = 1
hl : Pell.d a1 * yn a1 n * yn a1 n ≤ xn a1 n * xn a1 n
⊢ ↑(xn a1 n * xn a1 n) - ↑(Pell.d a1 * yn a1 n * yn a1 n) = ↑1
state_after: no goals
Theorem: HurwitzZeta.hurwitzZeta_neg_nat
File: Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean

tactic: rcases Nat.even_or_odd' k with ⟨n, (rfl | rfl)⟩
state_before: k : ℕ
x : ℝ
hk : k ≠ 0
hx : x ∈ Icc 0 1
⊢ hurwitzZeta (↑x) (-↑k) =
    -1 / (↑k + 1) * Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (k + 1)))
state_after: case intro.inl
x : ℝ
hx : x ∈ Icc 0 1
n : ℕ
hk : 2 * n ≠ 0
⊢ hurwitzZeta (↑x) (-↑(2 * n)) =
    -1 / (↑(2 * n) + 1) * Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (2 * n + 1)))

case intro.inr
x : ℝ
hx : x ∈ Icc 0 1
n : ℕ
hk : 2 * n + 1 ≠ 0
⊢ hurwitzZeta (↑x) (-↑(2 * n + 1)) =
    -1 / (↑(2 * n + 1) + 1) *
      Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (2 * n + 1 + 1)))

tactic: exact_mod_cast hurwitzZeta_neg_two_mul_nat (by omega : n ≠ 0) hx
state_before: case intro.inl
x : ℝ
hx : x ∈ Icc 0 1
n : ℕ
hk : 2 * n ≠ 0
⊢ hurwitzZeta (↑x) (-↑(2 * n)) =
    -1 / (↑(2 * n) + 1) * Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (2 * n + 1)))
state_after: no goals

tactic: omega
state_before: x : ℝ
hx : x ∈ Icc 0 1
n : ℕ
hk : 2 * n ≠ 0
⊢ n ≠ 0
state_after: no goals

tactic: exact_mod_cast hurwitzZeta_one_sub_two_mul_nat (by omega : n + 1 ≠ 0) hx
state_before: case intro.inr
x : ℝ
hx : x ∈ Icc 0 1
n : ℕ
hk : 2 * n + 1 ≠ 0
⊢ hurwitzZeta (↑x) (-↑(2 * n + 1)) =
    -1 / (↑(2 * n + 1) + 1) *
      Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (2 * n + 1 + 1)))
state_after: no goals

tactic: omega
state_before: x : ℝ
hx : x ∈ Icc 0 1
n : ℕ
hk : 2 * n + 1 ≠ 0
⊢ n + 1 ≠ 0
state_after: no goals
Theorem: Liouville.liouvilleWith
File: Mathlib/NumberTheory/Liouville/LiouvilleWith.lean

tactic: suffices LiouvilleWith ⌈p⌉₊ x from this.mono (Nat.le_ceil p)
state_before: x : ℝ
hx : Liouville x
p : ℝ
⊢ LiouvilleWith p x
state_after: x : ℝ
hx : Liouville x
p : ℝ
⊢ LiouvilleWith (↑⌈p⌉₊) x

tactic: refine ⟨1, ((eventually_gt_atTop 1).and_frequently (hx.frequently_exists_num ⌈p⌉₊)).mono ?_⟩
state_before: x : ℝ
hx : Liouville x
p : ℝ
⊢ LiouvilleWith (↑⌈p⌉₊) x
state_after: x : ℝ
hx : Liouville x
p : ℝ
⊢ ∀ (x_1 : ℕ),
    (1 < x_1 ∧ ∃ a, x ≠ ↑a / ↑x_1 ∧ |x - ↑a / ↑x_1| < 1 / ↑x_1 ^ ⌈p⌉₊) →
      ∃ m, x ≠ ↑m / ↑x_1 ∧ |x - ↑m / ↑x_1| < 1 / ↑x_1 ^ ↑⌈p⌉₊

tactic: rintro b ⟨_hb, a, hne, hlt⟩
state_before: x : ℝ
hx : Liouville x
p : ℝ
⊢ ∀ (x_1 : ℕ),
    (1 < x_1 ∧ ∃ a, x ≠ ↑a / ↑x_1 ∧ |x - ↑a / ↑x_1| < 1 / ↑x_1 ^ ⌈p⌉₊) →
      ∃ m, x ≠ ↑m / ↑x_1 ∧ |x - ↑m / ↑x_1| < 1 / ↑x_1 ^ ↑⌈p⌉₊
state_after: case intro.intro.intro
x : ℝ
hx : Liouville x
p : ℝ
b : ℕ
_hb : 1 < b
a : ℤ
hne : x ≠ ↑a / ↑b
hlt : |x - ↑a / ↑b| < 1 / ↑b ^ ⌈p⌉₊
⊢ ∃ m, x ≠ ↑m / ↑b ∧ |x - ↑m / ↑b| < 1 / ↑b ^ ↑⌈p⌉₊

tactic: refine ⟨a, hne, ?_⟩
state_before: case intro.intro.intro
x : ℝ
hx : Liouville x
p : ℝ
b : ℕ
_hb : 1 < b
a : ℤ
hne : x ≠ ↑a / ↑b
hlt : |x - ↑a / ↑b| < 1 / ↑b ^ ⌈p⌉₊
⊢ ∃ m, x ≠ ↑m / ↑b ∧ |x - ↑m / ↑b| < 1 / ↑b ^ ↑⌈p⌉₊
state_after: case intro.intro.intro
x : ℝ
hx : Liouville x
p : ℝ
b : ℕ
_hb : 1 < b
a : ℤ
hne : x ≠ ↑a / ↑b
hlt : |x - ↑a / ↑b| < 1 / ↑b ^ ⌈p⌉₊
⊢ |x - ↑a / ↑b| < 1 / ↑b ^ ↑⌈p⌉₊

tactic: rwa [rpow_natCast]
state_before: case intro.intro.intro
x : ℝ
hx : Liouville x
p : ℝ
b : ℕ
_hb : 1 < b
a : ℤ
hne : x ≠ ↑a / ↑b
hlt : |x - ↑a / ↑b| < 1 / ↑b ^ ⌈p⌉₊
⊢ |x - ↑a / ↑b| < 1 / ↑b ^ ↑⌈p⌉₊
state_after: no goals
Theorem: Ordnode.Sized.dual_iff
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [← dual_dual t]
state_before: α : Type u_1
t : Ordnode α
h : t.dual.Sized
⊢ t.Sized
state_after: α : Type u_1
t : Ordnode α
h : t.dual.Sized
⊢ t.dual.dual.Sized

tactic: exact h.dual
state_before: α : Type u_1
t : Ordnode α
h : t.dual.Sized
⊢ t.dual.dual.Sized
state_after: no goals
Theorem: List.pairwise_gt_iota
File: Mathlib/Data/List/Range.lean

tactic: simpa only [iota_eq_reverse_range', pairwise_reverse] using pairwise_lt_range' 1 n
state_before: α : Type u
n : ℕ
⊢ Pairwise (fun x x_1 => x > x_1) (iota n)
state_after: no goals
Theorem: WithZero.map'_id
File: Mathlib/Algebra/GroupWithZero/WithZero.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : MulOneClass α
inst✝¹ : MulOneClass β
inst✝ : MulOneClass γ
⊢ ↑(map' (MonoidHom.id β)) = MonoidHom.id (WithZero β)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : MulOneClass α
inst✝¹ : MulOneClass β
inst✝ : MulOneClass γ
x : WithZero β
⊢ ↑(map' (MonoidHom.id β)) x = (MonoidHom.id (WithZero β)) x

tactic: induction x <;> rfl
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : MulOneClass α
inst✝¹ : MulOneClass β
inst✝ : MulOneClass γ
x : WithZero β
⊢ ↑(map' (MonoidHom.id β)) x = (MonoidHom.id (WithZero β)) x
state_after: no goals
Theorem: Nat.Primrec'.unpair₂
File: Mathlib/Computability/Primrec.lean

tactic: have s := sqrt.comp₁ _ hf
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
⊢ Primrec' fun v => (unpair (f v)).2
state_after: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
⊢ Primrec' fun v => (unpair (f v)).2

tactic: have fss := sub.comp₂ _ hf (mul.comp₂ _ s s)
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
⊢ Primrec' fun v => (unpair (f v)).2
state_after: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
fss : Primrec' fun v => f v - (f v).sqrt * (f v).sqrt
⊢ Primrec' fun v => (unpair (f v)).2

tactic: refine (if_lt fss s s (sub.comp₂ _ fss s)).of_eq fun v => ?_
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
fss : Primrec' fun v => f v - (f v).sqrt * (f v).sqrt
⊢ Primrec' fun v => (unpair (f v)).2
state_after: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
fss : Primrec' fun v => f v - (f v).sqrt * (f v).sqrt
v : Vector ℕ n
⊢ (if f v - (f v).sqrt * (f v).sqrt < (f v).sqrt then (f v).sqrt else f v - (f v).sqrt * (f v).sqrt - (f v).sqrt) =
    (unpair (f v)).2

tactic: simp [Nat.unpair]
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
fss : Primrec' fun v => f v - (f v).sqrt * (f v).sqrt
v : Vector ℕ n
⊢ (if f v - (f v).sqrt * (f v).sqrt < (f v).sqrt then (f v).sqrt else f v - (f v).sqrt * (f v).sqrt - (f v).sqrt) =
    (unpair (f v)).2
state_after: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
fss : Primrec' fun v => f v - (f v).sqrt * (f v).sqrt
v : Vector ℕ n
⊢ (if f v - (f v).sqrt * (f v).sqrt < (f v).sqrt then (f v).sqrt else f v - (f v).sqrt * (f v).sqrt - (f v).sqrt) =
    (if f v - (f v).sqrt * (f v).sqrt < (f v).sqrt then (f v - (f v).sqrt * (f v).sqrt, (f v).sqrt)
      else ((f v).sqrt, f v - (f v).sqrt * (f v).sqrt - (f v).sqrt)).2

tactic: split_ifs <;> rfl
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
s : Primrec' fun v => (f v).sqrt
fss : Primrec' fun v => f v - (f v).sqrt * (f v).sqrt
v : Vector ℕ n
⊢ (if f v - (f v).sqrt * (f v).sqrt < (f v).sqrt then (f v).sqrt else f v - (f v).sqrt * (f v).sqrt - (f v).sqrt) =
    (if f v - (f v).sqrt * (f v).sqrt < (f v).sqrt then (f v - (f v).sqrt * (f v).sqrt, (f v).sqrt)
      else ((f v).sqrt, f v - (f v).sqrt * (f v).sqrt - (f v).sqrt)).2
state_after: no goals
Theorem: CategoryTheory.Limits.imageMonoIsoSource_hom_self
File: Mathlib/CategoryTheory/Limits/Shapes/Images.lean

tactic: simp only [← imageMonoIsoSource_inv_ι f]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (imageMonoIsoSource f).hom ≫ f = image.ι f
state_after: C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (imageMonoIsoSource f).hom ≫ (imageMonoIsoSource f).inv ≫ image.ι f = image.ι f

tactic: rw [← Category.assoc, Iso.hom_inv_id, Category.id_comp]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X Y : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (imageMonoIsoSource f).hom ≫ (imageMonoIsoSource f).inv ≫ image.ι f = image.ι f
state_after: no goals
Theorem: Polynomial.coeff_X_mul_zero
File: Mathlib/Algebra/Polynomial/Coeff.lean

tactic: simp
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
⊢ (X * p).coeff 0 = 0
state_after: no goals
Theorem: ProbabilityTheory.IndepSet_iff_Indep
File: Mathlib/Probability/Independence/Basic.lean

tactic: simp only [IndepSet, Indep, kernel.IndepSet]
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s✝ : ι → Set Ω
s t : Set Ω
μ : Measure Ω
⊢ IndepSet s t μ ↔ Indep (generateFrom {s}) (generateFrom {t}) μ
state_after: no goals
Theorem: IsAdjoinRootMonic.deg_pos
File: Mathlib/RingTheory/IsAdjoinRoot.lean

tactic: rcases h.basis.index_nonempty with ⟨⟨i, hi⟩⟩
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
⊢ 0 < f.natDegree
state_after: case intro.mk
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
i : ℕ
hi : i < f.natDegree
⊢ 0 < f.natDegree

tactic: exact (Nat.zero_le _).trans_lt hi
state_before: case intro.mk
R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
f : R[X]
inst✝¹ : Algebra R S
inst✝ : Nontrivial S
h : IsAdjoinRootMonic S f
i : ℕ
hi : i < f.natDegree
⊢ 0 < f.natDegree
state_after: no goals
Theorem: Real.volume_singleton
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp [volume_val]
state_before: ι : Type u_1
inst✝ : Fintype ι
a : ℝ
⊢ volume {a} = 0
state_after: no goals
Theorem: MvPolynomial.psum_zero
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

tactic: simp only [psum, _root_.pow_zero, ← cast_card]
state_before: σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝² : CommSemiring R
inst✝¹ : Fintype σ
inst✝ : Fintype τ
⊢ psum σ R 0 = ↑(Fintype.card σ)
state_after: σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝² : CommSemiring R
inst✝¹ : Fintype σ
inst✝ : Fintype τ
⊢ ↑univ.card = ↑(Fintype.card σ)

tactic: exact rfl
state_before: σ : Type u_1
R : Type u_2
τ : Type u_3
S : Type u_4
inst✝² : CommSemiring R
inst✝¹ : Fintype σ
inst✝ : Fintype τ
⊢ ↑univ.card = ↑(Fintype.card σ)
state_after: no goals
Theorem: toIocDiv_zsmul_sub_toIocMod
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [add_comm, toIocMod_add_toIocDiv_zsmul]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
⊢ toIocDiv hp a b • p + toIocMod hp a b = b
state_after: no goals