tasksource/leandojo huggingface dataset:
Theorem: IsGroupHom.inv_iff_ker
File: Mathlib/Deprecated/Subgroup.lean

tactic: rw [mem_ker]
state_before: G : Type u_1
H : Type u_2
A : Type ?u.83924
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
⊢ f a = f b ↔ a * b⁻¹ ∈ ker f

tactic: exact one_iff_ker_inv hf _ _
state_before: G : Type u_1
H : Type u_2
A : Type ?u.83924
a✝ a₁ a₂ b✝ c : G
inst✝¹ : Group G
inst✝ : Group H
f : G → H
hf : IsGroupHom f
a b : G
⊢ f a = f b ↔ f (a * b⁻¹) = 1
Theorem: ball_pi'
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: simp [ball_eq_empty.2 hr]
state_before: α : Type u
β : Type v
X : Type ?u.401932
ι : Type ?u.401935
inst✝³ : PseudoMetricSpace α
π : β → Type u_1
inst✝² : Fintype β
inst✝¹ : (b : β) → PseudoMetricSpace (π b)
inst✝ : Nonempty β
x : (b : β) → π b
r : ℝ
hr : r ≤ 0
⊢ ball x r = Set.pi Set.univ fun b => ball (x b) r
Theorem: Ioc_mem_nhdsWithin_Iic
File: Mathlib/Topology/Order/Basic.lean

tactic: simpa only [dual_Ico] using
  Ico_mem_nhdsWithin_Ici (show toDual b ∈ Ico (toDual c) (toDual a) from H.symm)
state_before: α : Type u
β : Type v
γ : Type w
inst✝³ : TopologicalSpace α
inst✝² : LinearOrder α
inst✝¹ : OrderClosedTopology α
a✝ b✝ : α
inst✝ : TopologicalSpace γ
a b c : α
H : b ∈ Ioc a c
⊢ Ioc a c ∈ 𝓝[Iic b] b
Theorem: of_quotient_center_nilpotent
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: obtain ⟨n, hn⟩ := h.nilpotent
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
h : Group.IsNilpotent (G ⧸ center G)
⊢ Group.IsNilpotent G

tactic: use n.succ
state_before: case intro
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
h : Group.IsNilpotent (G ⧸ center G)
n : ℕ
hn : upperCentralSeries (G ⧸ center G) n = ⊤
⊢ Group.IsNilpotent G

tactic: simp [← comap_upperCentralSeries_quotient_center, hn]
state_before: case intro
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
h : Group.IsNilpotent (G ⧸ center G)
n : ℕ
hn : upperCentralSeries (G ⧸ center G) n = ⊤
⊢ upperCentralSeries G (Nat.succ n) = ⊤
Theorem: Nat.mul_dvd_of_dvd_div
File: Mathlib/Data/Nat/Basic.lean

tactic: rwa [mul_comm, ←mul_assoc] at h3
state_before: m n k a b c : ℕ
hab : c ∣ b
h : a ∣ b / c
h1 : ∃ d, b / c = a * d
d : ℕ
hd : b / c = a * d
h3 : b = a * d * c
⊢ b = c * a * d
Theorem: CharTwo.bit0_apply_eq_zero
File: Mathlib/Algebra/CharP/Two.lean

tactic: simp
state_before: R : Type u_1
ι : Type ?u.2610
inst✝¹ : Semiring R
inst✝ : CharP R 2
x : R
⊢ bit0 x = 0
Theorem: ENNReal.toReal_min
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [h, (ENNReal.toReal_le_toReal hr hp).2 h, min_eq_left]
state_before: α : Type ?u.801740
β : Type ?u.801743
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
hr : a ≠ ⊤
hp : b ≠ ⊤
h : a ≤ b
⊢ ENNReal.toReal (min a b) = min (ENNReal.toReal a) (ENNReal.toReal b)

tactic: simp only [h, (ENNReal.toReal_le_toReal hp hr).2 h, min_eq_right]
state_before: α : Type ?u.801740
β : Type ?u.801743
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
hr : a ≠ ⊤
hp : b ≠ ⊤
h : b ≤ a
⊢ ENNReal.toReal (min a b) = min (ENNReal.toReal a) (ENNReal.toReal b)
Theorem: Filter.map_div_atTop_eq_nat
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp only [← Nat.lt_succ_iff, Nat.div_lt_iff_lt_mul hk, Nat.succ_eq_add_one,
add_assoc, tsub_add_cancel_of_le (Nat.one_le_iff_ne_zero.2 hk.ne'), add_mul, one_mul]
state_before: ι : Type ?u.345892
ι' : Type ?u.345895
α : Type ?u.345898
β : Type ?u.345901
γ : Type ?u.345904
k : ℕ
hk : 0 < k
a b : ℕ
x✝ : b ≥ 1
⊢ a / k ≤ b ↔ a ≤ (fun b => b * k + (k - 1)) b

tactic: rw [Nat.mul_div_cancel b hk]
state_before: ι : Type ?u.345892
ι' : Type ?u.345895
α : Type ?u.345898
β : Type ?u.345901
γ : Type ?u.345904
k : ℕ
hk : 0 < k
b : ℕ
x✝ : b ≥ 1
⊢ b = b * k / k
Theorem: cmpUsing_eq_lt
File: Mathlib/Init/Data/Ordering/Lemmas.lean

tactic: simp
state_before: α : Type u
lt : α → α → Prop
inst✝ : DecidableRel lt
a b : α
⊢ (cmpUsing lt a b = Ordering.lt) = lt a b
Theorem: Equiv.Perm.IsCycleOn.extendDomain
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

tactic: rintro _ ⟨a, ha, rfl⟩ _ ⟨b, hb, rfl⟩
state_before: ι : Type ?u.2071598
α : Type u_2
β : Type u_1
f✝ g : Perm α
s t : Set α
a b x y : α
p : β → Prop
inst✝ : DecidablePred p
f : α ≃ Subtype p
h : IsCycleOn g s
⊢ ∀ ⦃x : β⦄, x ∈ Subtype.val ∘ ↑f '' s → ∀ ⦃y : β⦄, y ∈ Subtype.val ∘ ↑f '' s → SameCycle (Perm.extendDomain g f) x y

tactic: exact (h.2 ha hb).extendDomain
state_before: case intro.intro.intro.intro
ι : Type ?u.2071598
α : Type u_2
β : Type u_1
f✝ g : Perm α
s t : Set α
a✝ b✝ x y : α
p : β → Prop
inst✝ : DecidablePred p
f : α ≃ Subtype p
h : IsCycleOn g s
a : α
ha : a ∈ s
b : α
hb : b ∈ s
⊢ SameCycle (Perm.extendDomain g f) ((Subtype.val ∘ ↑f) a) ((Subtype.val ∘ ↑f) b)
Theorem: CategoryTheory.Limits.map_π_preserves_coequalizer_inv
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Equalizers.lean

tactic: rw [← ι_comp_coequalizerComparison_assoc, ← PreservesCoequalizer.iso_hom, Iso.hom_inv_id,
  comp_id]
state_before: C : Type u₁
inst✝⁴ : Category C
D : Type u₂
inst✝³ : Category D
G : C ⥤ D
X Y Z : C
f g : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = g ≫ h
inst✝² : HasCoequalizer f g
inst✝¹ : HasCoequalizer (G.map f) (G.map g)
inst✝ : PreservesColimit (parallelPair f g) G
⊢ G.map (coequalizer.π f g) ≫ (PreservesCoequalizer.iso G f g).inv = coequalizer.π (G.map f) (G.map g)
Theorem: card_derangements_eq_numDerangements
File: Mathlib/Combinatorics/Derangements/Finite.lean

tactic: rw [← card_derangements_invariant (card_fin _)]
state_before: α✝ : Type ?u.21453
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
⊢ card ↑(derangements α) = numDerangements (card α)

tactic: exact card_derangements_fin_eq_numDerangements
state_before: α✝ : Type ?u.21453
inst✝³ : DecidableEq α✝
inst✝² : Fintype α✝
α : Type u_1
inst✝¹ : Fintype α
inst✝ : DecidableEq α
⊢ card ↑(derangements (Fin (card α))) = numDerangements (card α)
Theorem: Rat.normalize_mul_right
File: Std/Data/Rat/Lemmas.lean

tactic: rw [← normalize_mul_left (d0 := d0) a0]
state_before: d : Nat
n : Int
a : Nat
d0 : d ≠ 0
a0 : a ≠ 0
⊢ normalize (n * ↑a) (d * a) = normalize n d

tactic: congr 1 <;> [apply Int.mul_comm; apply Nat.mul_comm]
state_before: d : Nat
n : Int
a : Nat
d0 : d ≠ 0
a0 : a ≠ 0
⊢ normalize (n * ↑a) (d * a) = normalize (↑a * n) (a * d)
Theorem: List.Perm.union_left
File: Mathlib/Data/List/Perm.lean

tactic: induction l <;> simp [*, Perm.insert]
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
inst✝ : DecidableEq α
l t₁ t₂ : List α
h : t₁ ~ t₂
⊢ List.union l t₁ ~ List.union l t₂
Theorem: Nat.gcdB_zero_left
File: Mathlib/Data/Int/GCD.lean

tactic: unfold gcdB
state_before: s : ℕ
⊢ gcdB 0 s = 1

tactic: rw [xgcd, xgcd_zero_left]
state_before: s : ℕ
⊢ (xgcd 0 s).snd = 1
Theorem: sSup_inv
File: Mathlib/Algebra/Order/Pointwise.lean

tactic: rw [← image_inv, sSup_image]
state_before: α : Type u_1
inst✝³ : CompleteLattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
s✝ t s : Set α
⊢ sSup s⁻¹ = (sInf s)⁻¹

tactic: exact ((OrderIso.inv α).map_sInf _).symm
state_before: α : Type u_1
inst✝³ : CompleteLattice α
inst✝² : Group α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
s✝ t s : Set α
⊢ (⨆ (a : α) (_ : a ∈ s), a⁻¹) = (sInf s)⁻¹
Theorem: Set.WellFoundedOn.union
File: Mathlib/Order/WellFoundedSet.lean

tactic: rw [wellFoundedOn_iff_no_descending_seq] at *
state_before: ι : Type ?u.29184
α : Type u_1
β : Type ?u.29190
r r' : α → α → Prop
inst✝ : IsStrictOrder α r
s t : Set α
hs : WellFoundedOn s r
ht : WellFoundedOn t r
⊢ WellFoundedOn (s ∪ t) r

tactic: rintro f hf
state_before: ι : Type ?u.29184
α : Type u_1
β : Type ?u.29190
r r' : α → α → Prop
inst✝ : IsStrictOrder α r
s t : Set α
hs : ∀ (f : (fun x x_1 => x > x_1) ↪r r), ¬∀ (n : ℕ), ↑f n ∈ s
ht : ∀ (f : (fun x x_1 => x > x_1) ↪r r), ¬∀ (n : ℕ), ↑f n ∈ t
⊢ ∀ (f : (fun x x_1 => x > x_1) ↪r r), ¬∀ (n : ℕ), ↑f n ∈ s ∪ t

tactic: rcases Nat.exists_subseq_of_forall_mem_union f hf with ⟨g, hg | hg⟩
state_before: ι : Type ?u.29184
α : Type u_1
β : Type ?u.29190
r r' : α → α → Prop
inst✝ : IsStrictOrder α r
s t : Set α
hs : ∀ (f : (fun x x_1 => x > x_1) ↪r r), ¬∀ (n : ℕ), ↑f n ∈ s
ht : ∀ (f : (fun x x_1 => x > x_1) ↪r r), ¬∀ (n : ℕ), ↑f n ∈ t
f : (fun x x_1 => x > x_1) ↪r r
hf : ∀ (n : ℕ), ↑f n ∈ s ∪ t
⊢ False

tactic: exacts [hs (g.dual.ltEmbedding.trans f) hg, ht (g.dual.ltEmbedding.trans f) hg]
state_before: case intro.inl
ι : Type ?u.29184
α : Type u_1
β : Type ?u.29190
r r' : α → α → Prop
inst✝ : IsStrictOrder α r
s t : Set α
hs : ∀ (f : (fun x x_1 => x > x_1) ↪r r), ¬∀ (n : ℕ), ↑f n ∈ s
ht : ∀ (f : (fun x x_1 => x > x_1) ↪r r), ¬∀ (n : ℕ), ↑f n ∈ t
f : (fun x x_1 => x > x_1) ↪r r
hf : ∀ (n : ℕ), ↑f n ∈ s ∪ t
g : ℕ ↪o ℕ
hg : ∀ (n : ℕ), ↑f (↑g n) ∈ s
⊢ False

case intro.inr
ι : Type ?u.29184
α : Type u_1
β : Type ?u.29190
r r' : α → α → Prop
inst✝ : IsStrictOrder α r
s t : Set α
hs : ∀ (f : (fun x x_1 => x > x_1) ↪r r), ¬∀ (n : ℕ), ↑f n ∈ s
ht : ∀ (f : (fun x x_1 => x > x_1) ↪r r), ¬∀ (n : ℕ), ↑f n ∈ t
f : (fun x x_1 => x > x_1) ↪r r
hf : ∀ (n : ℕ), ↑f n ∈ s ∪ t
g : ℕ ↪o ℕ
hg : ∀ (n : ℕ), ↑f (↑g n) ∈ t
⊢ False
Theorem: Cardinal.beth_one
File: Mathlib/SetTheory/Cardinal/Continuum.lean

tactic: simpa using beth_succ 0
state_before: ⊢ beth 1 = 𝔠
Theorem: List.get_indexOf
File: Mathlib/Data/List/Nodup.lean

tactic: simp
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
inst✝ : DecidableEq α
l : List α
H : Nodup l
i : Fin (length l)
⊢ get l { val := indexOf (get l i) l, isLt := (_ : indexOf (get l i) l < length l) } = get l i
Theorem: Set.indicator_mul
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: funext
state_before: α : Type u_1
β : Type ?u.118109
ι : Type ?u.118112
M : Type u_2
N : Type ?u.118118
inst✝ : MulZeroClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
⊢ (indicator s fun a => f a * g a) = fun a => indicator s f a * indicator s g a

tactic: simp only [indicator]
state_before: case h
α : Type u_1
β : Type ?u.118109
ι : Type ?u.118112
M : Type u_2
N : Type ?u.118118
inst✝ : MulZeroClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
⊢ indicator s (fun a => f a * g a) x✝ = indicator s f x✝ * indicator s g x✝

tactic: split_ifs
state_before: case h
α : Type u_1
β : Type ?u.118109
ι : Type ?u.118112
M : Type u_2
N : Type ?u.118118
inst✝ : MulZeroClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
⊢ (if x✝ ∈ s then f x✝ * g x✝ else 0) = (if x✝ ∈ s then f x✝ else 0) * if x✝ ∈ s then g x✝ else 0

tactic: rw [mul_zero]
state_before: case h.inr
α : Type u_1
β : Type ?u.118109
ι : Type ?u.118112
M : Type u_2
N : Type ?u.118118
inst✝ : MulZeroClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
h✝ : ¬x✝ ∈ s
⊢ 0 = 0 * 0

tactic: rfl
state_before: case h.inl
α : Type u_1
β : Type ?u.118109
ι : Type ?u.118112
M : Type u_2
N : Type ?u.118118
inst✝ : MulZeroClass M
s✝ t : Set α
f✝ g✝ : α → M
a : α
s : Set α
f g : α → M
x✝ : α
h✝ : x✝ ∈ s
⊢ f x✝ * g x✝ = f x✝ * g x✝
Theorem: CategoryTheory.factorThruImage_comp_imageUnopOp_inv
File: Mathlib/CategoryTheory/Abelian/Opposite.lean

tactic: rw [Iso.comp_inv_eq, image_ι_op_comp_imageUnopOp_hom]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ factorThruImage g ≫ (imageUnopOp g).inv = (image.ι g.unop).op
Theorem: Inducing.closure_eq_preimage_closure_image
File: Mathlib/Topology/Maps.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.5388
δ : Type ?u.5391
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : Inducing f
s : Set α
⊢ closure s = f ⁻¹' closure (f '' s)

tactic: rw [Set.mem_preimage, ← closure_induced, hf.induced]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.5388
δ : Type ?u.5391
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : Inducing f
s : Set α
x : α
⊢ x ∈ closure s ↔ x ∈ f ⁻¹' closure (f '' s)
Theorem: AddCircle.liftIoc_coe_apply
File: Mathlib/Topology/Instances/AddCircle.lean

tactic: have : (equivIoc p a) x = ⟨x, hx⟩ := by
  rw [Equiv.apply_eq_iff_eq_symm_apply]
  rfl
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
f : 𝕜 → B
x : 𝕜
hx : x ∈ Ioc a (a + p)
⊢ liftIoc p a f ↑x = f x

tactic: rw [liftIoc, comp_apply, this]
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
f : 𝕜 → B
x : 𝕜
hx : x ∈ Ioc a (a + p)
this : ↑(equivIoc p a) ↑x = { val := x, property := hx }
⊢ liftIoc p a f ↑x = f x

tactic: rfl
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
f : 𝕜 → B
x : 𝕜
hx : x ∈ Ioc a (a + p)
this : ↑(equivIoc p a) ↑x = { val := x, property := hx }
⊢ restrict (Ioc a (a + p)) f { val := x, property := hx } = f x

tactic: rw [Equiv.apply_eq_iff_eq_symm_apply]
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
f : 𝕜 → B
x : 𝕜
hx : x ∈ Ioc a (a + p)
⊢ ↑(equivIoc p a) ↑x = { val := x, property := hx }

tactic: rfl
state_before: 𝕜 : Type u_1
B : Type u_2
inst✝³ : LinearOrderedAddCommGroup 𝕜
inst✝² : TopologicalSpace 𝕜
inst✝¹ : OrderTopology 𝕜
p : 𝕜
hp : Fact (0 < p)
a : 𝕜
inst✝ : Archimedean 𝕜
f : 𝕜 → B
x : 𝕜
hx : x ∈ Ioc a (a + p)
⊢ ↑x = ↑(equivIoc p a).symm { val := x, property := hx }
Theorem: Fin.cycleRange_zero
File: Mathlib/GroupTheory/Perm/Fin.lean

tactic: ext j
state_before: n : ℕ
⊢ cycleRange 0 = 1

tactic: refine' Fin.cases _ (fun j => _) j
state_before: case H.h
n : ℕ
j : Fin (Nat.succ n)
⊢ ↑(↑(cycleRange 0) j) = ↑(↑1 j)

tactic: simp
state_before: case H.h.refine'_1
n : ℕ
j : Fin (Nat.succ n)
⊢ ↑(↑(cycleRange 0) 0) = ↑(↑1 0)

tactic: rw [cycleRange_of_gt (Fin.succ_pos j), one_apply]
state_before: case H.h.refine'_2
n : ℕ
j✝ : Fin (Nat.succ n)
j : Fin n
⊢ ↑(↑(cycleRange 0) (succ j)) = ↑(↑1 (succ j))
Theorem: Complex.sin_sq
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← sin_sq_add_cos_sq x, add_sub_cancel]
state_before: x y : ℂ
⊢ sin x ^ 2 = 1 - cos x ^ 2
Theorem: Real.isBigO_exp_comp_one
File: Mathlib/Analysis/SpecialFunctions/Exp.lean

tactic: simp only [isBigO_one_iff, norm_eq_abs, abs_exp, isBoundedUnder_le_exp_comp]
state_before: α : Type u_1
x y z : ℝ
l : Filter α
f : α → ℝ
⊢ ((fun x => exp (f x)) =O[l] fun x => 1) ↔ IsBoundedUnder (fun x x_1 => x ≤ x_1) l f
Theorem: Filter.tendsto_lift'
File: Mathlib/Order/Filter/Lift.lean

tactic: simp only [Filter.lift', tendsto_lift, tendsto_principal, comp]
state_before: α : Type u_3
β : Type u_2
γ : Type u_1
ι : Sort ?u.28305
f f₁ f₂ : Filter α
h h₁ h₂ : Set α → Set β
m : γ → β
l : Filter γ
⊢ Tendsto m l (Filter.lift' f h) ↔ ∀ (s : Set α), s ∈ f → ∀ᶠ (a : γ) in l, m a ∈ h s
Theorem: Polynomial.rootSet_C_mul_X_pow
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: rw [C_mul_X_pow_eq_monomial, rootSet_monomial hn ha]
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n✝ : ℕ
inst✝³ : Field R
p q : R[X]
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra R S
n : ℕ
hn : n ≠ 0
a : R
ha : a ≠ 0
⊢ rootSet (↑C a * X ^ n) S = {0}
Theorem: Ultrafilter.comap_pure
File: Mathlib/Order/Filter/Ultrafilter.lean

tactic: rw [coe_pure, ← principal_singleton, ← image_singleton, preimage_image_eq _ inj]
state_before: α : Type u
β : Type v
γ : Type ?u.20593
f g : Ultrafilter α
s t : Set α
p q : α → Prop
m : α → β
a : α
inj : Injective m
large : range m ∈ pure (m a)
⊢ 𝓟 (m ⁻¹' {m a}) = ↑(pure a)
Theorem: MeasureTheory.tendsto_lintegral_thickenedIndicator_of_isClosed
File: Mathlib/MeasureTheory/Measure/Portmanteau.lean

tactic: apply measure_of_cont_bdd_of_tendsto_indicator μ F_closed.measurableSet
  (fun n => thickenedIndicator (δs_pos n) F) fun n ω => thickenedIndicator_le_one (δs_pos n) F ω
state_before: Ω✝ : Type ?u.24613
inst✝⁴ : MeasurableSpace Ω✝
Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : PseudoEMetricSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
F : Set Ω
F_closed : IsClosed F
δs : ℕ → ℝ
δs_pos : ∀ (n : ℕ), 0 < δs n
δs_lim : Tendsto δs atTop (𝓝 0)
⊢ Tendsto (fun n => ∫⁻ (ω : Ω), ↑(↑(thickenedIndicator (_ : 0 < δs n) F) ω) ∂μ) atTop (𝓝 (↑↑μ F))

tactic: have key := thickenedIndicator_tendsto_indicator_closure δs_pos δs_lim F
state_before: Ω✝ : Type ?u.24613
inst✝⁴ : MeasurableSpace Ω✝
Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : PseudoEMetricSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
F : Set Ω
F_closed : IsClosed F
δs : ℕ → ℝ
δs_pos : ∀ (n : ℕ), 0 < δs n
δs_lim : Tendsto δs atTop (𝓝 0)
⊢ Tendsto (fun n => ↑(thickenedIndicator (_ : 0 < δs n) F)) atTop (𝓝 (indicator F fun x => 1))

tactic: rwa [F_closed.closure_eq] at key
state_before: Ω✝ : Type ?u.24613
inst✝⁴ : MeasurableSpace Ω✝
Ω : Type u_1
inst✝³ : MeasurableSpace Ω
inst✝² : PseudoEMetricSpace Ω
inst✝¹ : OpensMeasurableSpace Ω
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
F : Set Ω
F_closed : IsClosed F
δs : ℕ → ℝ
δs_pos : ∀ (n : ℕ), 0 < δs n
δs_lim : Tendsto δs atTop (𝓝 0)
key : Tendsto (fun n => ↑(thickenedIndicator (_ : 0 < δs n) F)) atTop (𝓝 (indicator (closure F) fun x => 1))
⊢ Tendsto (fun n => ↑(thickenedIndicator (_ : 0 < δs n) F)) atTop (𝓝 (indicator F fun x => 1))
Theorem: Set.ite_inter_compl_self
File: Mathlib/Data/Set/Basic.lean

tactic: rw [← ite_compl, ite_inter_self]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u t s s' : Set α
⊢ Set.ite t s s' ∩ tᶜ = s' ∩ tᶜ
Theorem: CategoryTheory.Limits.IsColimit.coconePointUniqueUpToIso_inv_desc
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category J
K : Type u₂
inst✝¹ : Category K
C : Type u₃
inst✝ : Category C
F : J ⥤ C
r s t : Cocone F
P : IsColimit s
Q : IsColimit t
⊢ ∀ (j : J), t.ι.app j ≫ (coconePointUniqueUpToIso P Q).inv ≫ desc P r = r.ι.app j
Theorem: Quiver.Path.cast_heq
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: rw [Path.cast_eq_cast]
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
p : Path u v
⊢ HEq (cast hu hv p) p

tactic: exact _root_.cast_heq _ _
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
p : Path u v
⊢ HEq (_root_.cast (_ : Path u v = Path u' v') p) p
Theorem: Memℓp.all
File: Mathlib/Analysis/NormedSpace/LpEquiv.lean

tactic: rcases p.trichotomy with (rfl | rfl | _h)
state_before: α : Type u_1
E : α → Type u_2
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
p : ℝ≥0∞
inst✝ : Finite α
f : (i : α) → E i
⊢ Memℓp f p

tactic: exact memℓp_zero_iff.mpr { i : α | f i ≠ 0 }.toFinite
state_before: case inl
α : Type u_1
E : α → Type u_2
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Finite α
f : (i : α) → E i
⊢ Memℓp f 0

tactic: exact memℓp_infty_iff.mpr (Set.Finite.bddAbove (Set.range fun i : α => ‖f i‖).toFinite)
state_before: case inr.inl
α : Type u_1
E : α → Type u_2
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Finite α
f : (i : α) → E i
⊢ Memℓp f ⊤

tactic: cases nonempty_fintype α
state_before: case inr.inr
α : Type u_1
E : α → Type u_2
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
p : ℝ≥0∞
inst✝ : Finite α
f : (i : α) → E i
_h : 0 < ENNReal.toReal p
⊢ Memℓp f p

tactic: exact memℓp_gen ⟨Finset.univ.sum _, hasSum_fintype _⟩
state_before: case inr.inr.intro
α : Type u_1
E : α → Type u_2
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
p : ℝ≥0∞
inst✝ : Finite α
f : (i : α) → E i
_h : 0 < ENNReal.toReal p
val✝ : Fintype α
⊢ Memℓp f p
Theorem: Rat.ceil_cast
File: Mathlib/Data/Rat/Floor.lean

tactic: rw [← neg_inj, ← floor_neg, ← floor_neg, ← Rat.cast_neg, Rat.floor_cast]
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : FloorRing α
x : ℚ
⊢ ⌈↑x⌉ = ⌈x⌉
Theorem: Cardinal.continuum_lt_lift
File: Mathlib/SetTheory/Cardinal/Continuum.lean

tactic: rw [← lift_continuum.{u,v}, lift_lt]
state_before: c : Cardinal
⊢ 𝔠 < lift c ↔ 𝔠 < c
Theorem: same_add_div
File: Mathlib/Algebra/Field/Basic.lean

tactic: rw [← div_self h, add_div]
state_before: α : Type u_1
β : Type ?u.1565
K : Type ?u.1568
inst✝ : DivisionSemiring α
a b c d : α
h : b ≠ 0
⊢ (b + a) / b = 1 + a / b
Theorem: finprod_eq_finset_prod_of_mulSupport_subset
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: simpa [← Finset.coe_subset, Set.coe_toFinset]
state_before: α : Type u_1
β : Type ?u.180289
ι : Type ?u.180292
G : Type ?u.180295
M : Type u_2
N : Type ?u.180301
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s : Finset α
h : mulSupport f ⊆ ↑s
⊢ Finite.toFinset (_ : Set.Finite (mulSupport f)) ⊆ s
Theorem: IsROrC.normSq_pos
File: Mathlib/Data/IsROrC/Basic.lean

tactic: rw [lt_iff_le_and_ne, Ne, eq_comm]
state_before: K : Type u_1
E : Type ?u.4450828
inst✝ : IsROrC K
z : K
⊢ 0 < ↑normSq z ↔ z ≠ 0

tactic: simp [normSq_nonneg]
state_before: K : Type u_1
E : Type ?u.4450828
inst✝ : IsROrC K
z : K
⊢ 0 ≤ ↑normSq z ∧ ¬↑normSq z = 0 ↔ z ≠ 0
Theorem: Metric.uniformEmbedding_iff'
File: Mathlib/Topology/MetricSpace/Basic.lean

tactic: rw [uniformEmbedding_iff_uniformInducing, uniformInducing_iff, uniformContinuous_iff]
state_before: α : Type u
β : Type v
X : Type ?u.553589
ι : Type ?u.553592
inst✝² : PseudoMetricSpace α
γ : Type w
inst✝¹ : MetricSpace γ
x : γ
s : Set γ
inst✝ : MetricSpace β
f : γ → β
⊢ UniformEmbedding f ↔
    (∀ (ε : ℝ), ε > 0 → ∃ δ, δ > 0 ∧ ∀ {a b : γ}, dist a b < δ → dist (f a) (f b) < ε) ∧
      ∀ (δ : ℝ), δ > 0 → ∃ ε, ε > 0 ∧ ∀ {a b : γ}, dist (f a) (f b) < ε → dist a b < δ
Theorem: FintypeCat.Skeleton.incl_mk_nat_card
File: Mathlib/CategoryTheory/FintypeCat.lean

tactic: convert Finset.card_fin n
state_before: n : ℕ
⊢ Fintype.card ↑(incl.obj (mk n)) = n

tactic: apply Fintype.ofEquiv_card
state_before: case h.e'_2
n : ℕ
⊢ Fintype.card ↑(incl.obj (mk n)) = Finset.card Finset.univ
Theorem: Mathlib.Tactic.Ring.cast_pos
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp [e]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
n : ℕ
e : a = ↑n
⊢ a = Nat.rawCast n + 0
Theorem: AffineSubspace.mem_direction_iff_eq_vsub_left
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [← SetLike.mem_coe, coe_direction_eq_vsub_set_left hp]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hp : p ∈ s
v : V
⊢ v ∈ direction s ↔ ∃ p2, p2 ∈ s ∧ v = p -ᵥ p2

tactic: exact ⟨fun ⟨p2, hp2, hv⟩ => ⟨p2, hp2, hv.symm⟩, fun ⟨p2, hp2, hv⟩ => ⟨p2, hp2, hv.symm⟩⟩
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
s : AffineSubspace k P
p : P
hp : p ∈ s
v : V
⊢ v ∈ (fun x x_1 => x -ᵥ x_1) p '' ↑s ↔ ∃ p2, p2 ∈ s ∧ v = p -ᵥ p2