tasksource/leandojo huggingface dataset:
Theorem: Commute.orderOf_mul_dvd_lcm
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [orderOf, ← comp_mul_left]
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : _root_.Commute x y
⊢ orderOf (x * y) ∣ lcm (orderOf x) (orderOf y)

tactic: exact Function.Commute.minimalPeriod_of_comp_dvd_lcm h.function_commute_mul_left
state_before: G : Type u
A : Type v
x y : G
a b : A
n m : ℕ
inst✝¹ : Monoid G
inst✝ : AddMonoid A
h : _root_.Commute x y
⊢ minimalPeriod ((fun x_1 => x * x_1) ∘ fun x => y * x) 1 ∣ lcm (orderOf x) (orderOf y)
Theorem: VitaliFamily.eventually_filterAt_measurableSet
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

tactic: filter_upwards [v.eventually_filterAt_mem_sets x]with _ ha using v.MeasurableSet' _ _ ha
state_before: α : Type u_1
inst✝ : MetricSpace α
m0 : MeasurableSpace α
μ : MeasureTheory.Measure α
v : VitaliFamily μ
x : α
⊢ ∀ᶠ (a : Set α) in filterAt v x, MeasurableSet a
Theorem: Path.trans_apply
File: Mathlib/Topology/PathConnected.lean

tactic: split_ifs <;> rw [extend_extends]
state_before: X : Type u_1
Y : Type ?u.226697
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.226712
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
⊢ (if ↑t ≤ 1 / 2 then extend γ (2 * ↑t) else extend γ' (2 * ↑t - 1)) =
    if h : ↑t ≤ 1 / 2 then ↑γ { val := 2 * ↑t, property := (_ : 2 * ↑t ∈ I) }
    else ↑γ' { val := 2 * ↑t - 1, property := (_ : 2 * ↑t - 1 ∈ I) }
Theorem: LieAlgebra.lieCharacter_apply_lie
File: Mathlib/Algebra/Lie/Character.lean

tactic: rw [LieHom.map_lie, LieRing.of_associative_ring_bracket, mul_comm, sub_self]
state_before: R : Type u
L : Type v
inst✝² : CommRing R
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
χ : LieCharacter R L
x y : L
⊢ ↑χ ⁅x, y⁆ = 0
Theorem: Nat.card_of_isEmpty
File: Mathlib/SetTheory/Cardinal/Finite.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.11061
inst✝ : IsEmpty α
⊢ Nat.card α = 0
Theorem: finprod_mem_singleton
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [← Finset.coe_singleton, finprod_mem_coe_finset, Finset.prod_singleton]
state_before: α : Type u_2
β : Type ?u.340104
ι : Type ?u.340107
G : Type ?u.340110
M : Type u_1
N : Type ?u.340116
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
⊢ (∏ᶠ (i : α) (_ : i ∈ {a}), f i) = f a
Theorem: Part.union_get_eq
File: Mathlib/Data/Part.lean

tactic: simp [union_def]
state_before: α : Type u_1
β : Type ?u.94362
γ : Type ?u.94365
inst✝ : Union α
a b : Part α
hab : (a ∪ b).Dom
⊢ get (a ∪ b) hab = get a (_ : a.Dom) ∪ get b (_ : b.Dom)

tactic: aesop
state_before: α : Type u_1
β : Type ?u.94362
γ : Type ?u.94365
inst✝ : Union α
a b : Part α
hab : (a ∪ b).Dom
⊢ get (Part.bind a fun y => map (fun x => y ∪ x) b) (_ : (Part.bind a fun y => map (fun x => y ∪ x) b).Dom) =
    get a (_ : a.Dom) ∪ get b (_ : b.Dom)
Theorem: map_sub_le_max
File: Mathlib/Analysis/Normed/Group/Seminorm.lean

tactic: rw [sub_eq_add_neg, ← NonarchAddGroupSeminormClass.map_neg_eq_map' f y]
state_before: ι : Type ?u.10515
R : Type ?u.10518
R' : Type ?u.10521
E : Type u_1
F : Type u_2
G : Type ?u.10530
inst✝¹ : AddGroup E
inst✝ : NonarchAddGroupSeminormClass F E
f : F
x y : E
⊢ ↑f (x - y) ≤ max (↑f x) (↑f y)

tactic: exact map_add_le_max _ _ _
state_before: ι : Type ?u.10515
R : Type ?u.10518
R' : Type ?u.10521
E : Type u_1
F : Type u_2
G : Type ?u.10530
inst✝¹ : AddGroup E
inst✝ : NonarchAddGroupSeminormClass F E
f : F
x y : E
⊢ ↑f (x + -y) ≤ max (↑f x) (↑f (-y))
Theorem: div_ball_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: simp [div_eq_mul_inv, mul_ball_one]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ s / ball 1 δ = thickening δ s
Theorem: Matrix.conjTranspose_neg
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp
state_before: l : Type ?u.1052427
m : Type u_1
n : Type u_2
o : Type ?u.1052436
m' : o → Type ?u.1052441
n' : o → Type ?u.1052446
R : Type ?u.1052449
S : Type ?u.1052452
α : Type v
β : Type w
γ : Type ?u.1052459
inst✝¹ : AddGroup α
inst✝ : StarAddMonoid α
M : Matrix m n α
⊢ ∀ (i : n) (j : m), (-M)ᴴ i j = (-Mᴴ) i j
Theorem: minpoly.min
File: Mathlib/FieldTheory/Minpoly/Basic.lean

tactic: delta minpoly
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.37651
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
p : A[X]
pmonic : Monic p
hp : ↑(Polynomial.aeval x) p = 0
⊢ degree (minpoly A x) ≤ degree p

tactic: split_ifs with hx
state_before: A : Type u_1
B : Type u_2
B' : Type ?u.37651
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
p : A[X]
pmonic : Monic p
hp : ↑(Polynomial.aeval x) p = 0
⊢ degree
      (if hx : IsIntegral A x then
        WellFounded.min (_ : WellFounded fun p q => degree p < degree q)
          (fun x_1 => Monic x_1 ∧ eval₂ (algebraMap A B) x x_1 = 0) hx
      else 0) ≤
    degree p

tactic: exact le_of_not_lt (degree_lt_wf.not_lt_min _ hx ⟨pmonic, hp⟩)
state_before: case inl
A : Type u_1
B : Type u_2
B' : Type ?u.37651
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
p : A[X]
pmonic : Monic p
hp : ↑(Polynomial.aeval x) p = 0
hx : IsIntegral A x
⊢ degree
      (WellFounded.min (_ : WellFounded fun p q => degree p < degree q)
        (fun x_1 => Monic x_1 ∧ eval₂ (algebraMap A B) x x_1 = 0) hx) ≤
    degree p

tactic: simp only [degree_zero, bot_le]
state_before: case inr
A : Type u_1
B : Type u_2
B' : Type ?u.37651
inst✝⁴ : CommRing A
inst✝³ : Ring B
inst✝² : Ring B'
inst✝¹ : Algebra A B
inst✝ : Algebra A B'
x : B
p : A[X]
pmonic : Monic p
hp : ↑(Polynomial.aeval x) p = 0
hx : ¬IsIntegral A x
⊢ degree 0 ≤ degree p
Theorem: Set.Ioc_union_Ioc'
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: ext1 x
state_before: α : Type u_1
β : Type ?u.132878
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
⊢ Ioc a b ∪ Ioc c d = Ioc (min a c) (max b d)

tactic: simp_rw [mem_union, mem_Ioc, min_lt_iff, le_max_iff]
state_before: case h
α : Type u_1
β : Type ?u.132878
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
⊢ x ∈ Ioc a b ∪ Ioc c d ↔ x ∈ Ioc (min a c) (max b d)

tactic: by_cases hc : c < x <;> by_cases hd : x ≤ d
state_before: case h
α : Type u_1
β : Type ?u.132878
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
⊢ a < x ∧ x ≤ b ∨ c < x ∧ x ≤ d ↔ (a < x ∨ c < x) ∧ (x ≤ b ∨ x ≤ d)

tactic: simp only [hc, hd, and_self, or_true]
state_before: case pos
α : Type u_1
β : Type ?u.132878
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : c < x
hd : x ≤ d
⊢ a < x ∧ x ≤ b ∨ c < x ∧ x ≤ d ↔ (a < x ∨ c < x) ∧ (x ≤ b ∨ x ≤ d)

tactic: have hax : a < x := h₂.trans_lt (lt_of_not_ge hd)
state_before: case neg
α : Type u_1
β : Type ?u.132878
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : c < x
hd : ¬x ≤ d
⊢ a < x ∧ x ≤ b ∨ c < x ∧ x ≤ d ↔ (a < x ∨ c < x) ∧ (x ≤ b ∨ x ≤ d)

tactic: simp only [hax, true_and, hc, or_self]
state_before: case neg
α : Type u_1
β : Type ?u.132878
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : c < x
hd : ¬x ≤ d
hax : a < x
⊢ a < x ∧ x ≤ b ∨ c < x ∧ x ≤ d ↔ (a < x ∨ c < x) ∧ (x ≤ b ∨ x ≤ d)

tactic: have hxb : x ≤ b := (le_of_not_gt hc).trans h₁
state_before: case pos
α : Type u_1
β : Type ?u.132878
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : ¬c < x
hd : x ≤ d
⊢ a < x ∧ x ≤ b ∨ c < x ∧ x ≤ d ↔ (a < x ∨ c < x) ∧ (x ≤ b ∨ x ≤ d)

tactic: simp only [hxb, and_true, hc, false_and, or_false, true_or]
state_before: case pos
α : Type u_1
β : Type ?u.132878
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : ¬c < x
hd : x ≤ d
hxb : x ≤ b
⊢ a < x ∧ x ≤ b ∨ c < x ∧ x ≤ d ↔ (a < x ∨ c < x) ∧ (x ≤ b ∨ x ≤ d)

tactic: simp only [hc, hd, and_self, or_false]
state_before: case neg
α : Type u_1
β : Type ?u.132878
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
h₁ : c ≤ b
h₂ : a ≤ d
x : α
hc : ¬c < x
hd : ¬x ≤ d
⊢ a < x ∧ x ≤ b ∨ c < x ∧ x ≤ d ↔ (a < x ∨ c < x) ∧ (x ≤ b ∨ x ≤ d)
Theorem: Complex.map_exp_comap_re_atBot
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: rw [← comap_exp_nhds_zero, map_comap, range_exp, nhdsWithin]
state_before: ⊢ map exp (comap re atBot) = 𝓝[{0}ᶜ] 0
Theorem: List.subperm_cons_diff
File: Mathlib/Data/List/Perm.lean

tactic: simp
state_before: α : Type uu
β : Type vv
l₁✝ l₂ : List α
inst✝ : DecidableEq α
a : α
l₁ : List α
⊢ ∃ x, a :: l₁ <+ a :: List.diff l₁ []

tactic: simp only [diff_cons]
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a : α
l₁ : List α
b : α
l₂ : List α
⊢ List.diff (a :: l₁) (b :: l₂) <+~ a :: List.diff l₁ (b :: l₂)

tactic: refine' ((erase_cons_subperm_cons_erase a b l₁).diff_right l₂).trans _
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a : α
l₁ : List α
b : α
l₂ : List α
⊢ List.diff (List.erase (a :: l₁) b) l₂ <+~ a :: List.diff (List.erase l₁ b) l₂

tactic: apply subperm_cons_diff
state_before: α : Type uu
β : Type vv
l₁✝ l₂✝ : List α
inst✝ : DecidableEq α
a : α
l₁ : List α
b : α
l₂ : List α
⊢ List.diff (a :: List.erase l₁ b) l₂ <+~ a :: List.diff (List.erase l₁ b) l₂
Theorem: StructureGroupoid.LocalInvariantProp.liftPropWithinAt_indep_chart_aux
File: Mathlib/Geometry/Manifold/LocalInvariantProperties.lean

tactic: rw [← Function.comp.assoc, hG.liftPropWithinAt_indep_chart_source_aux (f ∘ g) he xe he' xe',
  Function.comp.assoc, hG.liftPropWithinAt_indep_chart_target_aux xe' hf xf hf' xf' hgs]
state_before: H : Type u_1
M : Type u_2
H' : Type u_3
M' : Type u_4
X : Type ?u.22285
inst✝⁶ : TopologicalSpace H
inst✝⁵ : TopologicalSpace M
inst✝⁴ : ChartedSpace H M
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
inst✝¹ : ChartedSpace H' M'
inst✝ : TopologicalSpace X
G : StructureGroupoid H
G' : StructureGroupoid H'
e e' : LocalHomeomorph M H
f f' : LocalHomeomorph M' H'
P : (H → H') → Set H → H → Prop
g g' : M → M'
s t : Set M
x : M
Q : (H → H) → Set H → H → Prop
hG : LocalInvariantProp G G' P
he : e ∈ maximalAtlas M G
xe : x ∈ e.source
he' : e' ∈ maximalAtlas M G
xe' : x ∈ e'.source
hf : f ∈ maximalAtlas M' G'
xf : g x ∈ f.source
hf' : f' ∈ maximalAtlas M' G'
xf' : g x ∈ f'.source
hgs : ContinuousWithinAt g s x
⊢ P (↑f ∘ g ∘ ↑(LocalHomeomorph.symm e)) (↑(LocalHomeomorph.symm e) ⁻¹' s) (↑e x) ↔
    P (↑f' ∘ g ∘ ↑(LocalHomeomorph.symm e')) (↑(LocalHomeomorph.symm e') ⁻¹' s) (↑e' x)
Theorem: TopologicalSpace.IsTopologicalBasis.exists_nonempty_subset
File: Mathlib/Topology/Bases.lean

tactic: cases' hu with x hx
state_before: α : Type u
t : TopologicalSpace α
B : Set (Set α)
hb : IsTopologicalBasis B
u : Set α
hu : Set.Nonempty u
ou : IsOpen u
⊢ ∃ v, v ∈ B ∧ Set.Nonempty v ∧ v ⊆ u

tactic: rw [hb.open_eq_sUnion' ou, mem_sUnion] at hx
state_before: case intro
α : Type u
t : TopologicalSpace α
B : Set (Set α)
hb : IsTopologicalBasis B
u : Set α
ou : IsOpen u
x : α
hx : x ∈ u
⊢ ∃ v, v ∈ B ∧ Set.Nonempty v ∧ v ⊆ u

tactic: rcases hx with ⟨v, hv, hxv⟩
state_before: case intro
α : Type u
t : TopologicalSpace α
B : Set (Set α)
hb : IsTopologicalBasis B
u : Set α
ou : IsOpen u
x : α
hx : ∃ t, t ∈ {s | s ∈ B ∧ s ⊆ u} ∧ x ∈ t
⊢ ∃ v, v ∈ B ∧ Set.Nonempty v ∧ v ⊆ u

tactic: exact ⟨v, hv.1, ⟨x, hxv⟩, hv.2⟩
state_before: case intro.intro.intro
α : Type u
t : TopologicalSpace α
B : Set (Set α)
hb : IsTopologicalBasis B
u : Set α
ou : IsOpen u
x : α
v : Set α
hv : v ∈ {s | s ∈ B ∧ s ⊆ u}
hxv : x ∈ v
⊢ ∃ v, v ∈ B ∧ Set.Nonempty v ∧ v ⊆ u
Theorem: Filter.Tendsto.piecewise_nhdsWithin
File: Mathlib/Topology/ContinuousOn.lean

tactic: apply Tendsto.piecewise <;> rwa [← nhdsWithin_inter']
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.185821
δ : Type ?u.185824
inst✝¹ : TopologicalSpace α
f g : α → β
t : Set α
inst✝ : (x : α) → Decidable (x ∈ t)
a : α
s : Set α
l : Filter β
h₀ : Tendsto f (𝓝[s ∩ t] a) l
h₁ : Tendsto g (𝓝[s ∩ tᶜ] a) l
⊢ Tendsto (piecewise t f g) (𝓝[s] a) l
Theorem: dist_eq_norm_div'
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [dist_comm, dist_eq_norm_div]
state_before: 𝓕 : Type ?u.47032
𝕜 : Type ?u.47035
α : Type ?u.47038
ι : Type ?u.47041
κ : Type ?u.47044
E : Type u_1
F : Type ?u.47050
G : Type ?u.47053
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a✝ a₁ a₂ b✝ b₁ b₂ : E
r r₁ r₂ : ℝ
a b : E
⊢ dist a b = ‖b / a‖
Theorem: Vector.toList_append
File: Mathlib/Data/Vector.lean

tactic: cases v
state_before: α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
v : Vector α n
w : Vector α m
⊢ toList (append v w) = toList v ++ toList w

tactic: cases w
state_before: case mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
w : Vector α m
val✝ : List α
property✝ : List.length val✝ = n
⊢ toList (append { val := val✝, property := property✝ } w) = toList { val := val✝, property := property✝ } ++ toList w

tactic: rfl
state_before: case mk.mk
α : Type u
β : Type v
φ : Type w
n✝ n m : ℕ
val✝¹ : List α
property✝¹ : List.length val✝¹ = n
val✝ : List α
property✝ : List.length val✝ = m
⊢ toList (append { val := val✝¹, property := property✝¹ } { val := val✝, property := property✝ }) =
    toList { val := val✝¹, property := property✝¹ } ++ toList { val := val✝, property := property✝ }
Theorem: Int.neg_add_le_left_of_le_add
File: Std/Data/Int/Lemmas.lean

tactic: rw [Int.add_comm]
state_before: a b c : Int
h : a ≤ b + c
⊢ -b + a ≤ c

tactic: exact Int.sub_left_le_of_le_add h
state_before: a b c : Int
h : a ≤ b + c
⊢ a + -b ≤ c
Theorem: List.isRotated_singleton_iff
File: Mathlib/Data/List/Rotate.lean

tactic: simpa using hn
state_before: α : Type u
l l' : List α
x : α
x✝ : l ~r [x]
n : ℕ
hn : rotate l n = [x]
⊢ l = [x]

tactic: rfl
state_before: α : Type u
l l' : List α
x : α
h : l = [x]
⊢ l ~r l
Theorem: PowerSeries.trunc_zero
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [coeff_trunc, LinearMap.map_zero, Polynomial.coeff_zero]
state_before: R : Type u_1
inst✝ : CommSemiring R
n m : ℕ
⊢ Polynomial.coeff (trunc n 0) m = Polynomial.coeff 0 m

tactic: split_ifs <;> rfl
state_before: R : Type u_1
inst✝ : CommSemiring R
n m : ℕ
⊢ (if m < n then 0 else 0) = 0
Theorem: Nat.pos_of_mem_divisors
File: Mathlib/NumberTheory/Divisors.lean

tactic: cases m
state_before: n m : ℕ
h : m ∈ divisors n
⊢ 0 < m

tactic: apply Nat.succ_pos
state_before: case succ
n n✝ : ℕ
h : succ n✝ ∈ divisors n
⊢ 0 < succ n✝

tactic: rw [mem_divisors, zero_eq, zero_dvd_iff (a := n)] at h
state_before: case zero
n : ℕ
h : zero ∈ divisors n
⊢ 0 < zero

tactic: cases h.2 h.1
state_before: case zero
n : ℕ
h : n = 0 ∧ n ≠ 0
⊢ 0 < zero
Theorem: deriv_zpow
File: Mathlib/Analysis/Calculus/Deriv/ZPow.lean

tactic: by_cases H : x ≠ 0 ∨ 0 ≤ m
state_before: 𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m✝ m : ℤ
x : 𝕜
⊢ deriv (fun x => x ^ m) x = ↑m * x ^ (m - 1)

tactic: exact (hasDerivAt_zpow m x H).deriv
state_before: case pos
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m✝ m : ℤ
x : 𝕜
H : x ≠ 0 ∨ 0 ≤ m
⊢ deriv (fun x => x ^ m) x = ↑m * x ^ (m - 1)

tactic: rw [deriv_zero_of_not_differentiableAt (mt differentiableAt_zpow.1 H)]
state_before: case neg
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m✝ m : ℤ
x : 𝕜
H : ¬(x ≠ 0 ∨ 0 ≤ m)
⊢ deriv (fun x => x ^ m) x = ↑m * x ^ (m - 1)

tactic: push_neg at H
state_before: case neg
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m✝ m : ℤ
x : 𝕜
H : ¬(x ≠ 0 ∨ 0 ≤ m)
⊢ 0 = ↑m * x ^ (m - 1)

tactic: rcases H with ⟨rfl, hm⟩
state_before: case neg
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x✝ : 𝕜
s : Set 𝕜
m✝ m : ℤ
x : 𝕜
H : x = 0 ∧ m < 0
⊢ 0 = ↑m * x ^ (m - 1)

tactic: rw [zero_zpow _ ((sub_one_lt _).trans hm).ne, MulZeroClass.mul_zero]
state_before: case neg.intro
𝕜 : Type u
inst✝² : NontriviallyNormedField 𝕜
E : Type v
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
x : 𝕜
s : Set 𝕜
m✝ m : ℤ
hm : m < 0
⊢ 0 = ↑m * 0 ^ (m - 1)
Theorem: tendsto_measure_cthickening_of_isClosed
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: convert tendsto_measure_cthickening hs
state_before: α : Type u_1
β : Type ?u.2148000
γ : Type ?u.2148003
γ₂ : Type ?u.2148006
δ : Type ?u.2148009
ι : Sort y
s✝ t u : Set α
inst✝³ : PseudoMetricSpace α
inst✝² : MeasurableSpace α
inst✝¹ : OpensMeasurableSpace α
inst✝ : MeasurableSpace β
x : α
ε : ℝ
μ : MeasureTheory.Measure α
s : Set α
hs : ∃ R, R > 0 ∧ ↑↑μ (cthickening R s) ≠ ⊤
h's : IsClosed s
⊢ Tendsto (fun r => ↑↑μ (cthickening r s)) (𝓝 0) (𝓝 (↑↑μ s))

tactic: exact h's.closure_eq.symm
state_before: case h.e'_5.h.e'_3.h.e'_3
α : Type u_1
β : Type ?u.2148000
γ : Type ?u.2148003
γ₂ : Type ?u.2148006
δ : Type ?u.2148009
ι : Sort y
s✝ t u : Set α
inst✝³ : PseudoMetricSpace α
inst✝² : MeasurableSpace α
inst✝¹ : OpensMeasurableSpace α
inst✝ : MeasurableSpace β
x : α
ε : ℝ
μ : MeasureTheory.Measure α
s : Set α
hs : ∃ R, R > 0 ∧ ↑↑μ (cthickening R s) ≠ ⊤
h's : IsClosed s
⊢ s = closure s
Theorem: Nat.mod_eq
File: src/lean/Init/Data/Nat/Div.lean

tactic: rw [←Nat.modCore_eq_mod, ←Nat.modCore_eq_mod, Nat.modCore]
state_before: x y : Nat
⊢ x % y = ite (0 < y ∧ y ≤ x) ((x - y) % y) x
Theorem: Finset.union_product
File: Mathlib/Data/Finset/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.72393
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
⊢ (s ∪ s') ×ˢ t = s ×ˢ t ∪ s' ×ˢ t

tactic: simp only [or_and_right, mem_union, mem_product]
state_before: case a.mk
α : Type u_1
β : Type u_2
γ : Type ?u.72393
s s' : Finset α
t t' : Finset β
a : α
b : β
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
x : α
y : β
⊢ (x, y) ∈ (s ∪ s') ×ˢ t ↔ (x, y) ∈ s ×ˢ t ∪ s' ×ˢ t
Theorem: Set.sUnion_eq_biUnion
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [← sUnion_image, image_id']
state_before: α : Type u_1
β : Type ?u.166966
γ : Type ?u.166969
ι : Sort ?u.166972
ι' : Sort ?u.166975
ι₂ : Sort ?u.166978
κ : ι → Sort ?u.166983
κ₁ : ι → Sort ?u.166988
κ₂ : ι → Sort ?u.166993
κ' : ι' → Sort ?u.166998
s : Set (Set α)
⊢ ⋃₀ s = ⋃ (i : Set α) (_ : i ∈ s), i
Theorem: IsAlgClosed.isAlgClosure_of_transcendence_basis
File: Mathlib/FieldTheory/IsAlgClosed/Classification.lean

tactic: infer_instance
state_before: R : Type u_3
L : Type ?u.15753
K : Type u_1
inst✝⁵ : CommRing R
inst✝⁴ : Field K
inst✝³ : Algebra R K
inst✝² : Field L
inst✝¹ : Algebra R L
ι : Type u_2
v : ι → K
κ : Type ?u.16224
w : κ → L
hv✝ : AlgebraicIndependent R v
inst✝ : IsAlgClosed K
hv : IsTranscendenceBasis R v
this : Nontrivial R := RingHom.domain_nontrivial (algebraMap R K)
⊢ IsAlgClosed K
Theorem: isClosed_setOf_specializes
File: Mathlib/Topology/Separation.lean

tactic: simp only [← isOpen_compl_iff, compl_setOf, ← disjoint_nhds_nhds_iff_not_specializes,
  isOpen_setOf_disjoint_nhds_nhds]
state_before: α : Type u
β : Type v
inst✝¹ : TopologicalSpace α
inst✝ : RegularSpace α
a : α
s : Set α
⊢ IsClosed {p | p.fst ⤳ p.snd}
Theorem: Fintype.card_eq_zero_iff
File: Mathlib/Data/Fintype/Card.lean

tactic: rw [card, Finset.card_eq_zero, univ_eq_empty_iff]
state_before: α : Type u_1
β : Type ?u.20910
γ : Type ?u.20913
inst✝¹ : Fintype α
inst✝ : Fintype β
⊢ card α = 0 ↔ IsEmpty α
Theorem: Real.cocompact_eq
File: Mathlib/Topology/Instances/Real.lean

tactic: simp only [← comap_dist_right_atTop_eq_cocompact (0 : ℝ), Real.dist_eq, sub_zero,
  comap_abs_atTop]
state_before: α : Type u
β : Type v
γ : Type w
⊢ cocompact ℝ = atBot ⊔ atTop
Theorem: Polynomial.natDegree_sub_le
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: simpa only [← natDegree_neg q] using natDegree_add_le p (-q)
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p✝ q✝ p q : R[X]
⊢ natDegree (p - q) ≤ max (natDegree p) (natDegree q)
Theorem: Real.tanh_neg
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [tanh, neg_div]
state_before: x y : ℝ
⊢ tanh (-x) = -tanh x
Theorem: Filter.hasBasis_iInf_of_directed'
File: Mathlib/Order/Filter/Bases.lean

tactic: refine' ⟨fun t => _⟩
state_before: α : Type u_3
β : Type ?u.35404
γ : Type ?u.35407
ι✝ : Sort ?u.35410
ι'✝ : Sort ?u.35413
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t : Set α
i : ι✝
p' : ι'✝ → Prop
s' : ι'✝ → Set α
i' : ι'✝
ι : Type u_1
ι' : ι → Type u_2
inst✝ : Nonempty ι
l : ι → Filter α
s : (i : ι) → ι' i → Set α
p : (i : ι) → ι' i → Prop
hl : ∀ (i : ι), HasBasis (l i) (p i) (s i)
h : Directed (fun x x_1 => x ≥ x_1) l
⊢ HasBasis (⨅ (i : ι), l i) (fun ii' => p ii'.fst ii'.snd) fun ii' => s ii'.fst ii'.snd

tactic: rw [mem_iInf_of_directed h, Sigma.exists]
state_before: α : Type u_3
β : Type ?u.35404
γ : Type ?u.35407
ι✝ : Sort ?u.35410
ι'✝ : Sort ?u.35413
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t✝ : Set α
i : ι✝
p' : ι'✝ → Prop
s' : ι'✝ → Set α
i' : ι'✝
ι : Type u_1
ι' : ι → Type u_2
inst✝ : Nonempty ι
l : ι → Filter α
s : (i : ι) → ι' i → Set α
p : (i : ι) → ι' i → Prop
hl : ∀ (i : ι), HasBasis (l i) (p i) (s i)
h : Directed (fun x x_1 => x ≥ x_1) l
t : Set α
⊢ (t ∈ ⨅ (i : ι), l i) ↔ ∃ i, p i.fst i.snd ∧ s i.fst i.snd ⊆ t

tactic: exact exists_congr fun i => (hl i).mem_iff
state_before: α : Type u_3
β : Type ?u.35404
γ : Type ?u.35407
ι✝ : Sort ?u.35410
ι'✝ : Sort ?u.35413
l✝ l' : Filter α
p✝ : ι✝ → Prop
s✝ : ι✝ → Set α
t✝ : Set α
i : ι✝
p' : ι'✝ → Prop
s' : ι'✝ → Set α
i' : ι'✝
ι : Type u_1
ι' : ι → Type u_2
inst✝ : Nonempty ι
l : ι → Filter α
s : (i : ι) → ι' i → Set α
p : (i : ι) → ι' i → Prop
hl : ∀ (i : ι), HasBasis (l i) (p i) (s i)
h : Directed (fun x x_1 => x ≥ x_1) l
t : Set α
⊢ (∃ i, t ∈ l i) ↔
    ∃ a b,
      p { fst := a, snd := b }.fst { fst := a, snd := b }.snd ∧
        s { fst := a, snd := b }.fst { fst := a, snd := b }.snd ⊆ t
Theorem: PicardLindelof.FunSpace.dist_iterate_next_apply_le
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: induction' n with n ihn generalizing t
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
inst✝ : CompleteSpace E
f₁ f₂ : FunSpace v
n : ℕ
t : ↑(Icc v.tMin v.tMax)
⊢ dist (toFun ((next^[n]) f₁) t) (toFun ((next^[n]) f₂) t) ≤ (↑v.L * abs (↑t - ↑v.t₀)) ^ n / ↑n ! * dist f₁ f₂

tactic: rw [Nat.zero_eq, pow_zero, Nat.factorial_zero, Nat.cast_one, div_one, one_mul]
state_before: case zero
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
inst✝ : CompleteSpace E
f₁ f₂ : FunSpace v
t✝ t : ↑(Icc v.tMin v.tMax)
⊢ dist (toFun ((next^[Nat.zero]) f₁) t) (toFun ((next^[Nat.zero]) f₂) t) ≤
    (↑v.L * abs (↑t - ↑v.t₀)) ^ Nat.zero / ↑Nat.zero ! * dist f₁ f₂

tactic: exact dist_apply_le_dist f₁ f₂ t
state_before: case zero
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
inst✝ : CompleteSpace E
f₁ f₂ : FunSpace v
t✝ t : ↑(Icc v.tMin v.tMax)
⊢ dist (toFun ((next^[0]) f₁) t) (toFun ((next^[0]) f₂) t) ≤ dist f₁ f₂

tactic: rw [iterate_succ_apply', iterate_succ_apply']
state_before: case succ
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
inst✝ : CompleteSpace E
f₁ f₂ : FunSpace v
t✝ : ↑(Icc v.tMin v.tMax)
n : ℕ
ihn :
  ∀ (t : ↑(Icc v.tMin v.tMax)),
    dist (toFun ((next^[n]) f₁) t) (toFun ((next^[n]) f₂) t) ≤ (↑v.L * abs (↑t - ↑v.t₀)) ^ n / ↑n ! * dist f₁ f₂
t : ↑(Icc v.tMin v.tMax)
⊢ dist (toFun ((next^[Nat.succ n]) f₁) t) (toFun ((next^[Nat.succ n]) f₂) t) ≤
    (↑v.L * abs (↑t - ↑v.t₀)) ^ Nat.succ n / ↑(Nat.succ n)! * dist f₁ f₂

tactic: exact dist_next_apply_le_of_le ihn _
state_before: case succ
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
v : PicardLindelof E
f : FunSpace v
inst✝ : CompleteSpace E
f₁ f₂ : FunSpace v
t✝ : ↑(Icc v.tMin v.tMax)
n : ℕ
ihn :
  ∀ (t : ↑(Icc v.tMin v.tMax)),
    dist (toFun ((next^[n]) f₁) t) (toFun ((next^[n]) f₂) t) ≤ (↑v.L * abs (↑t - ↑v.t₀)) ^ n / ↑n ! * dist f₁ f₂
t : ↑(Icc v.tMin v.tMax)
⊢ dist (toFun (next ((next^[n]) f₁)) t) (toFun (next ((next^[n]) f₂)) t) ≤
    (↑v.L * abs (↑t - ↑v.t₀)) ^ Nat.succ n / ↑(Nat.succ n)! * dist f₁ f₂