tasksource/leandojo huggingface dataset:
Theorem: Nat.prime_def_le_sqrt
File: Mathlib/Data/Nat/Prime.lean

tactic: cases' le_total m k with mk km
state_before: p : ℕ
p2 : 2 ≤ p
a : ∀ (m : ℕ), 2 ≤ m → m ≤ sqrt p → ¬m ∣ p
this : ∀ {m k : ℕ}, m ≤ k → 1 < m → p ≠ m * k
m : ℕ
m2 : 2 ≤ m
l : m < p
x✝ : m ∣ p
k : ℕ
e : p = m * k
⊢ False

tactic: exact this mk m2 e
state_before: case inl
p : ℕ
p2 : 2 ≤ p
a : ∀ (m : ℕ), 2 ≤ m → m ≤ sqrt p → ¬m ∣ p
this : ∀ {m k : ℕ}, m ≤ k → 1 < m → p ≠ m * k
m : ℕ
m2 : 2 ≤ m
l : m < p
x✝ : m ∣ p
k : ℕ
e : p = m * k
mk : m ≤ k
⊢ False

tactic: rw [mul_comm] at e
state_before: case inr
p : ℕ
p2 : 2 ≤ p
a : ∀ (m : ℕ), 2 ≤ m → m ≤ sqrt p → ¬m ∣ p
this : ∀ {m k : ℕ}, m ≤ k → 1 < m → p ≠ m * k
m : ℕ
m2 : 2 ≤ m
l : m < p
x✝ : m ∣ p
k : ℕ
e : p = m * k
km : k ≤ m
⊢ False

tactic: refine' this km (lt_of_mul_lt_mul_right _ (zero_le m)) e
state_before: case inr
p : ℕ
p2 : 2 ≤ p
a : ∀ (m : ℕ), 2 ≤ m → m ≤ sqrt p → ¬m ∣ p
this : ∀ {m k : ℕ}, m ≤ k → 1 < m → p ≠ m * k
m : ℕ
m2 : 2 ≤ m
l : m < p
x✝ : m ∣ p
k : ℕ
e : p = k * m
km : k ≤ m
⊢ False

tactic: rwa [one_mul, ← e]
state_before: case inr
p : ℕ
p2 : 2 ≤ p
a : ∀ (m : ℕ), 2 ≤ m → m ≤ sqrt p → ¬m ∣ p
this : ∀ {m k : ℕ}, m ≤ k → 1 < m → p ≠ m * k
m : ℕ
m2 : 2 ≤ m
l : m < p
x✝ : m ∣ p
k : ℕ
e : p = k * m
km : k ≤ m
⊢ 1 * m < k * m
Theorem: Real.sqrt_le_sqrt
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [sqrt, sqrt, NNReal.coe_le_coe, NNReal.sqrt_le_sqrt_iff]
state_before: x y : ℝ
h : x ≤ y
⊢ sqrt x ≤ sqrt y

tactic: exact toNNReal_le_toNNReal h
state_before: x y : ℝ
h : x ≤ y
⊢ toNNReal x ≤ toNNReal y
Theorem: List.reverse_suffix
File: Std/Data/List/Lemmas.lean

tactic: rw [← reverse_reverse l₁, ← reverse_append, e, reverse_reverse]
state_before: α✝ : Type u_1
l₁ l₂ : List α✝
x✝ : reverse l₁ <:+ reverse l₂
r : List α✝
e : r ++ reverse l₁ = reverse l₂
⊢ l₁ ++ reverse r = l₂

tactic: rw [← reverse_append, e]
state_before: α✝ : Type u_1
l₁ l₂ : List α✝
x✝ : l₁ <+: l₂
r : List α✝
e : l₁ ++ r = l₂
⊢ reverse r ++ reverse l₁ = reverse l₂
Theorem: one_lt_div_of_neg
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rw [lt_div_iff_of_neg hb, one_mul]
state_before: ι : Type ?u.155109
α : Type u_1
β : Type ?u.155115
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
hb : b < 0
⊢ 1 < a / b ↔ a < b
Theorem: List.erase_cons_subperm_cons_erase
File: Mathlib/Data/List/Perm.lean

tactic: by_cases h : a = b
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
a b : α
l : List α
⊢ List.erase (a :: l) b <+~ a :: List.erase l b

tactic: subst b
state_before: case pos
α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
a b : α
l : List α
h : a = b
⊢ List.erase (a :: l) b <+~ a :: List.erase l b

tactic: rw [erase_cons_head]
state_before: case pos
α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
l : List α
⊢ List.erase (a :: l) a <+~ a :: List.erase l a

tactic: apply subperm_cons_erase
state_before: case pos
α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
a : α
l : List α
⊢ l <+~ a :: List.erase l a

tactic: rw [erase_cons_tail _ h]
state_before: case neg
α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
a b : α
l : List α
h : ¬a = b
⊢ List.erase (a :: l) b <+~ a :: List.erase l b
Theorem: Set.Iic_diff_right
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp [lt_iff_le_and_ne]
state_before: α : Type u_1
β : Type ?u.42374
inst✝ : PartialOrder α
a b c x : α
⊢ x ∈ Iic a \ {a} ↔ x ∈ Iio a
Theorem: Finset.prod_range_one
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [range_one]
state_before: ι : Type ?u.450637
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
⊢ ∏ k in range 1, f k = f 0

tactic: apply @prod_singleton β ℕ 0 f
state_before: ι : Type ?u.450637
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝ : CommMonoid β
f : ℕ → β
⊢ ∏ k in {0}, f k = f 0
Theorem: FractionalIdeal.canonicalEquiv_coeIdeal
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: ext
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_3
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_2
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type ?u.1004372
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
I : Ideal R
⊢ ↑(canonicalEquiv S P P') ↑I = ↑I

tactic: simp [IsLocalization.map_eq]
state_before: case a
R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_3
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_2
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type ?u.1004372
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g : P →ₐ[R] P'
I : Ideal R
x✝ : P'
⊢ x✝ ∈ ↑(canonicalEquiv S P P') ↑I ↔ x✝ ∈ ↑I
Theorem: MvPolynomial.totalDegree_X_pow
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: simp [X_pow_eq_monomial, one_ne_zero]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type ?u.463074
r : R
e : ℕ
n✝ m : σ
s✝ : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : Nontrivial R
s : σ
n : ℕ
⊢ totalDegree (X s ^ n) = n
Theorem: Pell.yn_one
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: simp
state_before: a : ℕ
a1 : 1 < a
⊢ yn a1 1 = 1
Theorem: mul_cancel_left_mem_nonZeroDivisors
File: Mathlib/RingTheory/NonZeroDivisors.lean

tactic: simp_rw [mul_comm r, mul_cancel_right_mem_nonZeroDivisors hr]
state_before: M : Type ?u.17057
M' : Type ?u.17060
M₁ : Type ?u.17063
R : Type ?u.17066
R' : Type u_1
F : Type ?u.17072
inst✝⁴ : MonoidWithZero M
inst✝³ : MonoidWithZero M'
inst✝² : CommMonoidWithZero M₁
inst✝¹ : Ring R
inst✝ : CommRing R'
x y r : R'
hr : r ∈ R'⁰
⊢ r * x = r * y ↔ x = y
Theorem: Real.tendsto_log_comp_add_sub_log
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: have : Tendsto (fun x ↦ 1 + y / x) atTop (𝓝 (1 + 0))
state_before: y : ℝ
⊢ Tendsto (fun x => log (x + y) - log x) atTop (𝓝 0)

tactic: rw [← comap_exp_nhds_exp, exp_zero, tendsto_comap_iff, ← add_zero (1 : ℝ)]
state_before: y : ℝ
this : Tendsto (fun x => 1 + y / x) atTop (𝓝 (1 + 0))
⊢ Tendsto (fun x => log (x + y) - log x) atTop (𝓝 0)

tactic: refine' this.congr' _
state_before: y : ℝ
this : Tendsto (fun x => 1 + y / x) atTop (𝓝 (1 + 0))
⊢ Tendsto (exp ∘ fun x => log (x + y) - log x) atTop (𝓝 (1 + 0))

tactic: filter_upwards [eventually_gt_atTop (0 : ℝ), eventually_gt_atTop (-y)] with x hx₀ hxy
state_before: y : ℝ
this : Tendsto (fun x => 1 + y / x) atTop (𝓝 (1 + 0))
⊢ (fun x => 1 + y / x) =ᶠ[atTop] exp ∘ fun x => log (x + y) - log x

tactic: rw [comp_apply, exp_sub, exp_log, exp_log, one_add_div] <;> linarith
state_before: case h
y : ℝ
this : Tendsto (fun x => 1 + y / x) atTop (𝓝 (1 + 0))
x : ℝ
hx₀ : 0 < x
hxy : -y < x
⊢ 1 + y / x = (exp ∘ fun x => log (x + y) - log x) x

tactic: exact tendsto_const_nhds.add (tendsto_const_nhds.div_atTop tendsto_id)
state_before: case this
y : ℝ
⊢ Tendsto (fun x => 1 + y / x) atTop (𝓝 (1 + 0))
Theorem: Nat.add_le_of_le_sub
File: src/lean/Init/Data/Nat/Basic.lean

tactic: match le.dest h with
| ⟨d, hd⟩ =>
  apply @le.intro _ _ d
  rw [Nat.eq_add_of_sub_eq hle hd.symm]
  simp [Nat.add_comm, Nat.add_assoc, Nat.add_left_comm]
state_before: a b c : Nat
hle : b ≤ c
h : a ≤ c - b
⊢ a + b ≤ c

tactic: apply @le.intro _ _ d
state_before: a b c : Nat
hle : b ≤ c
h : a ≤ c - b
d : Nat
hd : a + d = c - b
⊢ a + b ≤ c

tactic: rw [Nat.eq_add_of_sub_eq hle hd.symm]
state_before: a b c : Nat
hle : b ≤ c
h : a ≤ c - b
d : Nat
hd : a + d = c - b
⊢ a + b + d = c

tactic: simp [Nat.add_comm, Nat.add_assoc, Nat.add_left_comm]
state_before: a b c : Nat
hle : b ≤ c
h : a ≤ c - b
d : Nat
hd : a + d = c - b
⊢ a + b + d = a + d + b
Theorem: HasStrictFDerivAt.sum
File: Mathlib/Analysis/Calculus/FDeriv/Add.lean

tactic: dsimp [HasStrictFDerivAt] at *
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_4
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.296313
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.296408
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_1
u : Finset ι
A : ι → E → F
A' : ι → E →L[𝕜] F
h : ∀ (i : ι), i ∈ u → HasStrictFDerivAt (A i) (A' i) x
⊢ HasStrictFDerivAt (fun y => ∑ i in u, A i y) (∑ i in u, A' i) x

tactic: convert IsLittleO.sum h
state_before: 𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_4
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.296313
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.296408
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_1
u : Finset ι
A : ι → E → F
A' : ι → E →L[𝕜] F
h : ∀ (i : ι), i ∈ u → (fun p => A i p.fst - A i p.snd - ↑(A' i) (p.fst - p.snd)) =o[𝓝 (x, x)] fun p => p.fst - p.snd
⊢ (fun p => ∑ i in u, A i p.fst - ∑ i in u, A i p.snd - ↑(∑ i in u, A' i) (p.fst - p.snd)) =o[𝓝 (x, x)] fun p =>
    p.fst - p.snd

tactic: simp [Finset.sum_sub_distrib, ContinuousLinearMap.sum_apply]
state_before: case h.e'_7.h
𝕜 : Type u_2
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_4
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.296313
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.296408
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_1
u : Finset ι
A : ι → E → F
A' : ι → E →L[𝕜] F
h : ∀ (i : ι), i ∈ u → (fun p => A i p.fst - A i p.snd - ↑(A' i) (p.fst - p.snd)) =o[𝓝 (x, x)] fun p => p.fst - p.snd
x✝ : E × E
⊢ ∑ i in u, A i x✝.fst - ∑ i in u, A i x✝.snd - ↑(∑ i in u, A' i) (x✝.fst - x✝.snd) =
    ∑ i in u, (A i x✝.fst - A i x✝.snd - ↑(A' i) (x✝.fst - x✝.snd))
Theorem: FractionalIdeal.spanSingleton_mul_spanSingleton
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: apply coeToSubmodule_injective
state_before: R : Type u_2
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_1
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type ?u.1334398
inst✝³ : CommRing R₁
K : Type ?u.1334404
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x y : P
⊢ spanSingleton S x * spanSingleton S y = spanSingleton S (x * y)

tactic: simp only [coe_mul, coe_spanSingleton, span_mul_span, singleton_mul_singleton]
state_before: case a
R : Type u_2
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_1
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
R₁ : Type ?u.1334398
inst✝³ : CommRing R₁
K : Type ?u.1334404
inst✝² : Field K
inst✝¹ : Algebra R₁ K
inst✝ : IsFractionRing R₁ K
x y : P
⊢ (fun I => ↑I) (spanSingleton S x * spanSingleton S y) = (fun I => ↑I) (spanSingleton S (x * y))
Theorem: RingHom.charZero_iff
File: Mathlib/Algebra/CharZero/Lemmas.lean

tactic: intro a b h
state_before: R : Type u_1
S : Type u_2
inst✝¹ : NonAssocSemiring R
inst✝ : NonAssocSemiring S
ϕ : R →+* S
hϕ : Function.Injective ↑ϕ
hR : CharZero R
⊢ Function.Injective Nat.cast

tactic: rwa [← @Nat.cast_inj R, ← hϕ.eq_iff, map_natCast ϕ, map_natCast ϕ]
state_before: R : Type u_1
S : Type u_2
inst✝¹ : NonAssocSemiring R
inst✝ : NonAssocSemiring S
ϕ : R →+* S
hϕ : Function.Injective ↑ϕ
hR : CharZero R
a b : ℕ
h : ↑a = ↑b
⊢ a = b
Theorem: Mathlib.Tactic.Ring.inv_add
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₁ : ℕ
b₁ : R
a₂ : ℕ
b₂ : R
x✝¹ : ↑a₁ = b₁
x✝ : ↑a₂ = b₂
⊢ ↑(a₁ + a₂) = b₁ + b₂

tactic: simp
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₁ a₂ : ℕ
⊢ ↑(a₁ + a₂) = ↑a₁ + ↑a₂
Theorem: Real.cauchy_one
File: Mathlib/Data/Real/Basic.lean

tactic: rw [one_def]
state_before: x y : ℝ
⊢ Real.one.cauchy = 1
Theorem: Complex.inv_re
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [inv_def, division_def, ofReal']
state_before: z : ℂ
⊢ z⁻¹.re = z.re / ↑normSq z
Theorem: monotone_stabilizes_iff_noetherian
File: Mathlib/RingTheory/Noetherian.lean

tactic: rw [isNoetherian_iff_wellFounded, WellFounded.monotone_chain_condition]
state_before: R : Type u_2
M : Type u_1
P : Type ?u.119271
N : Type w
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
⊢ (∀ (f : ℕ →o Submodule R M), ∃ n, ∀ (m : ℕ), n ≤ m → ↑f n = ↑f m) ↔ IsNoetherian R M
Theorem: PadicSeq.norm_equiv
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: have hg : g ≈ 0 := Setoid.trans (Setoid.symm hfg) hf
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : f ≈ g
hf : f ≈ 0
⊢ norm f = norm g

tactic: simp [norm, hf, hg]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : f ≈ g
hf : f ≈ 0
hg : g ≈ 0
⊢ norm f = norm g

tactic: have hg : ¬g ≈ 0 := hf ∘ Setoid.trans hfg
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : f ≈ g
hf : ¬f ≈ 0
⊢ norm f = norm g

tactic: unfold norm
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : f ≈ g
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ norm f = norm g

tactic: split_ifs
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : f ≈ g
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ (if hf : f ≈ 0 then 0 else padicNorm p (↑f (stationaryPoint hf))) =
    if hf : g ≈ 0 then 0 else padicNorm p (↑g (stationaryPoint hf))

tactic: exact norm_eq_of_equiv hf hg hfg
state_before: p : ℕ
hp : Fact (Nat.Prime p)
f g : PadicSeq p
hfg : f ≈ g
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ padicNorm p (↑f (stationaryPoint hf)) = padicNorm p (↑g (stationaryPoint hg))
Theorem: PartENat.lt_add_one
File: Mathlib/Data/Nat/PartENat.lean

tactic: rw [PartENat.lt_add_iff_pos_right hx]
state_before: x : PartENat
hx : x ≠ ⊤
⊢ x < x + 1

tactic: norm_cast
state_before: x : PartENat
hx : x ≠ ⊤
⊢ 0 < 1
Theorem: nhds_basis_abs_convex
File: Mathlib/Analysis/LocallyConvex/AbsConvex.lean

tactic: refine'
  (LocallyConvexSpace.convex_basis_zero ℝ E).to_hasBasis (fun s hs => _) fun s hs =>
    ⟨s, ⟨hs.1, hs.2.2⟩, rfl.subset⟩
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.8459
G : Type ?u.8462
ι : Type ?u.8465
s : Set E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module 𝕜 E
inst✝⁴ : Module ℝ E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : TopologicalSpace E
inst✝¹ : LocallyConvexSpace ℝ E
inst✝ : ContinuousSMul 𝕜 E
⊢ Filter.HasBasis (𝓝 0) (fun s => s ∈ 𝓝 0 ∧ Balanced 𝕜 s ∧ Convex ℝ s) id

tactic: refine' ⟨convexHull ℝ (balancedCore 𝕜 s), _, convexHull_min (balancedCore_subset s) hs.2⟩
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.8459
G : Type ?u.8462
ι : Type ?u.8465
s✝ : Set E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module 𝕜 E
inst✝⁴ : Module ℝ E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : TopologicalSpace E
inst✝¹ : LocallyConvexSpace ℝ E
inst✝ : ContinuousSMul 𝕜 E
s : Set E
hs : s ∈ 𝓝 0 ∧ Convex ℝ s
⊢ ∃ i', (i' ∈ 𝓝 0 ∧ Balanced 𝕜 i' ∧ Convex ℝ i') ∧ id i' ⊆ id s

tactic: refine' ⟨Filter.mem_of_superset (balancedCore_mem_nhds_zero hs.1) (subset_convexHull ℝ _), _⟩
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.8459
G : Type ?u.8462
ι : Type ?u.8465
s✝ : Set E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module 𝕜 E
inst✝⁴ : Module ℝ E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : TopologicalSpace E
inst✝¹ : LocallyConvexSpace ℝ E
inst✝ : ContinuousSMul 𝕜 E
s : Set E
hs : s ∈ 𝓝 0 ∧ Convex ℝ s
⊢ ↑(convexHull ℝ).toOrderHom (balancedCore 𝕜 s) ∈ 𝓝 0 ∧
    Balanced 𝕜 (↑(convexHull ℝ).toOrderHom (balancedCore 𝕜 s)) ∧
      Convex ℝ (↑(convexHull ℝ).toOrderHom (balancedCore 𝕜 s))

tactic: refine' ⟨balanced_convexHull_of_balanced (balancedCore_balanced s), _⟩
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.8459
G : Type ?u.8462
ι : Type ?u.8465
s✝ : Set E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module 𝕜 E
inst✝⁴ : Module ℝ E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : TopologicalSpace E
inst✝¹ : LocallyConvexSpace ℝ E
inst✝ : ContinuousSMul 𝕜 E
s : Set E
hs : s ∈ 𝓝 0 ∧ Convex ℝ s
⊢ Balanced 𝕜 (↑(convexHull ℝ).toOrderHom (balancedCore 𝕜 s)) ∧ Convex ℝ (↑(convexHull ℝ).toOrderHom (balancedCore 𝕜 s))

tactic: exact convex_convexHull ℝ (balancedCore 𝕜 s)
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.8459
G : Type ?u.8462
ι : Type ?u.8465
s✝ : Set E
inst✝⁷ : NontriviallyNormedField 𝕜
inst✝⁶ : AddCommGroup E
inst✝⁵ : Module 𝕜 E
inst✝⁴ : Module ℝ E
inst✝³ : SMulCommClass ℝ 𝕜 E
inst✝² : TopologicalSpace E
inst✝¹ : LocallyConvexSpace ℝ E
inst✝ : ContinuousSMul 𝕜 E
s : Set E
hs : s ∈ 𝓝 0 ∧ Convex ℝ s
⊢ Convex ℝ (↑(convexHull ℝ).toOrderHom (balancedCore 𝕜 s))
Theorem: Prime.dvd_of_dvd_pow
File: Mathlib/Algebra/Associated.lean

tactic: induction' n with n ih
state_before: α : Type u_1
β : Type ?u.3519
γ : Type ?u.3522
δ : Type ?u.3525
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n : ℕ
h : p ∣ a ^ n
⊢ p ∣ a

tactic: rw [pow_succ] at h
state_before: case succ
α : Type u_1
β : Type ?u.3519
γ : Type ?u.3522
δ : Type ?u.3525
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n✝ : ℕ
h✝ : p ∣ a ^ n✝
n : ℕ
ih : p ∣ a ^ n → p ∣ a
h : p ∣ a ^ Nat.succ n
⊢ p ∣ a

tactic: cases' dvd_or_dvd hp h with dvd_a dvd_pow
state_before: case succ
α : Type u_1
β : Type ?u.3519
γ : Type ?u.3522
δ : Type ?u.3525
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n✝ : ℕ
h✝ : p ∣ a ^ n✝
n : ℕ
ih : p ∣ a ^ n → p ∣ a
h : p ∣ a * a ^ n
⊢ p ∣ a

tactic: exact ih dvd_pow
state_before: case succ.inr
α : Type u_1
β : Type ?u.3519
γ : Type ?u.3522
δ : Type ?u.3525
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n✝ : ℕ
h✝ : p ∣ a ^ n✝
n : ℕ
ih : p ∣ a ^ n → p ∣ a
h : p ∣ a * a ^ n
dvd_pow : p ∣ a ^ n
⊢ p ∣ a

tactic: rw [pow_zero] at h
state_before: case zero
α : Type u_1
β : Type ?u.3519
γ : Type ?u.3522
δ : Type ?u.3525
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n : ℕ
h✝ : p ∣ a ^ n
h : p ∣ a ^ Nat.zero
⊢ p ∣ a

tactic: have := isUnit_of_dvd_one h
state_before: case zero
α : Type u_1
β : Type ?u.3519
γ : Type ?u.3522
δ : Type ?u.3525
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n : ℕ
h✝ : p ∣ a ^ n
h : p ∣ 1
⊢ p ∣ a

tactic: have := not_unit hp
state_before: case zero
α : Type u_1
β : Type ?u.3519
γ : Type ?u.3522
δ : Type ?u.3525
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n : ℕ
h✝ : p ∣ a ^ n
h : p ∣ 1
this : IsUnit p
⊢ p ∣ a

tactic: contradiction
state_before: case zero
α : Type u_1
β : Type ?u.3519
γ : Type ?u.3522
δ : Type ?u.3525
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n : ℕ
h✝ : p ∣ a ^ n
h : p ∣ 1
this✝ : IsUnit p
this : ¬IsUnit p
⊢ p ∣ a

tactic: assumption
state_before: case succ.inl
α : Type u_1
β : Type ?u.3519
γ : Type ?u.3522
δ : Type ?u.3525
inst✝ : CommMonoidWithZero α
p : α
hp✝ hp : Prime p
a : α
n✝ : ℕ
h✝ : p ∣ a ^ n✝
n : ℕ
ih : p ∣ a ^ n → p ∣ a
h : p ∣ a * a ^ n
dvd_a : p ∣ a
⊢ p ∣ a
Theorem: Nat.log_of_one_lt_of_le
File: Mathlib/Data/Nat/Log.lean

tactic: rw [log]
state_before: b n : ℕ
h : 1 < b
hn : b ≤ n
⊢ log b n = log b (n / b) + 1

tactic: exact if_pos ⟨hn, h⟩
state_before: b n : ℕ
h : 1 < b
hn : b ≤ n
⊢ (if h : b ≤ n ∧ 1 < b then
      let_fun this := (_ : n / b < n);
      log b (n / b) + 1
    else 0) =
    log b (n / b) + 1
Theorem: Nat.gcd_mul_right_right
File: Std/Data/Nat/Gcd.lean

tactic: rw [gcd_comm, gcd_mul_right_left]
state_before: m n : Nat
⊢ gcd n (n * m) = n
Theorem: iter_deriv_zpow'
File: Mathlib/Analysis/Calculus/Deriv/ZPow.lean

tactic: induction' k with k ihk
state_before: 𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : 𝕜
s : Set 𝕜
m✝ m : ℤ
k : ℕ
⊢ ((deriv^[k]) fun x => x ^ m) = fun x => (∏ i in Finset.range k, (↑m - ↑i)) * x ^ (m - ↑k)

tactic: simp only [Nat.zero_eq, one_mul, Int.ofNat_zero, id, sub_zero, Finset.prod_range_zero,
  Function.iterate_zero]
state_before: case zero
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : 𝕜
s : Set 𝕜
m✝ m : ℤ
⊢ ((deriv^[Nat.zero]) fun x => x ^ m) = fun x => (∏ i in Finset.range Nat.zero, (↑m - ↑i)) * x ^ (m - ↑Nat.zero)

tactic: simp only [Function.iterate_succ_apply', ihk, deriv_const_mul_field', deriv_zpow',
  Finset.prod_range_succ, Int.ofNat_succ, ← sub_sub, Int.cast_sub, Int.cast_ofNat, mul_assoc]
state_before: case succ
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : 𝕜
s : Set 𝕜
m✝ m : ℤ
k : ℕ
ihk : ((deriv^[k]) fun x => x ^ m) = fun x => (∏ i in Finset.range k, (↑m - ↑i)) * x ^ (m - ↑k)
⊢ ((deriv^[Nat.succ k]) fun x => x ^ m) = fun x =>
    (∏ i in Finset.range (Nat.succ k), (↑m - ↑i)) * x ^ (m - ↑(Nat.succ k))
Theorem: Metric.ball_zero
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [ball_eq_empty]
state_before: α : Type u
β : Type v
X : Type ?u.26255
ι : Type ?u.26258
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
⊢ ball x 0 = ∅
Theorem: Subgroup.mem_sup'
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: simp only [SetLike.exists, coe_mk, exists_prop]
state_before: G : Type ?u.697599
G' : Type ?u.697602
inst✝⁴ : Group G
inst✝³ : Group G'
A : Type ?u.697611
inst✝² : AddGroup A
N : Type ?u.697617
inst✝¹ : Group N
C : Type u_1
inst✝ : CommGroup C
s t : Subgroup C
x : C
⊢ (∃ y, y ∈ s ∧ ∃ z, z ∈ t ∧ y * z = x) ↔ ∃ y z, ↑y * ↑z = x
Theorem: MvPolynomial.homogeneousComponent_C_mul
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: simp only [C_mul', LinearMap.map_smul]
state_before: σ : Type u_2
τ : Type ?u.308829
R : Type u_1
S : Type ?u.308835
inst✝ : CommSemiring R
n✝ : ℕ
φ ψ : MvPolynomial σ R
n : ℕ
r : R
⊢ ↑(homogeneousComponent n) (↑C r * φ) = ↑C r * ↑(homogeneousComponent n) φ
Theorem: Polynomial.cyclotomic.eval_apply
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: rw [← map_cyclotomic n f, eval_map, eval₂_at_apply]
state_before: R : Type u_1
S : Type u_2
q : R
n : ℕ
inst✝¹ : Ring R
inst✝ : Ring S
f : R →+* S
⊢ eval (↑f q) (cyclotomic n S) = ↑f (eval q (cyclotomic n R))
Theorem: MeasureTheory.Measure.prod_swap
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

tactic: refine' (prod_eq _).symm
state_before: α : Type u_1
α' : Type ?u.4456049
β : Type u_2
β' : Type ?u.4456055
γ : Type ?u.4456058
E : Type ?u.4456061
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
⊢ map Prod.swap (Measure.prod μ ν) = Measure.prod ν μ

tactic: intro s t hs ht
state_before: α : Type u_1
α' : Type ?u.4456049
β : Type u_2
β' : Type ?u.4456055
γ : Type ?u.4456058
E : Type ?u.4456061
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
⊢ ∀ (s : Set β) (t : Set α),
    MeasurableSet s → MeasurableSet t → ↑↑(map Prod.swap (Measure.prod μ ν)) (s ×ˢ t) = ↑↑ν s * ↑↑μ t

tactic: simp_rw [map_apply measurable_swap (hs.prod ht), preimage_swap_prod, prod_prod, mul_comm]
state_before: α : Type u_1
α' : Type ?u.4456049
β : Type u_2
β' : Type ?u.4456055
γ : Type ?u.4456058
E : Type ?u.4456061
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
s : Set β
t : Set α
hs : MeasurableSet s
ht : MeasurableSet t
⊢ ↑↑(map Prod.swap (Measure.prod μ ν)) (s ×ˢ t) = ↑↑ν s * ↑↑μ t