tasksource/leandojo huggingface dataset:
Theorem: NNReal.tendsto_rpow_atTop
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

tactic: rw [Filter.tendsto_atTop_atTop]
state_before: y : ℝ
hy : 0 < y
⊢ Tendsto (fun x => ↑x ^ y) atTop atTop

tactic: intro b
state_before: y : ℝ
hy : 0 < y
⊢ ∀ (b : ℝ), ∃ i, ∀ (a : ℝ≥0), i ≤ a → b ≤ ↑a ^ y

tactic: obtain ⟨c, hc⟩ := tendsto_atTop_atTop.mp (tendsto_rpow_atTop hy) b
state_before: y : ℝ
hy : 0 < y
b : ℝ
⊢ ∃ i, ∀ (a : ℝ≥0), i ≤ a → b ≤ ↑a ^ y

tactic: use c.toNNReal
state_before: case intro
y : ℝ
hy : 0 < y
b c : ℝ
hc : ∀ (a : ℝ), c ≤ a → b ≤ a ^ y
⊢ ∃ i, ∀ (a : ℝ≥0), i ≤ a → b ≤ ↑a ^ y

tactic: intro a ha
state_before: case intro
y : ℝ
hy : 0 < y
b c : ℝ
hc : ∀ (a : ℝ), c ≤ a → b ≤ a ^ y
⊢ ∀ (a : ℝ≥0), toNNReal c ≤ a → b ≤ ↑a ^ y

tactic: exact_mod_cast hc a (Real.toNNReal_le_iff_le_coe.mp ha)
state_before: case intro
y : ℝ
hy : 0 < y
b c : ℝ
hc : ∀ (a : ℝ), c ≤ a → b ≤ a ^ y
a : ℝ≥0
ha : toNNReal c ≤ a
⊢ b ≤ ↑a ^ y
Theorem: Submodule.torsionBySet_singleton_eq
File: Mathlib/Algebra/Module/Torsion.lean

tactic: ext x
state_before: R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
⊢ torsionBySet R M {a} = torsionBy R M a

tactic: simp only [mem_torsionBySet_iff, SetCoe.forall, Subtype.coe_mk, Set.mem_singleton_iff,
  forall_eq, mem_torsionBy_iff]
state_before: case h
R : Type u_2
M : Type u_1
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
s : Set R
a : R
x : M
⊢ x ∈ torsionBySet R M {a} ↔ x ∈ torsionBy R M a
Theorem: Submodule.le_one_toAddSubmonoid
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: rintro x ⟨n, rfl⟩
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n : A
⊢ 1 ≤ 1.toAddSubmonoid

tactic: exact ⟨n, map_natCast (algebraMap R A) n⟩
state_before: case intro
ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n✝ : A
n : ℕ
⊢ ↑(Nat.castAddMonoidHom A) n ∈ 1.toAddSubmonoid
Theorem: Int.emod_lt
File: Mathlib/Data/Int/Order/Basic.lean

tactic: rw [← emod_abs]
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
H : b ≠ 0
⊢ a % b < abs b

tactic: exact emod_lt_of_pos _ (abs_pos.2 H)
state_before: a✝ b✝ : ℤ
n : ℕ
a b : ℤ
H : b ≠ 0
⊢ a % abs b < abs b
Theorem: Nat.mem_factors_mul_of_coprime
File: Mathlib/Data/Nat/Factors.lean

tactic: rcases a.eq_zero_or_pos with (rfl | ha)
state_before: a b : ℕ
hab : coprime a b
p : ℕ
⊢ p ∈ factors (a * b) ↔ p ∈ factors a ∪ factors b

tactic: rcases b.eq_zero_or_pos with (rfl | hb)
state_before: case inr
a b : ℕ
hab : coprime a b
p : ℕ
ha : a > 0
⊢ p ∈ factors (a * b) ↔ p ∈ factors a ∪ factors b

tactic: rw [mem_factors_mul ha.ne' hb.ne', List.mem_union]
state_before: case inr.inr
a b : ℕ
hab : coprime a b
p : ℕ
ha : a > 0
hb : b > 0
⊢ p ∈ factors (a * b) ↔ p ∈ factors a ∪ factors b

tactic: simp [(coprime_zero_left _).mp hab]
state_before: case inl
b p : ℕ
hab : coprime 0 b
⊢ p ∈ factors (0 * b) ↔ p ∈ factors 0 ∪ factors b

tactic: simp [(coprime_zero_right _).mp hab]
state_before: case inr.inl
a p : ℕ
ha : a > 0
hab : coprime a 0
⊢ p ∈ factors (a * 0) ↔ p ∈ factors a ∪ factors 0
Theorem: UniformInducing.uniformContinuous_iff
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: dsimp only [UniformContinuous, Tendsto]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
g : β → γ
hg : UniformInducing g
⊢ UniformContinuous f ↔ UniformContinuous (g ∘ f)

tactic: rw [← hg.comap_uniformity, ← map_le_iff_le_comap, Filter.map_map]
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
g : β → γ
hg : UniformInducing g
⊢ map (fun x => (f x.fst, f x.snd)) (𝓤 α) ≤ 𝓤 β ↔ map (fun x => ((g ∘ f) x.fst, (g ∘ f) x.snd)) (𝓤 α) ≤ 𝓤 γ

tactic: rfl
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
g : β → γ
hg : UniformInducing g
⊢ map ((fun x => (g x.fst, g x.snd)) ∘ fun x => (f x.fst, f x.snd)) (𝓤 α) ≤ 𝓤 γ ↔
    map (fun x => ((g ∘ f) x.fst, (g ∘ f) x.snd)) (𝓤 α) ≤ 𝓤 γ
Theorem: ZFSet.ext_iff
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp [h]
state_before: x y : ZFSet
h : x = y
⊢ ∀ (z : ZFSet), z ∈ x ↔ z ∈ y
Theorem: List.pmap_map
File: Mathlib/Data/List/Basic.lean

tactic: induction l <;> [rfl; simp only [*, pmap, map]]
state_before: ι : Type ?u.327120
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
p : β → Prop
g : (b : β) → p b → γ
f : α → β
l : List α
H : ∀ (a : β), a ∈ map f l → p a
⊢ pmap g (map f l) H = pmap (fun a h => g (f a) h) l (_ : ∀ (a : α), a ∈ l → p (f a))
Theorem: List.bind_assoc
File: Mathlib/Data/List/Basic.lean

tactic: induction l <;> simp [*]
state_before: ι : Type ?u.22576
α✝ : Type u
β✝ : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α✝
α : Type u_1
β : Type u_2
l : List α
f : α → List β
g : β → List γ
⊢ List.bind (List.bind l f) g = List.bind l fun x => List.bind (f x) g
Theorem: CategoryTheory.MonoidalCategory.hom_inv_id_tensor'
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← tensor_comp, IsIso.hom_inv_id, id_tensor_comp]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝³ : MonoidalCategory C✝
C : Type u
inst✝² : Category C
inst✝¹ : MonoidalCategory C
U V✝ W✝ X✝ Y✝ Z✝ V W X Y Z : C
f : V ⟶ W
inst✝ : IsIso f
g : X ⟶ Y
h : Y ⟶ Z
⊢ (f ⊗ g) ≫ (inv f ⊗ h) = (𝟙 V ⊗ g) ≫ (𝟙 V ⊗ h)
Theorem: CategoryTheory.Abelian.Pseudoelement.pseudoZero_iff
File: Mathlib/CategoryTheory/Abelian/Pseudoelements.lean

tactic: rw [← pseudoZero_aux P a]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
P : C
a : Over P
⊢ Quot.mk (PseudoEqual P) a = 0 ↔ a.hom = 0

tactic: exact Quotient.eq'
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
P : C
a : Over P
⊢ Quot.mk (PseudoEqual P) a = 0 ↔ a ≈ Over.mk 0
Theorem: TypeVec.repeat_eq_append1
File: Mathlib/Data/TypeVec.lean

tactic: induction n <;> rfl
state_before: n✝ : ℕ
β : Type u_1
n : ℕ
α : TypeVec n
⊢ repeatEq (α ::: β) = splitFun (repeatEq α) (uncurry Eq)
Theorem: SimpleGraph.Subgraph.deleteVerts_empty
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: simp [deleteVerts]
state_before: ι : Sort ?u.270663
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set V
⊢ deleteVerts G' ∅ = G'
Theorem: Traversable.toList_spec
File: Mathlib/Control/Fold.lean

tactic: simp only [List.reverse_reverse]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
xs : t α
⊢ ↑FreeMonoid.toList (foldMap FreeMonoid.of xs) =
    ↑FreeMonoid.toList (List.reverse (List.reverse (foldMap FreeMonoid.of xs)))

tactic: simp only [List.foldr_eta]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
xs : t α
⊢ ↑FreeMonoid.toList (List.reverse (List.reverse (foldMap FreeMonoid.of xs))) =
    ↑FreeMonoid.toList (List.reverse (List.foldr cons [] (List.reverse (foldMap FreeMonoid.of xs))))

tactic: simp [flip, List.foldr_reverse, Foldl.ofFreeMonoid, unop_op]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
xs : t α
⊢ ↑FreeMonoid.toList (List.reverse (List.foldr cons [] (List.reverse (foldMap FreeMonoid.of xs)))) =
    List.reverse (unop (↑(Foldl.ofFreeMonoid (flip cons)) (foldMap FreeMonoid.of xs)) [])

tactic: rw [foldMap_hom_free (Foldl.ofFreeMonoid (flip <| @cons α))]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
xs : t α
⊢ List.reverse (unop (↑(Foldl.ofFreeMonoid (flip cons)) (foldMap FreeMonoid.of xs)) []) = toList xs

tactic: simp only [toList, foldl, List.reverse_inj, Foldl.get, foldl.ofFreeMonoid_comp_of,
  Function.comp_apply]
state_before: α β γ : Type u
t : Type u → Type u
inst✝¹ : Traversable t
inst✝ : IsLawfulTraversable t
xs : t α
⊢ List.reverse (unop (foldMap (↑(Foldl.ofFreeMonoid (flip cons)) ∘ FreeMonoid.of) xs) []) = toList xs
Theorem: mul_inv_le_mul_inv_iff'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [mul_comm c, mul_inv_le_inv_mul_iff, mul_comm]
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LE α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a * b⁻¹ ≤ c * d⁻¹ ↔ a * d ≤ c * b
Theorem: LowerSet.mem_iInf_iff
File: Mathlib/Order/UpperLower/Basic.lean

tactic: rw [← SetLike.mem_coe, coe_iInf]
state_before: α : Type u_1
β : Type ?u.76981
γ : Type ?u.76984
ι : Sort u_2
κ : ι → Sort ?u.76992
inst✝ : LE α
S : Set (LowerSet α)
s t : LowerSet α
a : α
f : ι → LowerSet α
⊢ (a ∈ ⨅ (i : ι), f i) ↔ ∀ (i : ι), a ∈ f i

tactic: exact mem_iInter
state_before: α : Type u_1
β : Type ?u.76981
γ : Type ?u.76984
ι : Sort u_2
κ : ι → Sort ?u.76992
inst✝ : LE α
S : Set (LowerSet α)
s t : LowerSet α
a : α
f : ι → LowerSet α
⊢ (a ∈ ⋂ (i : ι), ↑(f i)) ↔ ∀ (i : ι), a ∈ f i
Theorem: Filter.HasBasis.nhds'
File: Mathlib/Topology/Filter.lean

tactic: simpa only [Iic_principal] using h.nhds
state_before: ι : Sort u_2
α : Type u_1
β : Type ?u.6309
X : Type ?u.6312
Y : Type ?u.6315
l : Filter α
p : ι → Prop
s : ι → Set α
h : HasBasis l p s
⊢ HasBasis (𝓝 l) p fun i => {l' | s i ∈ l'}
Theorem: List.Ico.zero_bot
File: Mathlib/Data/List/Intervals.lean

tactic: rw [Ico, tsub_zero, range_eq_range']
state_before: n : ℕ
⊢ Ico 0 n = range n
Theorem: ContinuousOn.isOpen_preimage
File: Mathlib/Topology/ContinuousOn.lean

tactic: convert (continuousOn_open_iff hs).mp h t ht
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.343466
δ : Type ?u.343469
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
h : ContinuousOn f s
hs : IsOpen s
hp : f ⁻¹' t ⊆ s
ht : IsOpen t
⊢ IsOpen (f ⁻¹' t)

tactic: rw [inter_comm, inter_eq_self_of_subset_left hp]
state_before: case h.e'_3
α : Type u_1
β : Type u_2
γ : Type ?u.343466
δ : Type ?u.343469
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
h : ContinuousOn f s
hs : IsOpen s
hp : f ⁻¹' t ⊆ s
ht : IsOpen t
⊢ f ⁻¹' t = s ∩ f ⁻¹' t
Theorem: HolderWith.dist_le_of_le
File: Mathlib/Topology/MetricSpace/Holder.lean

tactic: lift d to ℝ≥0 using dist_nonneg.trans hd
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.969277
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ
hd : dist x y ≤ d
⊢ dist (f x) (f y) ≤ ↑C * d ^ ↑r

tactic: rw [dist_nndist] at hd⊢
state_before: case intro
X : Type u_1
Y : Type u_2
Z : Type ?u.969277
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : dist x y ≤ ↑d
⊢ dist (f x) (f y) ≤ ↑C * ↑d ^ ↑r

tactic: norm_cast  at hd⊢
state_before: case intro
X : Type u_1
Y : Type u_2
Z : Type ?u.969277
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : ↑(nndist x y) ≤ ↑d
⊢ ↑(nndist (f x) (f y)) ≤ ↑C * ↑d ^ ↑r

tactic: exact hf.nndist_le_of_le hd
state_before: case intro
X : Type u_1
Y : Type u_2
Z : Type ?u.969277
inst✝¹ : PseudoMetricSpace X
inst✝ : PseudoMetricSpace Y
C r : ℝ≥0
f : X → Y
hf : HolderWith C r f
x y : X
d : ℝ≥0
hd : nndist x y ≤ d
⊢ nndist (f x) (f y) ≤ C * d ^ ↑r
Theorem: exists_nat_one_div_lt
File: Mathlib/Algebra/Order/Archimedean.lean

tactic: cases' exists_nat_gt (1 / ε) with n hn
state_before: α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε✝ ε : α
hε : 0 < ε
⊢ ∃ n, 1 / (↑n + 1) < ε

tactic: use n
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε✝ ε : α
hε : 0 < ε
n : ℕ
hn : 1 / ε < ↑n
⊢ ∃ n, 1 / (↑n + 1) < ε

tactic: rw [div_lt_iff, ← div_lt_iff' hε]
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε✝ ε : α
hε : 0 < ε
n : ℕ
hn : 1 / ε < ↑n
⊢ 1 / (↑n + 1) < ε

tactic: apply hn.trans
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε✝ ε : α
hε : 0 < ε
n : ℕ
hn : 1 / ε < ↑n
⊢ 1 / ε < ↑n + 1

tactic: simp [zero_lt_one]
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε✝ ε : α
hε : 0 < ε
n : ℕ
hn : 1 / ε < ↑n
⊢ ↑n < ↑n + 1

tactic: exact n.cast_add_one_pos
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrderedField α
inst✝ : Archimedean α
x y ε✝ ε : α
hε : 0 < ε
n : ℕ
hn : 1 / ε < ↑n
⊢ 0 < ↑n + 1
Theorem: CategoryTheory.simple_iff_subobject_isSimpleOrder
File: Mathlib/CategoryTheory/Simple.lean

tactic: intro h
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X : C
⊢ Simple X → IsSimpleOrder (Subobject X)

tactic: infer_instance
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X : C
h : Simple X
⊢ IsSimpleOrder (Subobject X)

tactic: intro h
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X : C
⊢ IsSimpleOrder (Subobject X) → Simple X

tactic: exact simple_of_isSimpleOrder_subobject X
state_before: C : Type u
inst✝² : Category C
inst✝¹ : HasZeroMorphisms C
inst✝ : HasZeroObject C
X : C
h : IsSimpleOrder (Subobject X)
⊢ Simple X
Theorem: ContinuousLinearEquiv.uniqueDiffOn_preimage_iff
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: rw [← e.image_symm_eq_preimage, e.symm.uniqueDiffOn_image_iff]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_3
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
f : E → F
s : Set E
f' : E →L[𝕜] F
e : F ≃L[𝕜] E
⊢ UniqueDiffOn 𝕜 (↑e ⁻¹' s) ↔ UniqueDiffOn 𝕜 s
Theorem: List.mem_filter
File: Std/Data/List/Lemmas.lean

tactic: simp [filter]
state_before: case nil
α✝ : Type u_1
x : α✝
p : α✝ → Bool
⊢ x ∈ filter p [] ↔ x ∈ [] ∧ p x = true

tactic: by_cases h : p a <;> simp [*, or_and_right]
state_before: case cons
α✝ : Type u_1
x : α✝
p : α✝ → Bool
a : α✝
as : List α✝
ih : x ∈ filter p as ↔ x ∈ as ∧ p x = true
⊢ x ∈ filter p (a :: as) ↔ x ∈ a :: as ∧ p x = true

tactic: exact or_congr_left (and_iff_left_of_imp fun | rfl => h).symm
state_before: case pos
α✝ : Type u_1
x : α✝
p : α✝ → Bool
a : α✝
as : List α✝
ih : x ∈ filter p as ↔ x ∈ as ∧ p x = true
h : p a = true
⊢ x = a ∨ x ∈ as ∧ p x = true ↔ x = a ∧ p x = true ∨ x ∈ as ∧ p x = true

tactic: exact (or_iff_right fun ⟨rfl, h'⟩ => h h').symm
state_before: case neg
α✝ : Type u_1
x : α✝
p : α✝ → Bool
a : α✝
as : List α✝
ih : x ∈ filter p as ↔ x ∈ as ∧ p x = true
h : ¬p a = true
⊢ x ∈ as ∧ p x = true ↔ x = a ∧ p x = true ∨ x ∈ as ∧ p x = true
Theorem: PGame.lf_of_lf_of_le
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← PGame.not_le] at h₁⊢
state_before: x y z : PGame
h₁ : x ⧏ y
h₂ : y ≤ z
⊢ x ⧏ z

tactic: exact fun h₃ => h₁ (h₂.trans h₃)
state_before: x y z : PGame
h₁ : ¬y ≤ x
h₂ : y ≤ z
⊢ ¬z ≤ x
Theorem: TopologicalSpace.productOfMemOpens_inducing
File: Mathlib/Topology/ContinuousFunction/T0Sierpinski.lean

tactic: convert inducing_iInf_to_pi fun (u : Opens X) (x : X) => x ∈ u
state_before: X : Type u_1
inst✝ : TopologicalSpace X
⊢ Inducing ↑(productOfMemOpens X)

tactic: apply eq_induced_by_maps_to_sierpinski
state_before: case h.e'_3
X : Type u_1
inst✝ : TopologicalSpace X
⊢ inst✝ = ⨅ (i : Opens X), induced (fun x => x ∈ i) inferInstance
Theorem: convexHull_pair
File: Mathlib/Analysis/Convex/Hull.lean

tactic: refine (convexHull_min ?_ <| convex_segment _ _).antisymm
  (segment_subset_convexHull (mem_insert _ _) <| subset_insert _ _ <| mem_singleton _)
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.23294
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
x✝ y✝ x y : E
⊢ ↑(convexHull 𝕜).toOrderHom {x, y} = segment 𝕜 x y

tactic: rw [insert_subset, singleton_subset_iff]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.23294
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
x✝ y✝ x y : E
⊢ {x, y} ⊆ segment 𝕜 x y

tactic: exact ⟨left_mem_segment _ _ _, right_mem_segment _ _ _⟩
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.23294
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
s t : Set E
x✝ y✝ x y : E
⊢ x ∈ segment 𝕜 x y ∧ y ∈ segment 𝕜 x y
Theorem: Submodule.mem_mul_span_singleton
File: Mathlib/Algebra/Algebra/Operations.lean

tactic: rfl
state_before: ι : Sort uι
R : Type u
inst✝² : CommSemiring R
A : Type v
inst✝¹ : Semiring A
inst✝ : Algebra R A
S T : Set A
M N P Q : Submodule R A
m n x y : A
⊢ x ∈ map (↑(LinearMap.flip (LinearMap.mul R A)) y) P ↔ ∃ z, z ∈ P ∧ Mul.mul z y = x
Theorem: Nat.coprime.pow_left
File: Std/Data/Nat/Gcd.lean

tactic: induction n with
| zero => exact coprime_one_left _
| succ n ih => have hm := H1.mul ih; rwa [Nat.pow_succ, Nat.mul_comm]
state_before: m k n : Nat
H1 : coprime m k
⊢ coprime (m ^ n) k

tactic: exact coprime_one_left _
state_before: case zero
m k : Nat
H1 : coprime m k
⊢ coprime (m ^ zero) k

tactic: have hm := H1.mul ih
state_before: case succ
m k : Nat
H1 : coprime m k
n : Nat
ih : coprime (m ^ n) k
⊢ coprime (m ^ succ n) k

tactic: rwa [Nat.pow_succ, Nat.mul_comm]
state_before: case succ
m k : Nat
H1 : coprime m k
n : Nat
ih : coprime (m ^ n) k
hm : coprime (m * m ^ n) k
⊢ coprime (m ^ succ n) k
Theorem: CauSeq.sup_le
File: Mathlib/Data/Real/CauSeq.lean

tactic: cases' ha with ha ha
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
ha : a ≤ c
hb : b ≤ c
⊢ a ⊔ b ≤ c

tactic: cases' hb with hb hb
state_before: case inl
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hb : b ≤ c
ha : a < c
⊢ a ⊔ b ≤ c

tactic: exact Or.inl (CauSeq.sup_lt ha hb)
state_before: case inl.inl
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
ha : a < c
hb : b < c
⊢ a ⊔ b ≤ c

tactic: replace ha := le_of_le_of_eq ha.le (Setoid.symm hb)
state_before: case inl.inr
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
ha : a < c
hb : b ≈ c
⊢ a ⊔ b ≤ c

tactic: refine' le_of_le_of_eq (Or.inr _) hb
state_before: case inl.inr
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hb : b ≈ c
ha : a ≤ b
⊢ a ⊔ b ≤ c

tactic: exact CauSeq.sup_eq_right ha
state_before: case inl.inr
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hb : b ≈ c
ha : a ≤ b
⊢ a ⊔ b ≈ b

tactic: replace hb := le_of_le_of_eq hb (Setoid.symm ha)
state_before: case inr
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
hb : b ≤ c
ha : a ≈ c
⊢ a ⊔ b ≤ c

tactic: refine' le_of_le_of_eq (Or.inr _) ha
state_before: case inr
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
ha : a ≈ c
hb : b ≤ a
⊢ a ⊔ b ≤ c

tactic: exact CauSeq.sup_eq_left hb
state_before: case inr
α : Type u_1
inst✝ : LinearOrderedField α
a b c : CauSeq α abs
ha : a ≈ c
hb : b ≤ a
⊢ a ⊔ b ≈ a
Theorem: Real.Angle.two_nsmul_toReal_eq_two_mul
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: exact_mod_cast nsmul_toReal_eq_mul two_ne_zero
state_before: θ : Angle
⊢ toReal (2 • θ) = 2 * toReal θ ↔ toReal θ ∈ Set.Ioc (-π / 2) (π / 2)
Theorem: continuousWithinAt_of_not_mem_closure
File: Mathlib/Topology/ContinuousOn.lean

tactic: intro hx
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.370490
δ : Type ?u.370493
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
x : α
⊢ ¬x ∈ closure s → ContinuousWithinAt f s x

tactic: rw [mem_closure_iff_nhdsWithin_neBot, neBot_iff, not_not] at hx
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.370490
δ : Type ?u.370493
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
x : α
hx : ¬x ∈ closure s
⊢ ContinuousWithinAt f s x

tactic: rw [ContinuousWithinAt, hx]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.370490
δ : Type ?u.370493
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
x : α
hx : 𝓝[s] x = ⊥
⊢ ContinuousWithinAt f s x

tactic: exact tendsto_bot
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.370490
δ : Type ?u.370493
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
x : α
hx : 𝓝[s] x = ⊥
⊢ Tendsto f ⊥ (𝓝 (f x))
Theorem: MeasureTheory.extend_iUnion_nat
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: congr with i
state_before: α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ (i : ℕ), f i)
mU✝ :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    Pairwise (Disjoint on f) → m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i))
msU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i))
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
f : ℕ → Set α
hm : ∀ (i : ℕ), P (f i)
mU : m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i))
⊢ (∑' (i : ℕ), m (f i) (_ : P (f i))) = ∑' (i : ℕ), extend m (f i)

tactic: rw [extend_eq]
state_before: case e_f.h
α : Type u_1
P : Set α → Prop
m : (s : Set α) → P s → ℝ≥0∞
P0 : P ∅
m0 : m ∅ P0 = 0
PU : ∀ ⦃f : ℕ → Set α⦄, (∀ (i : ℕ), P (f i)) → P (⋃ (i : ℕ), f i)
mU✝ :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    Pairwise (Disjoint on f) → m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i))
msU :
  ∀ ⦃f : ℕ → Set α⦄ (hm : ∀ (i : ℕ), P (f i)),
    m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) ≤ ∑' (i : ℕ), m (f i) (_ : P (f i))
m_mono : ∀ ⦃s₁ s₂ : Set α⦄ (hs₁ : P s₁) (hs₂ : P s₂), s₁ ⊆ s₂ → m s₁ hs₁ ≤ m s₂ hs₂
f : ℕ → Set α
hm : ∀ (i : ℕ), P (f i)
mU : m (⋃ (i : ℕ), f i) (_ : P (⋃ (i : ℕ), f i)) = ∑' (i : ℕ), m (f i) (_ : P (f i))
i : ℕ
⊢ m (f i) (_ : P (f i)) = extend m (f i)
Theorem: Complex.abs_two
File: Mathlib/Data/Complex/Basic.lean

tactic: rfl
state_before: ⊢ ↑abs 2 = ↑abs ↑2

tactic: norm_num
state_before: ⊢ 0 ≤ 2
Theorem: isUnit_iff_exists_inv'
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [isUnit_iff_exists_inv]
state_before: α : Type u
M : Type u_1
N : Type ?u.58079
inst✝ : CommMonoid M
a : M
⊢ IsUnit a ↔ ∃ b, b * a = 1

tactic: simp [mul_comm]
state_before: α : Type u
M : Type u_1
N : Type ?u.58079
inst✝ : CommMonoid M
a : M
⊢ (∃ b, a * b = 1) ↔ ∃ b, b * a = 1
Theorem: SameRay.refl
File: Mathlib/LinearAlgebra/Ray.lean

tactic: nontriviality R
state_before: R : Type u_1
inst✝⁵ : StrictOrderedCommSemiring R
M : Type u_2
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
N : Type ?u.7004
inst✝² : AddCommMonoid N
inst✝¹ : Module R N
ι : Type ?u.7086
inst✝ : DecidableEq ι
x✝ y z x : M
⊢ SameRay R x x

tactic: exact Or.inr (Or.inr <| ⟨1, 1, zero_lt_one, zero_lt_one, rfl⟩)
state_before: R : Type u_1
inst✝⁶ : StrictOrderedCommSemiring R
M : Type u_2
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
N : Type ?u.7004
inst✝³ : AddCommMonoid N
inst✝² : Module R N
ι : Type ?u.7086
inst✝¹ : DecidableEq ι
x✝ y z x : M
inst✝ : Nontrivial R
⊢ SameRay R x x
Theorem: Multiset.nodup_union
File: Mathlib/Data/Multiset/Nodup.lean

tactic: rw [count_union]
state_before: α : Type u_1
β : Type ?u.14144
γ : Type ?u.14147
r : α → α → Prop
s✝ t✝ : Multiset α
a✝ : α
inst✝ : DecidableEq α
s t : Multiset α
x✝ : Nodup s ∧ Nodup t
h₁ : Nodup s
h₂ : Nodup t
a : α
⊢ count a (s ∪ t) ≤ 1

tactic: exact max_le (nodup_iff_count_le_one.1 h₁ a) (nodup_iff_count_le_one.1 h₂ a)
state_before: α : Type u_1
β : Type ?u.14144
γ : Type ?u.14147
r : α → α → Prop
s✝ t✝ : Multiset α
a✝ : α
inst✝ : DecidableEq α
s t : Multiset α
x✝ : Nodup s ∧ Nodup t
h₁ : Nodup s
h₂ : Nodup t
a : α
⊢ max (count a s) (count a t) ≤ 1
Theorem: Submonoid.exists_list_of_mem_closure
File: Mathlib/GroupTheory/Submonoid/Membership.lean

tactic: rwa [← SetLike.mem_coe, closure_eq_image_prod, Set.mem_image_iff_bex] at hx
state_before: M : Type u_1
A : Type ?u.81053
B : Type ?u.81056
inst✝ : Monoid M
s : Set M
x : M
hx : x ∈ closure s
⊢ ∃ l x_1, List.prod l = x