tasksource/leandojo huggingface dataset:
Theorem: IsSelfAdjoint.smul
File: Mathlib/Algebra/Star/SelfAdjoint.lean

tactic: simp only [isSelfAdjoint_iff, star_smul, hr.star_eq, hx.star_eq]
state_before: R : Type u_1
A : Type u_2
inst✝⁴ : Star R
inst✝³ : AddMonoid A
inst✝² : StarAddMonoid A
inst✝¹ : SMul R A
inst✝ : StarModule R A
r : R
hr : IsSelfAdjoint r
x : A
hx : IsSelfAdjoint x
⊢ IsSelfAdjoint (r • x)
Theorem: isLUB_pi
File: Mathlib/Order/Bounds/Basic.lean

tactic: refine'
  ⟨fun H a => ⟨(Function.monotone_eval a).mem_upperBounds_image H.1, fun b hb => _⟩, fun H =>
    ⟨_, _⟩⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
π : α → Type u_1
inst✝ : (a : α) → Preorder (π a)
s : Set ((a : α) → π a)
f : (a : α) → π a
⊢ IsLUB s f ↔ ∀ (a : α), IsLUB (eval a '' s) (f a)

tactic: suffices h : Function.update f a b ∈ upperBounds s from Function.update_same a b f ▸ H.2 h a
state_before: case refine'_1
α : Type u
β : Type v
γ : Type w
ι : Sort x
π : α → Type u_1
inst✝ : (a : α) → Preorder (π a)
s : Set ((a : α) → π a)
f : (a : α) → π a
H : IsLUB s f
a : α
b : π a
hb : b ∈ upperBounds (eval a '' s)
⊢ f a ≤ b

tactic: refine' fun g hg => le_update_iff.2 ⟨hb <| mem_image_of_mem _ hg, fun i _ => H.1 hg i⟩
state_before: case refine'_1
α : Type u
β : Type v
γ : Type w
ι : Sort x
π : α → Type u_1
inst✝ : (a : α) → Preorder (π a)
s : Set ((a : α) → π a)
f : (a : α) → π a
H : IsLUB s f
a : α
b : π a
hb : b ∈ upperBounds (eval a '' s)
⊢ update f a b ∈ upperBounds s

tactic: exact fun g hg a => (H a).1 (mem_image_of_mem _ hg)
state_before: case refine'_2
α : Type u
β : Type v
γ : Type w
ι : Sort x
π : α → Type u_1
inst✝ : (a : α) → Preorder (π a)
s : Set ((a : α) → π a)
f : (a : α) → π a
H : ∀ (a : α), IsLUB (eval a '' s) (f a)
⊢ f ∈ upperBounds s

tactic: exact fun g hg a => (H a).2 ((Function.monotone_eval a).mem_upperBounds_image hg)
state_before: case refine'_3
α : Type u
β : Type v
γ : Type w
ι : Sort x
π : α → Type u_1
inst✝ : (a : α) → Preorder (π a)
s : Set ((a : α) → π a)
f : (a : α) → π a
H : ∀ (a : α), IsLUB (eval a '' s) (f a)
⊢ f ∈ lowerBounds (upperBounds s)
Theorem: SimpleGraph.Walk.IsTrail.dropUntil
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: rwa [← take_spec _ h] at hc
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v w : V
p : Walk G v w
hc : IsTrail p
h : u ∈ support p
⊢ IsTrail (append (?m.255550 hc h) (dropUntil p u h))
Theorem: RatFunc.denom_div
File: Mathlib/FieldTheory/RatFunc.lean

tactic: rw [denom, numDenom_div _ hq]
state_before: K : Type u
inst✝ : Field K
p q : K[X]
hq : q ≠ 0
⊢ denom (↑(algebraMap K[X] (RatFunc K)) p / ↑(algebraMap K[X] (RatFunc K)) q) =
    ↑C (leadingCoeff (q / gcd p q))⁻¹ * (q / gcd p q)
Theorem: Rat.divInt_one_one
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [divInt]
state_before: a b c : ℚ
⊢ 1 /. 1 = 1

tactic: simp
state_before: a b c : ℚ
⊢ (match 1, 1 with
    | n, Int.ofNat d => inline (mkRat n d)
    | n, Int.negSucc d => normalize (-n) (Nat.succ d)) =
    1

tactic: rfl
state_before: a b c : ℚ
⊢ mkRat 1 1 = 1
Theorem: one_div_pow_le_one_div_pow_of_le
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: refine' (one_div_le_one_div _ _).mpr (pow_le_pow a1 mn) <;>
  exact pow_pos (zero_lt_one.trans_le a1) _
state_before: ι : Type ?u.121089
α : Type u_1
β : Type ?u.121095
inst✝ : LinearOrderedSemifield α
a b c d e : α
m✝ n✝ : ℤ
a1 : 1 ≤ a
m n : ℕ
mn : m ≤ n
⊢ 1 / a ^ n ≤ 1 / a ^ m
Theorem: Turing.ListBlank.map_modifyNth
File: Mathlib/Computability/TuringMachine.lean

tactic: induction' n with n IH generalizing L <;>
  simp only [*, ListBlank.head_map, ListBlank.modifyNth, ListBlank.map_cons, ListBlank.tail_map]
state_before: Γ : Type u_1
Γ' : Type u_2
inst✝¹ : Inhabited Γ
inst✝ : Inhabited Γ'
F : PointedMap Γ Γ'
f : Γ → Γ
f' : Γ' → Γ'
H : ∀ (x : Γ), PointedMap.f F (f x) = f' (PointedMap.f F x)
n : ℕ
L : ListBlank Γ
⊢ map F (modifyNth f n L) = modifyNth f' n (map F L)
Theorem: AddMonoidAlgebra.exists_finset_adjoin_eq_top
File: Mathlib/RingTheory/FiniteType.lean

tactic: obtain ⟨S, hS⟩ := h
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : AddCommMonoid M
h : FiniteType R (AddMonoidAlgebra R M)
⊢ ∃ G, adjoin R (of' R M '' ↑G) = ⊤

tactic: letI : DecidableEq M := Classical.decEq M
state_before: case mk.intro
R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : AddCommMonoid M
S : Finset (AddMonoidAlgebra R M)
hS : adjoin R ↑S = ⊤
⊢ ∃ G, adjoin R (of' R M '' ↑G) = ⊤

tactic: use Finset.biUnion S fun f => f.support
state_before: case mk.intro
R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : AddCommMonoid M
S : Finset (AddMonoidAlgebra R M)
hS : adjoin R ↑S = ⊤
this : DecidableEq M := Classical.decEq M
⊢ ∃ G, adjoin R (of' R M '' ↑G) = ⊤

tactic: have : (Finset.biUnion S fun f => f.support : Set M) = ⋃ f ∈ S, (f.support : Set M) := by
  simp only [Finset.set_biUnion_coe, Finset.coe_biUnion]
state_before: case mk.intro
R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : AddCommMonoid M
S : Finset (AddMonoidAlgebra R M)
hS : adjoin R ↑S = ⊤
this : DecidableEq M := Classical.decEq M
⊢ adjoin R (of' R M '' ↑(Finset.biUnion S fun f => f.support)) = ⊤

tactic: rw [this]
state_before: case mk.intro
R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : AddCommMonoid M
S : Finset (AddMonoidAlgebra R M)
hS : adjoin R ↑S = ⊤
this✝ : DecidableEq M := Classical.decEq M
this : ↑(Finset.biUnion S fun f => f.support) = ⋃ (f : AddMonoidAlgebra R M) (_ : f ∈ S), ↑f.support
⊢ adjoin R (of' R M '' ↑(Finset.biUnion S fun f => f.support)) = ⊤

tactic: exact support_gen_of_gen' hS
state_before: case mk.intro
R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : AddCommMonoid M
S : Finset (AddMonoidAlgebra R M)
hS : adjoin R ↑S = ⊤
this✝ : DecidableEq M := Classical.decEq M
this : ↑(Finset.biUnion S fun f => f.support) = ⋃ (f : AddMonoidAlgebra R M) (_ : f ∈ S), ↑f.support
⊢ adjoin R (of' R M '' ⋃ (f : AddMonoidAlgebra R M) (_ : f ∈ S), ↑f.support) = ⊤

tactic: simp only [Finset.set_biUnion_coe, Finset.coe_biUnion]
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommRing R
inst✝ : AddCommMonoid M
S : Finset (AddMonoidAlgebra R M)
hS : adjoin R ↑S = ⊤
this : DecidableEq M := Classical.decEq M
⊢ ↑(Finset.biUnion S fun f => f.support) = ⋃ (f : AddMonoidAlgebra R M) (_ : f ∈ S), ↑f.support
Theorem: CategoryTheory.Limits.limit.map_post
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

tactic: ext
state_before: J : Type u₁
inst✝⁵ : Category J
K : Type u₂
inst✝⁴ : Category K
C : Type u
inst✝³ : Category C
F : J ⥤ C
inst✝² : HasLimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
D : Type u'
inst✝¹ : Category D
inst✝ : HasLimitsOfShape J D
H : C ⥤ D
⊢ H.map (limMap α) ≫ post G H = post F H ≫ limMap (whiskerRight α H)

tactic: simp only [whiskerRight_app, limMap_π, assoc, limit.post_π_assoc, limit.post_π, ← H.map_comp]
state_before: case w
J : Type u₁
inst✝⁵ : Category J
K : Type u₂
inst✝⁴ : Category K
C : Type u
inst✝³ : Category C
F : J ⥤ C
inst✝² : HasLimitsOfShape J C
G : J ⥤ C
α : F ⟶ G
D : Type u'
inst✝¹ : Category D
inst✝ : HasLimitsOfShape J D
H : C ⥤ D
j✝ : J
⊢ (H.map (limMap α) ≫ post G H) ≫ π (G ⋙ H) j✝ = (post F H ≫ limMap (whiskerRight α H)) ≫ π (G ⋙ H) j✝
Theorem: ZNum.of_to_int'
File: Mathlib/Data/Num/Lemmas.lean

tactic: dsimp [ofInt', cast_zero]
state_before: α : Type ?u.961215
⊢ ofInt' ↑0 = 0

tactic: erw [Num.ofNat'_zero, Num.toZNum]
state_before: α : Type ?u.961215
⊢ Num.toZNum (Num.ofNat' 0) = 0

tactic: rw [cast_pos, ← PosNum.cast_to_nat, ← Num.ofInt'_toZNum, PosNum.of_to_nat]
state_before: α : Type ?u.961215
a : PosNum
⊢ ofInt' ↑(pos a) = pos a

tactic: rfl
state_before: α : Type ?u.961215
a : PosNum
⊢ Num.toZNum (Num.pos a) = pos a

tactic: rw [cast_neg, ofInt'_neg, ← PosNum.cast_to_nat, ← Num.ofInt'_toZNum, PosNum.of_to_nat]
state_before: α : Type ?u.961215
a : PosNum
⊢ ofInt' ↑(neg a) = neg a

tactic: rfl
state_before: α : Type ?u.961215
a : PosNum
⊢ -Num.toZNum (Num.pos a) = neg a
Theorem: Filter.comap_inf_principal_neBot_of_image_mem
File: Mathlib/Order/Filter/Basic.lean

tactic: refine' ⟨compl_compl s ▸ mt mem_of_eq_bot _⟩
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.276092
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
f : Filter β
m : α → β
hf : NeBot f
s : Set α
hs : m '' s ∈ f
⊢ NeBot (comap m f ⊓ 𝓟 s)

tactic: rintro ⟨t, ht, hts⟩
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.276092
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t : Set β
f : Filter β
m : α → β
hf : NeBot f
s : Set α
hs : m '' s ∈ f
⊢ ¬sᶜ ∈ comap m f

tactic: rcases hf.nonempty_of_mem (inter_mem hs ht) with ⟨_, ⟨x, hxs, rfl⟩, hxt⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.276092
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t✝ : Set β
f : Filter β
m : α → β
hf : NeBot f
s : Set α
hs : m '' s ∈ f
t : Set β
ht : t ∈ f
hts : m ⁻¹' t ⊆ sᶜ
⊢ False

tactic: exact absurd hxs (hts hxt)
state_before: case intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
δ : Type ?u.276092
ι : Sort x
f✝ f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m✝ : α → β
m' : β → γ
s✝ : Set α
t✝ : Set β
f : Filter β
m : α → β
hf : NeBot f
s : Set α
hs : m '' s ∈ f
t : Set β
ht : t ∈ f
hts : m ⁻¹' t ⊆ sᶜ
x : α
hxs : x ∈ s
hxt : m x ∈ t
⊢ False
Theorem: Multiset.product_cons
File: Mathlib/Data/Multiset/Bind.lean

tactic: simp [SProd.sprod, product]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.57529
δ : Type ?u.57532
a : α
b : β
s : Multiset α
t : Multiset β
⊢ s ×ˢ (b ::ₘ t) = map (fun a => (a, b)) s + s ×ˢ t
Theorem: Multiset.nodup_iff_count_le_one
File: Mathlib/Data/Multiset/Nodup.lean

tactic: simp only [quot_mk_to_coe'', coe_nodup, mem_coe, coe_count]
state_before: α : Type u_1
β : Type ?u.2011
γ : Type ?u.2014
r : α → α → Prop
s✝ t : Multiset α
a : α
inst✝ : DecidableEq α
s : Multiset α
_l : List α
⊢ Nodup (Quot.mk Setoid.r _l) ↔ ∀ (a : α), count a (Quot.mk Setoid.r _l) ≤ 1

tactic: apply List.nodup_iff_count_le_one
state_before: α : Type u_1
β : Type ?u.2011
γ : Type ?u.2014
r : α → α → Prop
s✝ t : Multiset α
a : α
inst✝ : DecidableEq α
s : Multiset α
_l : List α
⊢ List.Nodup _l ↔ ∀ (a : α), List.count a _l ≤ 1
Theorem: MeasurableSet.image_of_continuousOn_injOn
File: Mathlib/MeasureTheory/Constructions/Polish.lean

tactic: obtain ⟨t', t't, t'_polish, s_closed, _⟩ :
  ∃ t' : TopologicalSpace γ, t' ≤ tγ ∧ @PolishSpace γ t' ∧ IsClosed[t'] s ∧ IsOpen[t'] s :=
  hs.isClopenable
state_before: α : Type ?u.321538
inst✝⁵ : TopologicalSpace α
ι : Type ?u.321544
γ : Type u_1
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
inst✝³ : MeasurableSpace γ
hγb : BorelSpace γ
β : Type u_2
tβ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
s : Set γ
f : γ → β
hs : MeasurableSet s
f_cont : ContinuousOn f s
f_inj : InjOn f s
⊢ MeasurableSet (f '' s)

tactic: exact
  @IsClosed.measurableSet_image_of_continuousOn_injOn γ t' t'_polish β _ _ _ _ s s_closed f
    (f_cont.mono_dom t't) f_inj
state_before: case intro.intro.intro.intro
α : Type ?u.321538
inst✝⁵ : TopologicalSpace α
ι : Type ?u.321544
γ : Type u_1
tγ : TopologicalSpace γ
inst✝⁴ : PolishSpace γ
inst✝³ : MeasurableSpace γ
hγb : BorelSpace γ
β : Type u_2
tβ : TopologicalSpace β
inst✝² : T2Space β
inst✝¹ : MeasurableSpace β
inst✝ : BorelSpace β
s : Set γ
f : γ → β
hs : MeasurableSet s
f_cont : ContinuousOn f s
f_inj : InjOn f s
t' : TopologicalSpace γ
t't : t' ≤ tγ
t'_polish : PolishSpace γ
s_closed : IsClosed s
right✝ : IsOpen s
⊢ MeasurableSet (f '' s)
Theorem: differentiableWithinAt_euclidean
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: rw [← (EuclideanSpace.equiv ι 𝕜).comp_differentiableWithinAt_iff, differentiableWithinAt_pi]
state_before: 𝕜 : Type u_1
ι : Type u_3
H : Type u_2
inst✝³ : IsROrC 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
⊢ DifferentiableWithinAt 𝕜 f t y ↔ ∀ (i : ι), DifferentiableWithinAt 𝕜 (fun x => f x i) t y

tactic: rfl
state_before: 𝕜 : Type u_1
ι : Type u_3
H : Type u_2
inst✝³ : IsROrC 𝕜
inst✝² : NormedAddCommGroup H
inst✝¹ : NormedSpace 𝕜 H
inst✝ : Fintype ι
f : H → EuclideanSpace 𝕜 ι
f' : H →L[𝕜] EuclideanSpace 𝕜 ι
t : Set H
y : H
⊢ (∀ (i : ι), DifferentiableWithinAt 𝕜 (fun x => (↑(EuclideanSpace.equiv ι 𝕜) ∘ f) x i) t y) ↔
    ∀ (i : ι), DifferentiableWithinAt 𝕜 (fun x => f x i) t y
Theorem: List.Perm.permutations'
File: Mathlib/Data/List/Perm.lean

tactic: induction' p with a s t _ IH a b l s t u _ _ IH₁ IH₂
state_before: α : Type uu
β : Type vv
l₁ l₂ s t : List α
p : s ~ t
⊢ List.permutations' s ~ List.permutations' t

tactic: simp
state_before: case nil
α : Type uu
β : Type vv
l₁ l₂ s t : List α
⊢ List.permutations' [] ~ List.permutations' []

tactic: simp only [permutations']
state_before: case cons
α : Type uu
β : Type vv
l₁ l₂ s✝ t✝ : List α
a : α
s t : List α
a✝ : s ~ t
IH : List.permutations' s ~ List.permutations' t
⊢ List.permutations' (a :: s) ~ List.permutations' (a :: t)

tactic: exact IH.bind_right _
state_before: case cons
α : Type uu
β : Type vv
l₁ l₂ s✝ t✝ : List α
a : α
s t : List α
a✝ : s ~ t
IH : List.permutations' s ~ List.permutations' t
⊢ List.permutations' (a :: s) ~ List.permutations' (a :: t)

tactic: dsimp [permutations']
state_before: case swap
α : Type uu
β : Type vv
l₁ l₂ s t : List α
a b : α
l : List α
⊢ List.permutations' (b :: a :: l) ~ List.permutations' (a :: b :: l)

tactic: rw [bind_assoc, bind_assoc]
state_before: case swap
α : Type uu
β : Type vv
l₁ l₂ s t : List α
a b : α
l : List α
⊢ List.bind (List.bind (List.permutations' l) (permutations'Aux a)) (permutations'Aux b) ~
    List.bind (List.bind (List.permutations' l) (permutations'Aux b)) (permutations'Aux a)

tactic: apply Perm.bind_left
state_before: case swap
α : Type uu
β : Type vv
l₁ l₂ s t : List α
a b : α
l : List α
⊢ (List.bind (List.permutations' l) fun x => List.bind (permutations'Aux a x) (permutations'Aux b)) ~
    List.bind (List.permutations' l) fun x => List.bind (permutations'Aux b x) (permutations'Aux a)

tactic: intro l' _
state_before: case swap.h
α : Type uu
β : Type vv
l₁ l₂ s t : List α
a b : α
l : List α
⊢ ∀ (a_1 : List α),
    a_1 ∈ List.permutations' l →
      List.bind (permutations'Aux a a_1) (permutations'Aux b) ~ List.bind (permutations'Aux b a_1) (permutations'Aux a)

tactic: apply perm_permutations'Aux_comm
state_before: case swap.h
α : Type uu
β : Type vv
l₁ l₂ s t : List α
a b : α
l l' : List α
a✝ : l' ∈ List.permutations' l
⊢ List.bind (permutations'Aux a l') (permutations'Aux b) ~ List.bind (permutations'Aux b l') (permutations'Aux a)

tactic: exact IH₁.trans IH₂
state_before: case trans
α : Type uu
β : Type vv
l₁ l₂ s✝ t✝ s t u : List α
a✝¹ : s ~ t
a✝ : t ~ u
IH₁ : List.permutations' s ~ List.permutations' t
IH₂ : List.permutations' t ~ List.permutations' u
⊢ List.permutations' s ~ List.permutations' u
Theorem: UniformSpace.hasBasis_nhds_prod
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [nhds_prod_eq]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.69859
inst✝ : UniformSpace α
x y : α
⊢ HasBasis (𝓝 (x, y)) (fun s => s ∈ 𝓤 α ∧ SymmetricRel s) fun s => ball x s ×ˢ ball y s

tactic: apply (hasBasis_nhds x).prod_same_index (hasBasis_nhds y)
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.69859
inst✝ : UniformSpace α
x y : α
⊢ HasBasis (𝓝 x ×ˢ 𝓝 y) (fun s => s ∈ 𝓤 α ∧ SymmetricRel s) fun s => ball x s ×ˢ ball y s

tactic: rintro U V ⟨U_in, U_symm⟩ ⟨V_in, V_symm⟩
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.69859
inst✝ : UniformSpace α
x y : α
⊢ ∀ {i j : Set (α × α)},
    i ∈ 𝓤 α ∧ SymmetricRel i →
      j ∈ 𝓤 α ∧ SymmetricRel j → ∃ k, (k ∈ 𝓤 α ∧ SymmetricRel k) ∧ ball x k ⊆ ball x i ∧ ball y k ⊆ ball y j

tactic: exact
  ⟨U ∩ V, ⟨(𝓤 α).inter_sets U_in V_in, U_symm.inter V_symm⟩, ball_inter_left x U V,
    ball_inter_right y U V⟩
state_before: case intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.69859
inst✝ : UniformSpace α
x y : α
U V : Set (α × α)
U_in : U ∈ 𝓤 α
U_symm : SymmetricRel U
V_in : V ∈ 𝓤 α
V_symm : SymmetricRel V
⊢ ∃ k, (k ∈ 𝓤 α ∧ SymmetricRel k) ∧ ball x k ⊆ ball x U ∧ ball y k ⊆ ball y V
Theorem: Finset.sorted_zero_eq_min'
File: Mathlib/Data/Finset/Sort.lean

tactic: rwa [length_sort] at h
state_before: α : Type ?u.12020
β : Type ?u.12023
inst✝ : LinearOrder α
s : Finset α
h : 0 < List.length (sort (fun x x_1 => x ≤ x_1) s)
⊢ 0 < card s
Theorem: MeasurableSpace.generateFrom_insert_empty
File: Mathlib/MeasureTheory/MeasurableSpaceDef.lean

tactic: rw [insert_eq, ← generateFrom_sup_generateFrom, generateFrom_singleton_empty, bot_sup_eq]
state_before: α : Type u_1
β : Type ?u.22617
γ : Type ?u.22620
δ : Type ?u.22623
δ' : Type ?u.22626
ι : Sort ?u.22629
s t u : Set α
S : Set (Set α)
⊢ generateFrom (insert ∅ S) = generateFrom S
Theorem: Asymptotics.isLittleO_pow_sub_pow_sub
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: apply tendsto_norm_zero.comp
state_before: α : Type ?u.658099
β : Type ?u.658102
E : Type ?u.658105
F : Type ?u.658108
G : Type ?u.658111
E' : Type u_1
F' : Type ?u.658117
G' : Type ?u.658120
E'' : Type ?u.658123
F'' : Type ?u.658126
G'' : Type ?u.658129
R : Type ?u.658132
R' : Type ?u.658135
𝕜 : Type ?u.658138
𝕜' : Type ?u.658141
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 α
x₀ : E'
n m : ℕ
h : n < m
⊢ Tendsto (fun x => ‖x - x₀‖) (𝓝 x₀) (𝓝 0)

tactic: rw [← sub_self x₀]
state_before: α : Type ?u.658099
β : Type ?u.658102
E : Type ?u.658105
F : Type ?u.658108
G : Type ?u.658111
E' : Type u_1
F' : Type ?u.658117
G' : Type ?u.658120
E'' : Type ?u.658123
F'' : Type ?u.658126
G'' : Type ?u.658129
R : Type ?u.658132
R' : Type ?u.658135
𝕜 : Type ?u.658138
𝕜' : Type ?u.658141
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 α
x₀ : E'
n m : ℕ
h : n < m
⊢ Tendsto (fun x => x - x₀) (𝓝 x₀) (𝓝 0)

tactic: exact tendsto_id.sub tendsto_const_nhds
state_before: α : Type ?u.658099
β : Type ?u.658102
E : Type ?u.658105
F : Type ?u.658108
G : Type ?u.658111
E' : Type u_1
F' : Type ?u.658117
G' : Type ?u.658120
E'' : Type ?u.658123
F'' : Type ?u.658126
G'' : Type ?u.658129
R : Type ?u.658132
R' : Type ?u.658135
𝕜 : Type ?u.658138
𝕜' : Type ?u.658141
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 α
x₀ : E'
n m : ℕ
h : n < m
⊢ Tendsto (fun x => x - x₀) (𝓝 x₀) (𝓝 (x₀ - x₀))
Theorem: Set.iUnion₂_inter
File: Mathlib/Data/Set/Lattice.lean

tactic: simp_rw [iUnion_inter]
state_before: α : Type u_1
β : Type ?u.116412
γ : Type ?u.116415
ι : Sort u_2
ι' : Sort ?u.116421
ι₂ : Sort ?u.116424
κ : ι → Sort u_3
κ₁ : ι → Sort ?u.116434
κ₂ : ι → Sort ?u.116439
κ' : ι' → Sort ?u.116444
s : (i : ι) → κ i → Set α
t : Set α
⊢ (⋃ (i : ι) (j : κ i), s i j) ∩ t = ⋃ (i : ι) (j : κ i), s i j ∩ t
Theorem: Polynomial.coeff_ofSubring
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: simp only [ofSubring, coeff_monomial, finset_sum_coeff, mem_support_iff, Finset.sum_ite_eq',
  ite_eq_right_iff, Ne.def, ite_not, Classical.not_not, ite_eq_left_iff]
state_before: R : Type u
S : Type ?u.105459
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
T : Subring R
p : { x // x ∈ T }[X]
n : ℕ
⊢ coeff (ofSubring T p) n = ↑(coeff p n)

tactic: intro h
state_before: R : Type u
S : Type ?u.105459
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
T : Subring R
p : { x // x ∈ T }[X]
n : ℕ
⊢ coeff p n = 0 → 0 = ↑(coeff p n)

tactic: rw [h, ZeroMemClass.coe_zero]
state_before: R : Type u
S : Type ?u.105459
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
T : Subring R
p : { x // x ∈ T }[X]
n : ℕ
h : coeff p n = 0
⊢ 0 = ↑(coeff p n)
Theorem: LinearMap.tailing_sup_tunnel_succ_le_tunnel
File: Mathlib/LinearAlgebra/Prod.lean

tactic: dsimp [tailing, tunnel, tunnel', tunnelAux]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.551452
M₆ : Type ?u.551455
inst✝⁴ : Ring R
N : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ↑f
n : ℕ
⊢ tailing f i n ⊔ ↑OrderDual.ofDual (↑(tunnel f i) (n + 1)) ≤ ↑OrderDual.ofDual (↑(tunnel f i) n)

tactic: erw [← Submodule.map_sup, sup_comm, Submodule.fst_sup_snd, Submodule.map_comp, Submodule.map_comp]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.551452
M₆ : Type ?u.551455
inst✝⁴ : Ring R
N : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ↑f
n : ℕ
⊢ Submodule.map (comp (comp (Submodule.subtype (tunnel' f i n).fst) ↑(LinearEquiv.symm (tunnel' f i n).snd)) f)
        (Submodule.snd R M N) ⊔
      Submodule.map
        (comp (comp (Submodule.subtype (tunnel' f i (n + 0)).fst) ↑(LinearEquiv.symm (tunnel' f i (n + 0)).snd)) f)
        (Submodule.fst R M N) ≤
    (tunnel' f i n).fst

tactic: apply Submodule.map_subtype_le
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type ?u.551452
M₆ : Type ?u.551455
inst✝⁴ : Ring R
N : Type u_1
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ↑f
n : ℕ
⊢ Submodule.map (Submodule.subtype (tunnel' f i n).fst)
      (Submodule.map (↑(LinearEquiv.symm (tunnel' f i n).snd)) (Submodule.map f ⊤)) ≤
    (tunnel' f i n).fst
Theorem: Commute.geom_sum₂_mul
File: Mathlib/Algebra/GeomSum.lean

tactic: have := (h.sub_left (Commute.refl y)).geom_sum₂_mul_add n
state_before: α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n : ℕ
⊢ (∑ i in range n, x ^ i * y ^ (n - 1 - i)) * (x - y) = x ^ n - y ^ n

tactic: rw [sub_add_cancel] at this
state_before: α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n : ℕ
this : (∑ i in range n, (x - y + y) ^ i * y ^ (n - 1 - i)) * (x - y) + y ^ n = (x - y + y) ^ n
⊢ (∑ i in range n, x ^ i * y ^ (n - 1 - i)) * (x - y) = x ^ n - y ^ n

tactic: rw [← this, add_sub_cancel]
state_before: α : Type u
inst✝ : Ring α
x y : α
h : Commute x y
n : ℕ
this : (∑ i in range n, x ^ i * y ^ (n - 1 - i)) * (x - y) + y ^ n = x ^ n
⊢ (∑ i in range n, x ^ i * y ^ (n - 1 - i)) * (x - y) = x ^ n - y ^ n
Theorem: Int.neg_add_lt_right_of_lt_add
File: Std/Data/Int/Lemmas.lean

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

tactic: exact Int.neg_add_lt_left_of_lt_add h
state_before: a b c : Int
h : a < c + b
⊢ -c + a < b