tasksource/leandojo huggingface dataset:
Theorem: Filter.tendsto_atTop_finset_of_monotone
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [atTop_finset_eq_iInf, tendsto_iInf, tendsto_principal]
state_before: ι : Type ?u.269296
ι' : Type ?u.269299
α : Type u_2
β : Type u_1
γ : Type ?u.269308
inst✝ : Preorder β
f : β → Finset α
h : Monotone f
h' : ∀ (x : α), ∃ n, x ∈ f n
⊢ Tendsto f atTop atTop

tactic: intro a
state_before: ι : Type ?u.269296
ι' : Type ?u.269299
α : Type u_2
β : Type u_1
γ : Type ?u.269308
inst✝ : Preorder β
f : β → Finset α
h : Monotone f
h' : ∀ (x : α), ∃ n, x ∈ f n
⊢ ∀ (i : α), ∀ᶠ (a : β) in atTop, f a ∈ Ici {i}

tactic: rcases h' a with ⟨b, hb⟩
state_before: ι : Type ?u.269296
ι' : Type ?u.269299
α : Type u_2
β : Type u_1
γ : Type ?u.269308
inst✝ : Preorder β
f : β → Finset α
h : Monotone f
h' : ∀ (x : α), ∃ n, x ∈ f n
a : α
⊢ ∀ᶠ (a_1 : β) in atTop, f a_1 ∈ Ici {a}

tactic: exact (eventually_ge_atTop b).mono fun b' hb' => (Finset.singleton_subset_iff.2 hb).trans (h hb')
state_before: case intro
ι : Type ?u.269296
ι' : Type ?u.269299
α : Type u_2
β : Type u_1
γ : Type ?u.269308
inst✝ : Preorder β
f : β → Finset α
h : Monotone f
h' : ∀ (x : α), ∃ n, x ∈ f n
a : α
b : β
hb : a ∈ f b
⊢ ∀ᶠ (a_1 : β) in atTop, f a_1 ∈ Ici {a}
Theorem: exists_npow_eq_one_of_zpow_eq_one
File: Mathlib/Algebra/Group/Basic.lean

tactic: cases' n with n n
state_before: α : Type ?u.63936
β : Type ?u.63939
G : Type u_1
inst✝ : Group G
a b c d : G
n : ℤ
hn : n ≠ 0
x : G
h : x ^ n = 1
⊢ ∃ n, 0 < n ∧ x ^ n = 1

tactic: simp only [Int.ofNat_eq_coe] at h
state_before: case ofNat
α : Type ?u.63936
β : Type ?u.63939
G : Type u_1
inst✝ : Group G
a b c d x : G
n : ℕ
hn : Int.ofNat n ≠ 0
h : x ^ Int.ofNat n = 1
⊢ ∃ n, 0 < n ∧ x ^ n = 1

tactic: rw [zpow_ofNat] at h
state_before: case ofNat
α : Type ?u.63936
β : Type ?u.63939
G : Type u_1
inst✝ : Group G
a b c d x : G
n : ℕ
hn : Int.ofNat n ≠ 0
h : x ^ ↑n = 1
⊢ ∃ n, 0 < n ∧ x ^ n = 1

tactic: refine' ⟨n, Nat.pos_of_ne_zero fun n0 ↦ hn ?_, h⟩
state_before: case ofNat
α : Type ?u.63936
β : Type ?u.63939
G : Type u_1
inst✝ : Group G
a b c d x : G
n : ℕ
hn : Int.ofNat n ≠ 0
h : x ^ n = 1
⊢ ∃ n, 0 < n ∧ x ^ n = 1

tactic: rw [n0]
state_before: case ofNat
α : Type ?u.63936
β : Type ?u.63939
G : Type u_1
inst✝ : Group G
a b c d x : G
n : ℕ
hn : Int.ofNat n ≠ 0
h : x ^ n = 1
n0 : n = 0
⊢ Int.ofNat n = 0

tactic: rfl
state_before: case ofNat
α : Type ?u.63936
β : Type ?u.63939
G : Type u_1
inst✝ : Group G
a b c d x : G
n : ℕ
hn : Int.ofNat n ≠ 0
h : x ^ n = 1
n0 : n = 0
⊢ Int.ofNat 0 = 0

tactic: rw [zpow_negSucc, inv_eq_one] at h
state_before: case negSucc
α : Type ?u.63936
β : Type ?u.63939
G : Type u_1
inst✝ : Group G
a b c d x : G
n : ℕ
hn : Int.negSucc n ≠ 0
h : x ^ Int.negSucc n = 1
⊢ ∃ n, 0 < n ∧ x ^ n = 1

tactic: refine' ⟨n + 1, n.succ_pos, h⟩
state_before: case negSucc
α : Type ?u.63936
β : Type ?u.63939
G : Type u_1
inst✝ : Group G
a b c d x : G
n : ℕ
hn : Int.negSucc n ≠ 0
h : x ^ (n + 1) = 1
⊢ ∃ n, 0 < n ∧ x ^ n = 1
Theorem: Matrix.smul_vec3
File: Mathlib/Data/Matrix/Notation.lean

tactic: rw [smul_cons, smul_cons, smul_cons, smul_empty]
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
R : Type u_1
inst✝ : SMul R α
x : R
a₀ a₁ a₂ : α
⊢ x • ![a₀, a₁, a₂] = ![x • a₀, x • a₁, x • a₂]
Theorem: Units.mk0_mul
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: ext
state_before: α : Type ?u.18576
M₀ : Type ?u.18579
G₀ : Type u_1
M₀' : Type ?u.18585
G₀' : Type ?u.18588
F : Type ?u.18591
F' : Type ?u.18594
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c x y : G₀
hxy : x * y ≠ 0
⊢ mk0 (x * y) hxy = mk0 x (_ : x ≠ 0) * mk0 y (_ : y ≠ 0)

tactic: rfl
state_before: case a
α : Type ?u.18576
M₀ : Type ?u.18579
G₀ : Type u_1
M₀' : Type ?u.18585
G₀' : Type ?u.18588
F : Type ?u.18591
F' : Type ?u.18594
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c x y : G₀
hxy : x * y ≠ 0
⊢ ↑(mk0 (x * y) hxy) = ↑(mk0 x (_ : x ≠ 0) * mk0 y (_ : y ≠ 0))
Theorem: CofiniteTopology.isClosed_iff
File: Mathlib/Topology/Constructions.lean

tactic: simp only [← isOpen_compl_iff, isOpen_iff', compl_compl, compl_empty_iff]
state_before: α : Type u
β : Type v
γ : Type ?u.17786
δ : Type ?u.17789
ε : Type ?u.17792
ζ : Type ?u.17795
s : Set (CofiniteTopology α)
⊢ IsClosed s ↔ s = univ ∨ Set.Finite s
Theorem: gauge_zero'
File: Mathlib/Analysis/Convex/Gauge.lean

tactic: ext x
state_before: 𝕜 : Type ?u.24181
E : Type u_1
F : Type ?u.24187
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
⊢ gauge 0 = 0

tactic: rw [gauge_def']
state_before: case h
𝕜 : Type ?u.24181
E : Type u_1
F : Type ?u.24187
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
x : E
⊢ gauge 0 x = OfNat.ofNat 0 x

tactic: obtain rfl | hx := eq_or_ne x 0
state_before: case h
𝕜 : Type ?u.24181
E : Type u_1
F : Type ?u.24187
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
x : E
⊢ sInf {r | r ∈ Ioi 0 ∧ r⁻¹ • x ∈ 0} = OfNat.ofNat 0 x

tactic: simp only [csInf_Ioi, mem_zero, Pi.zero_apply, eq_self_iff_true, sep_true, smul_zero]
state_before: case h.inl
𝕜 : Type ?u.24181
E : Type u_1
F : Type ?u.24187
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
⊢ sInf {r | r ∈ Ioi 0 ∧ r⁻¹ • 0 ∈ 0} = OfNat.ofNat 0 0

tactic: simp only [mem_zero, Pi.zero_apply, inv_eq_zero, smul_eq_zero]
state_before: case h.inr
𝕜 : Type ?u.24181
E : Type u_1
F : Type ?u.24187
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
x : E
hx : x ≠ 0
⊢ sInf {r | r ∈ Ioi 0 ∧ r⁻¹ • x ∈ 0} = OfNat.ofNat 0 x

tactic: convert Real.sInf_empty
state_before: case h.inr
𝕜 : Type ?u.24181
E : Type u_1
F : Type ?u.24187
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
x : E
hx : x ≠ 0
⊢ sInf {r | r ∈ Ioi 0 ∧ (r = 0 ∨ x = 0)} = 0

tactic: exact eq_empty_iff_forall_not_mem.2 fun r hr => hr.2.elim (ne_of_gt hr.1) hx
state_before: case h.e'_2.h.e'_3
𝕜 : Type ?u.24181
E : Type u_1
F : Type ?u.24187
inst✝¹ : AddCommGroup E
inst✝ : Module ℝ E
s t : Set E
a : ℝ
x : E
hx : x ≠ 0
⊢ {r | r ∈ Ioi 0 ∧ (r = 0 ∨ x = 0)} = ∅
Theorem: Int.dvd_sub
File: Std/Data/Int/DivMod.lean

tactic: rw [Int.mul_sub]
state_before: a✝ d e : Int
⊢ a✝ * d - a✝ * e = a✝ * (d - e)
Theorem: norm_le_norm_add_norm_div
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: rw [norm_div_rev]
state_before: 𝓕 : Type ?u.86263
𝕜 : Type ?u.86266
α : Type ?u.86269
ι : Type ?u.86272
κ : Type ?u.86275
E : Type u_1
F : Type ?u.86281
G : Type ?u.86284
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
u v : E
⊢ ‖v‖ ≤ ‖u‖ + ‖u / v‖

tactic: exact norm_le_norm_add_norm_div' v u
state_before: 𝓕 : Type ?u.86263
𝕜 : Type ?u.86266
α : Type ?u.86269
ι : Type ?u.86272
κ : Type ?u.86275
E : Type u_1
F : Type ?u.86281
G : Type ?u.86284
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
u v : E
⊢ ‖v‖ ≤ ‖u‖ + ‖v / u‖
Theorem: Prod.image_mk_segment_right
File: Mathlib/Analysis/Convex/Segment.lean

tactic: ext ⟨x', y'⟩
state_before: 𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.327345
ι : Type ?u.327348
π : ι → Type ?u.327353
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x : E
y₁ y₂ : F
⊢ (fun y => (x, y)) '' [y₁-[𝕜]y₂] = [(x, y₁)-[𝕜](x, y₂)]

tactic: simp_rw [Set.mem_image, segment, Set.mem_setOf, Prod.smul_mk, Prod.mk_add_mk, Prod.mk.inj_iff, ←
  exists_and_right, @exists_comm F, exists_eq_left']
state_before: case h.mk
𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.327345
ι : Type ?u.327348
π : ι → Type ?u.327353
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x : E
y₁ y₂ : F
x' : E
y' : F
⊢ (x', y') ∈ (fun y => (x, y)) '' [y₁-[𝕜]y₂] ↔ (x', y') ∈ [(x, y₁)-[𝕜](x, y₂)]

tactic: refine' exists₅_congr fun a b ha hb hab => _
state_before: case h.mk
𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.327345
ι : Type ?u.327348
π : ι → Type ?u.327353
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x : E
y₁ y₂ : F
x' : E
y' : F
⊢ (∃ b b_1 h h h, x = x' ∧ b • y₁ + b_1 • y₂ = y') ↔ ∃ a b h h h, a • x + b • x = x' ∧ a • y₁ + b • y₂ = y'

tactic: rw [Convex.combo_self hab]
state_before: case h.mk
𝕜 : Type u_3
E : Type u_1
F : Type u_2
G : Type ?u.327345
ι : Type ?u.327348
π : ι → Type ?u.327353
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x : E
y₁ y₂ : F
x' : E
y' : F
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ x = x' ∧ a • y₁ + b • y₂ = y' ↔ a • x + b • x = x' ∧ a • y₁ + b • y₂ = y'
Theorem: Real.sqrtTwoAddSeries_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simp
state_before: x : ℝ
⊢ sqrtTwoAddSeries x 0 = x
Theorem: OnePoint.nhdsWithin_compl_infty_eq
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: refine' (nhdsWithin_basis_open ∞ _).ext (hasBasis_coclosedCompact.map _) _ _
state_before: X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ 𝓝[{∞}ᶜ] ∞ = map some (coclosedCompact X)

tactic: rintro s ⟨hs, hso⟩
state_before: case refine'_1
X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ ∀ (i : Set (OnePoint X)), ∞ ∈ i ∧ IsOpen i → ∃ i', (IsClosed i' ∧ IsCompact i') ∧ some '' i'ᶜ ⊆ i ∩ {∞}ᶜ

tactic: refine' ⟨_, (isOpen_iff_of_mem hs).mp hso, _⟩
state_before: case refine'_1.intro
X : Type u_1
inst✝ : TopologicalSpace X
s✝ : Set (OnePoint X)
t : Set X
s : Set (OnePoint X)
hs : ∞ ∈ s
hso : IsOpen s
⊢ ∃ i', (IsClosed i' ∧ IsCompact i') ∧ some '' i'ᶜ ⊆ s ∩ {∞}ᶜ

tactic: simp [Subset.rfl]
state_before: case refine'_1.intro
X : Type u_1
inst✝ : TopologicalSpace X
s✝ : Set (OnePoint X)
t : Set X
s : Set (OnePoint X)
hs : ∞ ∈ s
hso : IsOpen s
⊢ some '' (some ⁻¹' s)ᶜᶜ ⊆ s ∩ {∞}ᶜ

tactic: rintro s ⟨h₁, h₂⟩
state_before: case refine'_2
X : Type u_1
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
⊢ ∀ (i' : Set X), IsClosed i' ∧ IsCompact i' → ∃ i, (∞ ∈ i ∧ IsOpen i) ∧ i ∩ {∞}ᶜ ⊆ some '' i'ᶜ

tactic: refine' ⟨_, ⟨mem_compl infty_not_mem_image_coe, isOpen_compl_image_coe.2 ⟨h₁, h₂⟩⟩, _⟩
state_before: case refine'_2.intro
X : Type u_1
inst✝ : TopologicalSpace X
s✝ : Set (OnePoint X)
t s : Set X
h₁ : IsClosed s
h₂ : IsCompact s
⊢ ∃ i, (∞ ∈ i ∧ IsOpen i) ∧ i ∩ {∞}ᶜ ⊆ some '' sᶜ

tactic: simp [compl_image_coe, ← diff_eq, subset_preimage_image]
state_before: case refine'_2.intro
X : Type u_1
inst✝ : TopologicalSpace X
s✝ : Set (OnePoint X)
t s : Set X
h₁ : IsClosed s
h₂ : IsCompact s
⊢ (some '' s)ᶜ ∩ {∞}ᶜ ⊆ some '' sᶜ
Theorem: PicardLindelof.FunSpace.dist_iterate_next_le
File: Mathlib/Analysis/ODE/PicardLindelof.lean

tactic: refine' dist_le_of_forall fun t => (dist_iterate_next_apply_le _ _ _ _).trans _
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 : ℕ
⊢ dist ((next^[n]) f₁) ((next^[n]) f₂) ≤ (↑v.L * tDist v) ^ n / ↑n ! * dist f₁ f₂

tactic: have : |(t - v.t₀ : ℝ)| ≤ v.tDist := v.dist_t₀_le 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)
⊢ (↑v.L * abs (↑t - ↑v.t₀)) ^ n / ↑n ! * dist f₁ f₂ ≤ (↑v.L * tDist v) ^ n / ↑n ! * dist f₁ f₂

tactic: gcongr
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)
this : abs (↑t - ↑v.t₀) ≤ tDist v
⊢ (↑v.L * abs (↑t - ↑v.t₀)) ^ n / ↑n ! * dist f₁ f₂ ≤ (↑v.L * tDist v) ^ n / ↑n ! * dist f₁ f₂
Theorem: charmatrix_apply_natDegree_le
File: Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean

tactic: split_ifs with h <;> simp [h, natDegree_X_sub_C_le]
state_before: R : Type u
inst✝³ : CommRing R
n G : Type v
inst✝² : DecidableEq n
inst✝¹ : Fintype n
α β : Type v
inst✝ : DecidableEq α
M : Matrix n n R
i j : n
⊢ natDegree (charmatrix M i j) ≤ if i = j then 1 else 0
Theorem: Nat.one_mem_divisors
File: Mathlib/NumberTheory/Divisors.lean

tactic: simp
state_before: n : ℕ
⊢ 1 ∈ divisors n ↔ n ≠ 0
Theorem: List.eq_cons_of_mem_head?
File: Mathlib/Data/List/Basic.lean

tactic: simp only [head?, Option.mem_def, Option.some_inj] at h
state_before: ι : Type ?u.41922
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x a : α
l : List α
h : x ∈ head? (a :: l)
⊢ a :: l = x :: tail (a :: l)

tactic: exact h ▸ rfl
state_before: ι : Type ?u.41922
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
x a : α
l : List α
h : a = x
⊢ a :: l = x :: tail (a :: l)
Theorem: WType.cardinal_mk_le_max_aleph0_of_finite
File: Mathlib/Data/W/Cardinal.lean

tactic: intro h
state_before: α : Type u
β : α → Type u
inst✝ : ∀ (a : α), Finite (β a)
⊢ IsEmpty α → (#WType β) ≤ max (#α) ℵ₀

tactic: rw [Cardinal.mk_eq_zero (WType β)]
state_before: α : Type u
β : α → Type u
inst✝ : ∀ (a : α), Finite (β a)
h : IsEmpty α
⊢ (#WType β) ≤ max (#α) ℵ₀

tactic: exact zero_le _
state_before: α : Type u
β : α → Type u
inst✝ : ∀ (a : α), Finite (β a)
h : IsEmpty α
⊢ 0 ≤ max (#α) ℵ₀

tactic: rw [succ_zero]
state_before: α : Type u
β : α → Type u
inst✝ : ∀ (a : α), Finite (β a)
hn : Nonempty α
m : Cardinal := max (#α) ℵ₀
⊢ Order.succ 0 ≤ ⨆ (a : α), m ^ (#β a)

tactic: obtain ⟨a⟩ : Nonempty α := hn
state_before: α : Type u
β : α → Type u
inst✝ : ∀ (a : α), Finite (β a)
hn : Nonempty α
m : Cardinal := max (#α) ℵ₀
⊢ 1 ≤ ⨆ (a : α), m ^ (#β a)

tactic: refine' le_trans _ (le_ciSup (bddAbove_range.{u, u} _) a)
state_before: case intro
α : Type u
β : α → Type u
inst✝ : ∀ (a : α), Finite (β a)
m : Cardinal := max (#α) ℵ₀
a : α
⊢ 1 ≤ ⨆ (a : α), m ^ (#β a)

tactic: rw [← power_zero]
state_before: case intro
α : Type u
β : α → Type u
inst✝ : ∀ (a : α), Finite (β a)
m : Cardinal := max (#α) ℵ₀
a : α
⊢ 1 ≤ m ^ (#β a)

tactic: exact
  power_le_power_left
    (pos_iff_ne_zero.1 (aleph0_pos.trans_le (le_max_right _ _))) (zero_le _)
state_before: case intro
α : Type u
β : α → Type u
inst✝ : ∀ (a : α), Finite (β a)
m : Cardinal := max (#α) ℵ₀
a : α
⊢ ?m.2512 ^ 0 ≤ m ^ (#β a)

α : Type u
β : α → Type u
inst✝ : ∀ (a : α), Finite (β a)
m : Cardinal := max (#α) ℵ₀
a : α
⊢ Cardinal
Theorem: Equiv.Perm.mem_cycleFactorsFinset_iff
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: obtain ⟨l, hl, hl'⟩ := f.cycleFactorsFinset.exists_list_nodup_eq
state_before: ι : Type ?u.2735472
α : Type u_1
β : Type ?u.2735478
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f p : Perm α
⊢ p ∈ cycleFactorsFinset f ↔ IsCycle p ∧ ∀ (a : α), a ∈ support p → ↑p a = ↑f a

tactic: rw [← hl']
state_before: case intro.intro
ι : Type ?u.2735472
α : Type u_1
β : Type ?u.2735478
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f p : Perm α
l : List (Perm α)
hl : List.Nodup l
hl' : List.toFinset l = cycleFactorsFinset f
⊢ p ∈ cycleFactorsFinset f ↔ IsCycle p ∧ ∀ (a : α), a ∈ support p → ↑p a = ↑f a

tactic: rw [eq_comm, cycleFactorsFinset_eq_list_toFinset hl] at hl'
state_before: case intro.intro
ι : Type ?u.2735472
α : Type u_1
β : Type ?u.2735478
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f p : Perm α
l : List (Perm α)
hl : List.Nodup l
hl' : List.toFinset l = cycleFactorsFinset f
⊢ p ∈ List.toFinset l ↔ IsCycle p ∧ ∀ (a : α), a ∈ support p → ↑p a = ↑f a

tactic: simpa [List.mem_toFinset, Ne.def, ← hl'.right.right] using
  mem_list_cycles_iff hl'.left hl'.right.left
state_before: case intro.intro
ι : Type ?u.2735472
α : Type u_1
β : Type ?u.2735478
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ f p : Perm α
l : List (Perm α)
hl : List.Nodup l
hl' : (∀ (f : Perm α), f ∈ l → IsCycle f) ∧ List.Pairwise Disjoint l ∧ List.prod l = f
⊢ p ∈ List.toFinset l ↔ IsCycle p ∧ ∀ (a : α), a ∈ support p → ↑p a = ↑f a
Theorem: Cardinal.add_eq_right
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: rw [add_comm, add_eq_left hb ha]
state_before: a b : Cardinal
hb : ℵ₀ ≤ b
ha : a ≤ b
⊢ a + b = b
Theorem: Sym2.congr_left
File: Mathlib/Data/Sym/Sym2.lean

tactic: constructor <;> intro h
state_before: α : Type u_1
β : Type ?u.4752
γ : Type ?u.4755
a b c : α
⊢ Quotient.mk (Rel.setoid α) (b, a) = Quotient.mk (Rel.setoid α) (c, a) ↔ b = c

tactic: rw [h]
state_before: case mpr
α : Type u_1
β : Type ?u.4752
γ : Type ?u.4755
a b c : α
h : b = c
⊢ Quotient.mk (Rel.setoid α) (b, a) = Quotient.mk (Rel.setoid α) (c, a)

tactic: rw [Quotient.eq] at h
state_before: case mp
α : Type u_1
β : Type ?u.4752
γ : Type ?u.4755
a b c : α
h : Quotient.mk (Rel.setoid α) (b, a) = Quotient.mk (Rel.setoid α) (c, a)
⊢ b = c

tactic: cases h <;> rfl
state_before: case mp
α : Type u_1
β : Type ?u.4752
γ : Type ?u.4755
a b c : α
h : (b, a) ≈ (c, a)
⊢ b = c
Theorem: RightDerivMeasurableAux.a_mono
File: Mathlib/Analysis/Calculus/FDerivMeasurable.lean

tactic: rintro x ⟨r', r'r, hr'⟩
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
L : F
r ε δ : ℝ
h : ε ≤ δ
⊢ A f L r ε ⊆ A f L r δ

tactic: refine' ⟨r', r'r, fun y hy z hz => (hr' y hy z hz).trans (mul_le_mul_of_nonneg_right h _)⟩
state_before: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
L : F
r ε δ : ℝ
h : ε ≤ δ
x r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ (y : ℝ), y ∈ Icc x (x + r') → ∀ (z : ℝ), z ∈ Icc x (x + r') → ‖f z - f y - (z - y) • L‖ ≤ ε * r
⊢ x ∈ A f L r δ

tactic: linarith [hy.1, hy.2, r'r.2]
state_before: case intro.intro
F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
L : F
r ε δ : ℝ
h : ε ≤ δ
x r' : ℝ
r'r : r' ∈ Ioc (r / 2) r
hr' : ∀ (y : ℝ), y ∈ Icc x (x + r') → ∀ (z : ℝ), z ∈ Icc x (x + r') → ‖f z - f y - (z - y) • L‖ ≤ ε * r
y : ℝ
hy : y ∈ Icc x (x + r')
z : ℝ
hz : z ∈ Icc x (x + r')
⊢ 0 ≤ r
Theorem: Matrix.Commute.mul_zpow
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: simp [h.mul_pow n, -mul_eq_mul]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A B : M
h : Commute A B
n : ℕ
⊢ (A * B) ^ ↑n = A ^ ↑n * B ^ ↑n

tactic: rw [zpow_negSucc, zpow_negSucc, zpow_negSucc, mul_eq_mul _⁻¹, ← mul_inv_rev, ← mul_eq_mul,
  h.mul_pow n.succ, (h.pow_pow _ _).eq]
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A B : M
h : Commute A B
n : ℕ
⊢ (A * B) ^ -[n+1] = A ^ -[n+1] * B ^ -[n+1]
Theorem: String.data_take
File: Std/Data/String/Lemmas.lean

tactic: rw [take_eq]
state_before: s : String
n : Nat
⊢ (take s n).data = List.take n s.data
Theorem: multiplicity.multiplicity_add_eq_min
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rcases lt_trichotomy (multiplicity p a) (multiplicity p b) with (hab | hab | hab)
state_before: α : Type u_1
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p a ≠ multiplicity p b
⊢ multiplicity p (a + b) = min (multiplicity p a) (multiplicity p b)

tactic: rw [add_comm, multiplicity_add_of_gt hab, min_eq_left]
state_before: case inl
α : Type u_1
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p a ≠ multiplicity p b
hab : multiplicity p a < multiplicity p b
⊢ multiplicity p (a + b) = min (multiplicity p a) (multiplicity p b)

tactic: exact le_of_lt hab
state_before: case inl
α : Type u_1
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p a ≠ multiplicity p b
hab : multiplicity p a < multiplicity p b
⊢ multiplicity p a ≤ multiplicity p b

tactic: contradiction
state_before: case inr.inl
α : Type u_1
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p a ≠ multiplicity p b
hab : multiplicity p a = multiplicity p b
⊢ multiplicity p (a + b) = min (multiplicity p a) (multiplicity p b)

tactic: rw [multiplicity_add_of_gt hab, min_eq_right]
state_before: case inr.inr
α : Type u_1
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p a ≠ multiplicity p b
hab : multiplicity p b < multiplicity p a
⊢ multiplicity p (a + b) = min (multiplicity p a) (multiplicity p b)

tactic: exact le_of_lt hab
state_before: case inr.inr
α : Type u_1
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p a ≠ multiplicity p b
hab : multiplicity p b < multiplicity p a
⊢ multiplicity p b ≤ multiplicity p a
Theorem: extChartAt_preimage_mem_nhdsWithin'
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: rwa [← map_extChartAt_symm_nhdsWithin' I x h, mem_map] at ht
state_before: 𝕜 : Type u_3
E : Type u_2
M : Type u_1
H : Type u_4
E' : Type ?u.219932
M' : Type ?u.219935
H' : Type ?u.219938
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedSpace 𝕜 E
inst✝⁷ : TopologicalSpace H
inst✝⁶ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝⁵ : NormedAddCommGroup E'
inst✝⁴ : NormedSpace 𝕜 E'
inst✝³ : TopologicalSpace H'
inst✝² : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
inst✝¹ : ChartedSpace H M
inst✝ : ChartedSpace H' M'
x' : M
h : x' ∈ (extChartAt I x).source
ht : t ∈ 𝓝[s] x'
⊢ ↑(LocalEquiv.symm (extChartAt I x)) ⁻¹' t ∈
    𝓝[↑(LocalEquiv.symm (extChartAt I x)) ⁻¹' s ∩ range ↑I] ↑(extChartAt I x) x'
Theorem: MeasureTheory.Measure.restrict_congr_meas
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [← inter_eq_self_of_subset_left hts, ← restrict_apply ht, H, restrict_apply ht]
state_before: α : Type u_1
β : Type ?u.307127
γ : Type ?u.307130
δ : Type ?u.307133
ι : Type ?u.307136
R : Type ?u.307139
R' : Type ?u.307142
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
hs : MeasurableSet s
H : restrict μ s = restrict ν s
t : Set α
hts : t ⊆ s
ht : MeasurableSet t
⊢ ↑↑μ t = ↑↑ν t

tactic: rw [restrict_apply ht, restrict_apply ht, H _ (inter_subset_right _ _) (ht.inter hs)]
state_before: α : Type u_1
β : Type ?u.307127
γ : Type ?u.307130
δ : Type ?u.307133
ι : Type ?u.307136
R : Type ?u.307139
R' : Type ?u.307142
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t✝ : Set α
hs : MeasurableSet s
H : ∀ (t : Set α), t ⊆ s → MeasurableSet t → ↑↑μ t = ↑↑ν t
t : Set α
ht : MeasurableSet t
⊢ ↑↑(restrict μ s) t = ↑↑(restrict ν s) t
Theorem: EuclideanDomain.mul_right_not_lt
File: Mathlib/Algebra/EuclideanDomain/Defs.lean

tactic: rw [mul_comm]
state_before: R : Type u
inst✝ : EuclideanDomain R
a b : R
h : a ≠ 0
⊢ ¬a * b ≺ b

tactic: exact mul_left_not_lt b h
state_before: R : Type u
inst✝ : EuclideanDomain R
a b : R
h : a ≠ 0
⊢ ¬b * a ≺ b
Theorem: Polynomial.leadingCoeff_ne_zero
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [Ne.def, leadingCoeff_eq_zero]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.514573
⊢ leadingCoeff p ≠ 0 ↔ p ≠ 0
Theorem: Polynomial.leadingCoeff_linear
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rw [add_comm, leadingCoeff_add_of_degree_lt (degree_C_lt_degree_C_mul_X ha),
  leadingCoeff_C_mul_X]
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p q : R[X]
ι : Type ?u.910503
ha : a ≠ 0
⊢ leadingCoeff (↑C a * X + ↑C b) = a