tasksource/leandojo huggingface dataset:
Theorem: HasFDerivWithinAt.eventually_ne
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

tactic: rw [nhdsWithin, diff_eq, ← inf_principal, ← inf_assoc, eventually_inf_principal]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.457298
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.457393
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : HasFDerivWithinAt f f' s x
hf' : ∃ C, ∀ (z : E), ‖z‖ ≤ C * ‖↑f' z‖
⊢ ∀ᶠ (z : E) in 𝓝[s \ {x}] x, f z ≠ f x

tactic: have A : (fun z => z - x) =O[𝓝[s] x] fun z => f' (z - x) :=
  isBigO_iff.2 <| hf'.imp fun C hC => eventually_of_forall fun z => hC _
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.457298
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.457393
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : HasFDerivWithinAt f f' s x
hf' : ∃ C, ∀ (z : E), ‖z‖ ≤ C * ‖↑f' z‖
⊢ ∀ᶠ (x_1 : E) in 𝓝 x ⊓ 𝓟 s, x_1 ∈ {x}ᶜ → f x_1 ≠ f x

tactic: have : (fun z => f z - f x) ~[𝓝[s] x] fun z => f' (z - x) := h.trans_isBigO A
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.457298
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.457393
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : HasFDerivWithinAt f f' s x
hf' : ∃ C, ∀ (z : E), ‖z‖ ≤ C * ‖↑f' z‖
A : (fun z => z - x) =O[𝓝[s] x] fun z => ↑f' (z - x)
⊢ ∀ᶠ (x_1 : E) in 𝓝 x ⊓ 𝓟 s, x_1 ∈ {x}ᶜ → f x_1 ≠ f x

tactic: simpa [not_imp_not, sub_eq_zero] using (A.trans this.isBigO_symm).eq_zero_imp
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.457298
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.457393
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
h : HasFDerivWithinAt f f' s x
hf' : ∃ C, ∀ (z : E), ‖z‖ ≤ C * ‖↑f' z‖
A : (fun z => z - x) =O[𝓝[s] x] fun z => ↑f' (z - x)
this : (fun z => f z - f x) ~[𝓝[s] x] fun z => ↑f' (z - x)
⊢ ∀ᶠ (x_1 : E) in 𝓝 x ⊓ 𝓟 s, x_1 ∈ {x}ᶜ → f x_1 ≠ f x
Theorem: IsLUB.exists_seq_monotone_tendsto
File: Mathlib/Topology/Order/Basic.lean

tactic: by_cases h : x ∈ t
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : LinearOrder α
inst✝³ : LinearOrder β
inst✝² : OrderTopology α
inst✝¹ : OrderTopology β
t : Set α
x : α
inst✝ : IsCountablyGenerated (𝓝 x)
htx : IsLUB t x
ht : Set.Nonempty t
⊢ ∃ u, Monotone u ∧ (∀ (n : ℕ), u n ≤ x) ∧ Tendsto u atTop (𝓝 x) ∧ ∀ (n : ℕ), u n ∈ t

tactic: exact ⟨fun _ => x, monotone_const, fun n => le_rfl, tendsto_const_nhds, fun _ => h⟩
state_before: case pos
α : Type u
β : Type v
γ : Type w
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : LinearOrder α
inst✝³ : LinearOrder β
inst✝² : OrderTopology α
inst✝¹ : OrderTopology β
t : Set α
x : α
inst✝ : IsCountablyGenerated (𝓝 x)
htx : IsLUB t x
ht : Set.Nonempty t
h : x ∈ t
⊢ ∃ u, Monotone u ∧ (∀ (n : ℕ), u n ≤ x) ∧ Tendsto u atTop (𝓝 x) ∧ ∀ (n : ℕ), u n ∈ t

tactic: rcases htx.exists_seq_strictMono_tendsto_of_not_mem h ht with ⟨u, hu⟩
state_before: case neg
α : Type u
β : Type v
γ : Type w
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : LinearOrder α
inst✝³ : LinearOrder β
inst✝² : OrderTopology α
inst✝¹ : OrderTopology β
t : Set α
x : α
inst✝ : IsCountablyGenerated (𝓝 x)
htx : IsLUB t x
ht : Set.Nonempty t
h : ¬x ∈ t
⊢ ∃ u, Monotone u ∧ (∀ (n : ℕ), u n ≤ x) ∧ Tendsto u atTop (𝓝 x) ∧ ∀ (n : ℕ), u n ∈ t

tactic: exact ⟨u, hu.1.monotone, fun n => (hu.2.1 n).le, hu.2.2⟩
state_before: case neg.intro
α : Type u
β : Type v
γ : Type w
inst✝⁶ : TopologicalSpace α
inst✝⁵ : TopologicalSpace β
inst✝⁴ : LinearOrder α
inst✝³ : LinearOrder β
inst✝² : OrderTopology α
inst✝¹ : OrderTopology β
t : Set α
x : α
inst✝ : IsCountablyGenerated (𝓝 x)
htx : IsLUB t x
ht : Set.Nonempty t
h : ¬x ∈ t
u : ℕ → α
hu : StrictMono u ∧ (∀ (n : ℕ), u n < x) ∧ Tendsto u atTop (𝓝 x) ∧ ∀ (n : ℕ), u n ∈ t
⊢ ∃ u, Monotone u ∧ (∀ (n : ℕ), u n ≤ x) ∧ Tendsto u atTop (𝓝 x) ∧ ∀ (n : ℕ), u n ∈ t
Theorem: Submodule.map_symm_eq_iff
File: Mathlib/LinearAlgebra/Basic.lean

tactic: constructor <;> rintro rfl
state_before: R : Type u_1
R₁ : Type ?u.2284641
R₂ : Type u_2
R₃ : Type ?u.2284647
R₄ : Type ?u.2284650
S : Type ?u.2284653
K✝ : Type ?u.2284656
K₂ : Type ?u.2284659
M : Type u_3
M' : Type ?u.2284665
M₁ : Type ?u.2284668
M₂ : Type u_4
M₃ : Type ?u.2284674
M₄ : Type ?u.2284677
N : Type ?u.2284680
N₂ : Type ?u.2284683
ι : Type ?u.2284686
V : Type ?u.2284689
V₂ : Type ?u.2284692
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R₂ M₂
inst✝⁵ : AddCommMonoid N
inst✝⁴ : AddCommMonoid N₂
inst✝³ : Module R N
inst✝² : Module R N₂
τ₁₂ : R →+* R₂
τ₂₁ : R₂ →+* R
inst✝¹ : RingHomInvPair τ₁₂ τ₂₁
inst✝ : RingHomInvPair τ₂₁ τ₁₂
p : Submodule R M
q : Submodule R₂ M₂
pₗ : Submodule R N
qₗ : Submodule R N₂
e : M ≃ₛₗ[τ₁₂] M₂
K : Submodule R₂ M₂
⊢ map (LinearEquiv.symm e) K = p ↔ map e p = K

tactic: calc
  map e (map e.symm K) = comap e.symm (map e.symm K) := map_equiv_eq_comap_symm _ _
  _ = K := comap_map_eq_of_injective e.symm.injective _
state_before: case mp
R : Type u_1
R₁ : Type ?u.2284641
R₂ : Type u_2
R₃ : Type ?u.2284647
R₄ : Type ?u.2284650
S : Type ?u.2284653
K✝ : Type ?u.2284656
K₂ : Type ?u.2284659
M : Type u_3
M' : Type ?u.2284665
M₁ : Type ?u.2284668
M₂ : Type u_4
M₃ : Type ?u.2284674
M₄ : Type ?u.2284677
N : Type ?u.2284680
N₂ : Type ?u.2284683
ι : Type ?u.2284686
V : Type ?u.2284689
V₂ : Type ?u.2284692
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R₂ M₂
inst✝⁵ : AddCommMonoid N
inst✝⁴ : AddCommMonoid N₂
inst✝³ : Module R N
inst✝² : Module R N₂
τ₁₂ : R →+* R₂
τ₂₁ : R₂ →+* R
inst✝¹ : RingHomInvPair τ₁₂ τ₂₁
inst✝ : RingHomInvPair τ₂₁ τ₁₂
q : Submodule R₂ M₂
pₗ : Submodule R N
qₗ : Submodule R N₂
e : M ≃ₛₗ[τ₁₂] M₂
K : Submodule R₂ M₂
⊢ map e (map (LinearEquiv.symm e) K) = K

tactic: calc
  map e.symm (map e p) = comap e (map e p) := (comap_equiv_eq_map_symm _ _).symm
  _ = p := comap_map_eq_of_injective e.injective _
state_before: case mpr
R : Type u_1
R₁ : Type ?u.2284641
R₂ : Type u_2
R₃ : Type ?u.2284647
R₄ : Type ?u.2284650
S : Type ?u.2284653
K : Type ?u.2284656
K₂ : Type ?u.2284659
M : Type u_3
M' : Type ?u.2284665
M₁ : Type ?u.2284668
M₂ : Type u_4
M₃ : Type ?u.2284674
M₄ : Type ?u.2284677
N : Type ?u.2284680
N₂ : Type ?u.2284683
ι : Type ?u.2284686
V : Type ?u.2284689
V₂ : Type ?u.2284692
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : CommSemiring R₂
inst✝⁹ : AddCommMonoid M
inst✝⁸ : AddCommMonoid M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R₂ M₂
inst✝⁵ : AddCommMonoid N
inst✝⁴ : AddCommMonoid N₂
inst✝³ : Module R N
inst✝² : Module R N₂
τ₁₂ : R →+* R₂
τ₂₁ : R₂ →+* R
inst✝¹ : RingHomInvPair τ₁₂ τ₂₁
inst✝ : RingHomInvPair τ₂₁ τ₁₂
p : Submodule R M
q : Submodule R₂ M₂
pₗ : Submodule R N
qₗ : Submodule R N₂
e : M ≃ₛₗ[τ₁₂] M₂
⊢ map (LinearEquiv.symm e) (map e p) = p
Theorem: isEmpty_pi
File: Mathlib/Logic/IsEmpty.lean

tactic: simp only [← not_nonempty_iff, Classical.nonempty_pi, not_forall]
state_before: α : Sort u_2
β : Sort ?u.2205
γ : Sort ?u.2208
π : α → Sort u_1
⊢ IsEmpty ((a : α) → π a) ↔ ∃ a, IsEmpty (π a)
Theorem: SimpleGraph.edgeFinset_ssubset_edgeFinset
File: Mathlib/Combinatorics/SimpleGraph/Basic.lean

tactic: simp
state_before: ι : Sort ?u.108522
𝕜 : Type ?u.108525
V : Type u
W : Type v
X : Type w
G : SimpleGraph V
G' : SimpleGraph W
a b c u v w : V
e : Sym2 V
G₁ G₂ : SimpleGraph V
inst✝² : Fintype ↑(edgeSet G)
inst✝¹ : Fintype ↑(edgeSet G₁)
inst✝ : Fintype ↑(edgeSet G₂)
⊢ edgeFinset G₁ ⊂ edgeFinset G₂ ↔ G₁ < G₂
Theorem: Real.exp_ne_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [exp, ← ofReal_inj] at h
state_before: x y : ℝ
h : exp x = 0
⊢ Complex.exp ↑x = 0

tactic: simp_all
state_before: x y : ℝ
h : ↑(Complex.exp ↑x).re = ↑0
⊢ Complex.exp ↑x = 0
Theorem: map_symm_diff'
File: Mathlib/Order/Hom/Lattice.lean

tactic: rw [symmDiff, symmDiff, map_sup, map_sdiff', map_sdiff']
state_before: F : Type u_3
ι : Type ?u.39178
α : Type u_2
β : Type u_1
γ : Type ?u.39187
δ : Type ?u.39190
inst✝² : BooleanAlgebra α
inst✝¹ : BooleanAlgebra β
inst✝ : BoundedLatticeHomClass F α β
f : F
a b : α
⊢ ↑f (a ∆ b) = ↑f a ∆ ↑f b
Theorem: CompleteLattice.Independent.comp
File: Mathlib/Order/SupIndep.lean

tactic: refine' (iSup_mono fun i => _).trans (iSup_comp_le _ f)
state_before: α : Type u_3
β : Type ?u.51964
ι✝ : Type ?u.51967
ι'✝ : Type ?u.51970
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t✝ : ι✝ → α
ht✝ : Independent t✝
ι : Sort u_1
ι' : Sort u_2
t : ι → α
f : ι' → ι
ht : Independent t
hf : Injective f
i : ι'
⊢ (⨆ (j : ι') (_ : j ≠ i), (t ∘ f) j) ≤ ⨆ (j : ι) (_ : j ≠ f i), t j

tactic: exact iSup_const_mono hf.ne
state_before: α : Type u_3
β : Type ?u.51964
ι✝ : Type ?u.51967
ι'✝ : Type ?u.51970
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t✝ : ι✝ → α
ht✝ : Independent t✝
ι : Sort u_1
ι' : Sort u_2
t : ι → α
f : ι' → ι
ht : Independent t
hf : Injective f
i✝ i : ι'
⊢ (⨆ (_ : i ≠ i✝), (t ∘ f) i) ≤ ⨆ (_ : f i ≠ f i✝), t (f i)
Theorem: Set.subsingleton_of_einfsep_eq_top
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: rw [einfsep_top] at hs
state_before: α : Type u_1
β : Type ?u.49562
inst✝ : PseudoMetricSpace α
s : Set α
hs : einfsep s = ⊤
⊢ Set.Subsingleton s

tactic: exact fun _ hx _ hy => of_not_not fun hxy => edist_ne_top _ _ (hs _ hx _ hy hxy)
state_before: α : Type u_1
β : Type ?u.49562
inst✝ : PseudoMetricSpace α
s : Set α
hs : ∀ (x : α), x ∈ s → ∀ (y : α), y ∈ s → x ≠ y → edist x y = ⊤
⊢ Set.Subsingleton s
Theorem: Int.negSucc_inj
File: Std/Data/Int/Lemmas.lean

tactic: simp [H]
state_before: m n : Nat
H : m = n
⊢ -[m+1] = -[n+1]
Theorem: Polynomial.monic_map_iff
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: rw [Monic, leadingCoeff_map, ← f.map_one, Function.Injective.eq_iff f.injective, Monic]
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✝ : DivisionRing k
f : R →+* k
p : R[X]
⊢ Monic (map f p) ↔ Monic p
Theorem: Asymptotics.isLittleO_congr
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsLittleO_def]
state_before: α : Type u_1
β : Type ?u.61096
E : Type u_2
F : Type u_3
G : Type ?u.61105
E' : Type ?u.61108
F' : Type ?u.61111
G' : Type ?u.61114
E'' : Type ?u.61117
F'' : Type ?u.61120
G'' : Type ?u.61123
R : Type ?u.61126
R' : Type ?u.61129
𝕜 : Type ?u.61132
𝕜' : Type ?u.61135
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f₁ f₂ : α → E
g₁ g₂ : α → F
hf : f₁ =ᶠ[l] f₂
hg : g₁ =ᶠ[l] g₂
⊢ f₁ =o[l] g₁ ↔ f₂ =o[l] g₂

tactic: exact forall₂_congr fun c _hc => isBigOWith_congr (Eq.refl c) hf hg
state_before: α : Type u_1
β : Type ?u.61096
E : Type u_2
F : Type u_3
G : Type ?u.61105
E' : Type ?u.61108
F' : Type ?u.61111
G' : Type ?u.61114
E'' : Type ?u.61117
F'' : Type ?u.61120
G'' : Type ?u.61123
R : Type ?u.61126
R' : Type ?u.61129
𝕜 : Type ?u.61132
𝕜' : Type ?u.61135
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
f₁ f₂ : α → E
g₁ g₂ : α → F
hf : f₁ =ᶠ[l] f₂
hg : g₁ =ᶠ[l] g₂
⊢ (∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l f₁ g₁) ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c l f₂ g₂
Theorem: Set.image_iUnion₂
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [image_iUnion]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.196148
ι : Sort u_3
ι' : Sort ?u.196154
ι₂ : Sort ?u.196157
κ : ι → Sort u_4
κ₁ : ι → Sort ?u.196167
κ₂ : ι → Sort ?u.196172
κ' : ι' → Sort ?u.196177
f : α → β
s : (i : ι) → κ i → Set α
⊢ (f '' ⋃ (i : ι) (j : κ i), s i j) = ⋃ (i : ι) (j : κ i), f '' s i j
Theorem: Nat.ord_proj_dvd
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: by_cases hp : p.Prime
state_before: n p : ℕ
⊢ p ^ ↑(factorization n) p ∣ n

tactic: case neg => simp [hp]
state_before: case pos
n p : ℕ
hp : Prime p
⊢ p ^ ↑(factorization n) p ∣ n

case neg
n p : ℕ
hp : ¬Prime p
⊢ p ^ ↑(factorization n) p ∣ n

tactic: rw [← factors_count_eq]
state_before: case pos
n p : ℕ
hp : Prime p
⊢ p ^ ↑(factorization n) p ∣ n

tactic: apply dvd_of_factors_subperm (pow_ne_zero _ hp.ne_zero)
state_before: case pos
n p : ℕ
hp : Prime p
⊢ p ^ count p (factors n) ∣ n

tactic: rw [hp.factors_pow, List.subperm_ext_iff]
state_before: case pos
n p : ℕ
hp : Prime p
⊢ factors (p ^ count p (factors n)) <+~ factors n

tactic: intro q hq
state_before: case pos
n p : ℕ
hp : Prime p
⊢ ∀ (x : ℕ), x ∈ replicate (count p (factors n)) p → count x (replicate (count p (factors n)) p) ≤ count x (factors n)

tactic: simp [List.eq_of_mem_replicate hq]
state_before: case pos
n p : ℕ
hp : Prime p
q : ℕ
hq : q ∈ replicate (count p (factors n)) p
⊢ count q (replicate (count p (factors n)) p) ≤ count q (factors n)

tactic: simp [hp]
state_before: n p : ℕ
hp : ¬Prime p
⊢ p ^ ↑(factorization n) p ∣ n
Theorem: Subsemigroup.iSup_induction
File: Mathlib/GroupTheory/Subsemigroup/Membership.lean

tactic: rw [iSup_eq_closure] at hx₁
state_before: ι : Sort u_2
M : Type u_1
A : Type ?u.9348
B : Type ?u.9351
inst✝ : Mul M
S : ι → Subsemigroup M
C : M → Prop
x₁ : M
hx₁ : x₁ ∈ ⨆ (i : ι), S i
hp : ∀ (i : ι) (x₂ : M), x₂ ∈ S i → C x₂
hmul : ∀ (x y : M), C x → C y → C (x * y)
⊢ C x₁

tactic: refine' closure_induction hx₁ (fun x₂ hx₂ => _) hmul
state_before: ι : Sort u_2
M : Type u_1
A : Type ?u.9348
B : Type ?u.9351
inst✝ : Mul M
S : ι → Subsemigroup M
C : M → Prop
x₁ : M
hx₁ : x₁ ∈ closure (⋃ (i : ι), ↑(S i))
hp : ∀ (i : ι) (x₂ : M), x₂ ∈ S i → C x₂
hmul : ∀ (x y : M), C x → C y → C (x * y)
⊢ C x₁

tactic: obtain ⟨i, hi⟩ := Set.mem_iUnion.mp hx₂
state_before: ι : Sort u_2
M : Type u_1
A : Type ?u.9348
B : Type ?u.9351
inst✝ : Mul M
S : ι → Subsemigroup M
C : M → Prop
x₁ : M
hx₁ : x₁ ∈ closure (⋃ (i : ι), ↑(S i))
hp : ∀ (i : ι) (x₂ : M), x₂ ∈ S i → C x₂
hmul : ∀ (x y : M), C x → C y → C (x * y)
x₂ : M
hx₂ : x₂ ∈ ⋃ (i : ι), ↑(S i)
⊢ C x₂

tactic: exact hp _ _ hi
state_before: case intro
ι : Sort u_2
M : Type u_1
A : Type ?u.9348
B : Type ?u.9351
inst✝ : Mul M
S : ι → Subsemigroup M
C : M → Prop
x₁ : M
hx₁ : x₁ ∈ closure (⋃ (i : ι), ↑(S i))
hp : ∀ (i : ι) (x₂ : M), x₂ ∈ S i → C x₂
hmul : ∀ (x y : M), C x → C y → C (x * y)
x₂ : M
hx₂ : x₂ ∈ ⋃ (i : ι), ↑(S i)
i : ι
hi : x₂ ∈ ↑(S i)
⊢ C x₂
Theorem: Sym.exists_eq_cons_of_succ
File: Mathlib/Data/Sym/Basic.lean

tactic: obtain ⟨a, ha⟩ := exists_mem s
state_before: α : Type u_1
β : Type ?u.30706
n n' m : ℕ
s✝ : Sym α n
a b : α
s : Sym α (Nat.succ n)
⊢ ∃ a s', s = a ::ₛ s'

tactic: classical exact ⟨a, s.erase a ha, (cons_erase ha).symm⟩
state_before: case intro
α : Type u_1
β : Type ?u.30706
n n' m : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (Nat.succ n)
a : α
ha : a ∈ s
⊢ ∃ a s', s = a ::ₛ s'

tactic: exact ⟨a, s.erase a ha, (cons_erase ha).symm⟩
state_before: case intro
α : Type u_1
β : Type ?u.30706
n n' m : ℕ
s✝ : Sym α n
a✝ b : α
s : Sym α (Nat.succ n)
a : α
ha : a ∈ s
⊢ ∃ a s', s = a ::ₛ s'
Theorem: CompositionSeries.top_eraseTop
File: Mathlib/Order/JordanHolder.lean

tactic: ext
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
⊢ { val := ↑(Fin.last (eraseTop s).length), isLt := (_ : ↑(Fin.last (eraseTop s).length) < s.length + 1) } =
    { val := s.length - 1, isLt := (_ : s.length - 1 < s.length + 1) }

tactic: simp only [eraseTop_length, Fin.val_last, Fin.coe_castSucc, Fin.coe_ofNat_eq_mod,
  Fin.val_mk]
state_before: case h
X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s : CompositionSeries X
⊢ ↑{ val := ↑(Fin.last (eraseTop s).length), isLt := (_ : ↑(Fin.last (eraseTop s).length) < s.length + 1) } =
    ↑{ val := s.length - 1, isLt := (_ : s.length - 1 < s.length + 1) }
Theorem: Nat.pow_log_le_add_one
File: Mathlib/Data/Nat/Log.lean

tactic: rw [log_zero_right, pow_zero]
state_before: b : ℕ
⊢ b ^ log b 0 ≤ 0 + 1
Theorem: List.ne_nil_of_mem
File: Std/Data/List/Lemmas.lean

tactic: cases h <;> intro.
state_before: α : Type u_1
a : α
l : List α
h : a ∈ l
⊢ l ≠ []
Theorem: lp.norm_le_of_forall_le'
File: Mathlib/Analysis/NormedSpace/lpSpace.lean

tactic: refine' (isLUB_norm f).2 _
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Nonempty α
f : { x // x ∈ lp E ⊤ }
C : ℝ
hCf : ∀ (i : α), ‖↑f i‖ ≤ C
⊢ ‖f‖ ≤ C

tactic: rintro - ⟨i, rfl⟩
state_before: α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Nonempty α
f : { x // x ∈ lp E ⊤ }
C : ℝ
hCf : ∀ (i : α), ‖↑f i‖ ≤ C
⊢ C ∈ upperBounds (Set.range fun i => ‖↑f i‖)

tactic: exact hCf i
state_before: case intro
α : Type u_1
E : α → Type u_2
p q : ℝ≥0∞
inst✝¹ : (i : α) → NormedAddCommGroup (E i)
inst✝ : Nonempty α
f : { x // x ∈ lp E ⊤ }
C : ℝ
hCf : ∀ (i : α), ‖↑f i‖ ≤ C
i : α
⊢ (fun i => ‖↑f i‖) i ≤ C
Theorem: List.Chain'.rel_head?
File: Mathlib/Data/List/Chain.lean

tactic: rw [← cons_head?_tail hy] at h
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a b x : α
l : List α
h : Chain' R (x :: l)
y : α
hy : y ∈ head? l
⊢ R x y

tactic: exact h.rel_head
state_before: α : Type u
β : Type v
R r : α → α → Prop
l✝ l₁ l₂ : List α
a b x : α
l : List α
y : α
h : Chain' R (x :: y :: List.tail l)
hy : y ∈ head? l
⊢ R x y
Theorem: Subgroup.conj_smul_le_of_le
File: Mathlib/GroupTheory/Subgroup/Pointwise.lean

tactic: rintro - ⟨g, hg, rfl⟩
state_before: α : Type ?u.101125
G : Type u_1
A : Type ?u.101131
S : Type ?u.101134
inst✝³ : Group G
inst✝² : AddGroup A
s : Set G
inst✝¹ : Monoid α
inst✝ : MulDistribMulAction α G
P H : Subgroup G
hP : P ≤ H
h : { x // x ∈ H }
⊢ ↑MulAut.conj ↑h • P ≤ H

tactic: exact H.mul_mem (H.mul_mem h.2 (hP hg)) (H.inv_mem h.2)
state_before: case intro.intro
α : Type ?u.101125
G : Type u_1
A : Type ?u.101131
S : Type ?u.101134
inst✝³ : Group G
inst✝² : AddGroup A
s : Set G
inst✝¹ : Monoid α
inst✝ : MulDistribMulAction α G
P H : Subgroup G
hP : P ≤ H
h : { x // x ∈ H }
g : G
hg : g ∈ ↑P
⊢ ↑(↑(MulDistribMulAction.toMonoidEnd ((fun x => MulAut G) ↑h) G) (↑MulAut.conj ↑h)) g ∈ H
Theorem: OreLocalization.mul_inv
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: simp [oreDiv_mul_char (s : R) s' s' s 1 1 (by simp)]
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
s s' : { x // x ∈ S }
⊢ ↑s /ₒ s' * (↑s' /ₒ s) = 1

tactic: simp
state_before: R : Type u_1
inst✝¹ : Monoid R
S : Submonoid R
inst✝ : OreSet S
s s' : { x // x ∈ S }
⊢ ↑s' * ↑1 = ↑s' * 1
Theorem: Polynomial.monic_X_pow_sub_C
File: Mathlib/Data/Polynomial/Monic.lean

tactic: obtain ⟨k, rfl⟩ := Nat.exists_eq_succ_of_ne_zero h
state_before: R✝ : Type u
S : Type v
a✝ b : R✝
m n✝ : ℕ
ι : Type y
inst✝¹ : Ring R✝
p : R✝[X]
R : Type u
inst✝ : Ring R
a : R
n : ℕ
h : n ≠ 0
⊢ Monic (X ^ n - ↑C a)

tactic: apply monic_X_pow_sub _
state_before: case intro
R✝ : Type u
S : Type v
a✝ b : R✝
m n : ℕ
ι : Type y
inst✝¹ : Ring R✝
p : R✝[X]
R : Type u
inst✝ : Ring R
a : R
k : ℕ
h : Nat.succ k ≠ 0
⊢ Monic (X ^ Nat.succ k - ↑C a)

tactic: exact le_trans degree_C_le Nat.WithBot.coe_nonneg
state_before: R✝ : Type u
S : Type v
a✝ b : R✝
m n : ℕ
ι : Type y
inst✝¹ : Ring R✝
p : R✝[X]
R : Type u
inst✝ : Ring R
a : R
k : ℕ
h : Nat.succ k ≠ 0
⊢ degree (↑C a) ≤ ↑k
Theorem: ENNReal.div_top
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [div_eq_mul_inv, inv_top, mul_zero]
state_before: α : Type ?u.272750
β : Type ?u.272753
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a / ⊤ = 0
Theorem: Real.sqrt_le_left
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [sqrt, ← Real.le_toNNReal_iff_coe_le hy, NNReal.sqrt_le_iff, sq, ← Real.toNNReal_mul hy,
  Real.toNNReal_le_toNNReal_iff (mul_self_nonneg y), sq]
state_before: x y : ℝ
hy : 0 ≤ y
⊢ sqrt x ≤ y ↔ x ≤ y ^ 2
Theorem: Mathlib.Meta.NormNum.isNat_int_cast
File: Mathlib/Tactic/NormNum/Basic.lean

tactic: rintro ⟨⟨⟩⟩
state_before: R : Type u_1
inst✝ : Ring R
n : ℤ
m : ℕ
⊢ IsNat n m → IsNat (↑n) m

tactic: exact ⟨by simp⟩
state_before: case mk.refl
R : Type u_1
inst✝ : Ring R
m : ℕ
⊢ IsNat (↑↑m) m

tactic: simp
state_before: R : Type u_1
inst✝ : Ring R
m : ℕ
⊢ ↑↑m = ↑m
Theorem: Polynomial.eval₂_neg
File: Mathlib/Data/Polynomial/Eval.lean

tactic: rw [eq_neg_iff_add_eq_zero, ← eval₂_add, add_left_neg, eval₂_zero]
state_before: R : Type u
S✝ : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Ring R
p q r : R[X]
S : Type u_1
inst✝ : Ring S
f : R →+* S
x : S
⊢ eval₂ f x (-p) = -eval₂ f x p
Theorem: CategoryTheory.BinaryCofan.isPullback_initial_to_of_isVanKampen
File: Mathlib/CategoryTheory/Extensive.lean

tactic: refine' ((h (BinaryCofan.mk (initial.to Y) (𝟙 Y)) (mapPair (initial.to X) (𝟙 Y)) c.inr _
    (mapPair_equifibered _)).mp ⟨_⟩ ⟨WalkingPair.left⟩).flip
state_before: J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsPullback (initial.to ((pair X Y).obj { as := WalkingPair.left }))
    (initial.to ((pair X Y).obj { as := WalkingPair.right })) (BinaryCofan.inl c) (BinaryCofan.inr c)

tactic: ext ⟨⟨⟩⟩ <;> dsimp
state_before: case refine'_1
J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ mapPair (initial.to X) (𝟙 Y) ≫ c.ι =
    (BinaryCofan.mk (initial.to Y) (𝟙 Y)).ι ≫ (Functor.const (Discrete WalkingPair)).map (BinaryCofan.inr c)

tactic: simp
state_before: case refine'_1.w.h.mk.left
J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ initial.to X ≫ BinaryCofan.inl c = initial.to Y ≫ BinaryCofan.inr c

tactic: exact ((BinaryCofan.isColimit_iff_isIso_inr initialIsInitial _).mpr (by
  dsimp
  infer_instance)).some
state_before: case refine'_2
J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsColimit (BinaryCofan.mk (initial.to Y) (𝟙 Y))

tactic: dsimp
state_before: J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsIso (BinaryCofan.inr (BinaryCofan.mk (initial.to Y) (𝟙 Y)))

tactic: infer_instance
state_before: J : Type v'
inst✝² : Category J
C : Type u
inst✝¹ : Category C
X Y : C
inst✝ : HasInitial C
c : BinaryCofan X Y
h : IsVanKampenColimit c
⊢ IsIso (𝟙 Y)