tasksource/leandojo huggingface dataset:
Theorem: EMetric.exists_continuous_nNReal_forall_closedBall_subset
File: Mathlib/Topology/MetricSpace/PartitionOfUnity.lean

tactic: rcases exists_continuous_real_forall_closedBall_subset hK hU hKU hfin with ⟨δ, hδ₀, hδ⟩
state_before: ι : Type u_2
X : Type u_1
inst✝ : EMetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
⊢ ∃ δ, (∀ (x : X), 0 < ↑δ x) ∧ ∀ (i : ι) (x : X), x ∈ K i → closedBall x ↑(↑δ x) ⊆ U i

tactic: lift δ to C(X, ℝ≥0) using fun x => (hδ₀ x).le
state_before: case intro.intro
ι : Type u_2
X : Type u_1
inst✝ : EMetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
δ : C(X, ℝ)
hδ₀ : ∀ (x : X), 0 < ↑δ x
hδ : ∀ (i : ι) (x : X), x ∈ K i → closedBall x (ENNReal.ofReal (↑δ x)) ⊆ U i
⊢ ∃ δ, (∀ (x : X), 0 < ↑δ x) ∧ ∀ (i : ι) (x : X), x ∈ K i → closedBall x ↑(↑δ x) ⊆ U i

tactic: refine' ⟨δ, hδ₀, fun i x hi => _⟩
state_before: case intro.intro.intro
ι : Type u_2
X : Type u_1
inst✝ : EMetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
δ : C(X, ℝ≥0)
hδ₀ : ∀ (x : X), 0 < ↑(ContinuousMap.comp ContinuousMap.coeNNRealReal δ) x
hδ :
  ∀ (i : ι) (x : X),
    x ∈ K i → closedBall x (ENNReal.ofReal (↑(ContinuousMap.comp ContinuousMap.coeNNRealReal δ) x)) ⊆ U i
⊢ ∃ δ, (∀ (x : X), 0 < ↑δ x) ∧ ∀ (i : ι) (x : X), x ∈ K i → closedBall x ↑(↑δ x) ⊆ U i

tactic: simpa only [← ENNReal.ofReal_coe_nnreal] using hδ i x hi
state_before: case intro.intro.intro
ι : Type u_2
X : Type u_1
inst✝ : EMetricSpace X
K U : ι → Set X
hK : ∀ (i : ι), IsClosed (K i)
hU : ∀ (i : ι), IsOpen (U i)
hKU : ∀ (i : ι), K i ⊆ U i
hfin : LocallyFinite K
δ : C(X, ℝ≥0)
hδ₀ : ∀ (x : X), 0 < ↑(ContinuousMap.comp ContinuousMap.coeNNRealReal δ) x
hδ :
  ∀ (i : ι) (x : X),
    x ∈ K i → closedBall x (ENNReal.ofReal (↑(ContinuousMap.comp ContinuousMap.coeNNRealReal δ) x)) ⊆ U i
i : ι
x : X
hi : x ∈ K i
⊢ closedBall x ↑(↑δ x) ⊆ U i
Theorem: Std.RBNode.Path.ins_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: match p with
| .root | .left red .. | .right red .. | .left black .. | .right black .. =>
  simp [ins, ins_toList]
state_before: α : Type u_1
t : RBNode α
p : Path α
⊢ toList (ins p t) = withList p (toList t)

tactic: simp [ins, ins_toList]
state_before: α : Type u_1
t : RBNode α
p : Path α
l✝ : RBNode α
v✝ : α
parent✝ : Path α
⊢ toList (ins (right black l✝ v✝ parent✝) t) = withList (right black l✝ v✝ parent✝) (toList t)
Theorem: MeasureTheory.LocallyIntegrableOn.smul_continuousOn
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

tactic: rw [MeasureTheory.locallyIntegrableOn_iff (Or.inr hs)] at hf⊢
state_before: X : Type u_1
Y : Type ?u.2503222
E : Type u_3
R : Type ?u.2503228
inst✝¹⁰ : MeasurableSpace X
inst✝⁹ : TopologicalSpace X
inst✝⁸ : MeasurableSpace Y
inst✝⁷ : TopologicalSpace Y
inst✝⁶ : NormedAddCommGroup E
f✝ : X → E
μ : Measure X
s✝ : Set X
inst✝⁵ : OpensMeasurableSpace X
A K : Set X
inst✝⁴ : LocallyCompactSpace X
inst✝³ : T2Space X
𝕜 : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : SecondCountableTopologyEither X E
inst✝ : NormedSpace 𝕜 E
f : X → 𝕜
g : X → E
s : Set X
hs : IsOpen s
hf : LocallyIntegrableOn f s
hg : ContinuousOn g s
⊢ LocallyIntegrableOn (fun x => f x • g x) s

tactic: exact fun k hk_sub hk_c => (hf k hk_sub hk_c).smul_continuousOn (hg.mono hk_sub) hk_c
state_before: X : Type u_1
Y : Type ?u.2503222
E : Type u_3
R : Type ?u.2503228
inst✝¹⁰ : MeasurableSpace X
inst✝⁹ : TopologicalSpace X
inst✝⁸ : MeasurableSpace Y
inst✝⁷ : TopologicalSpace Y
inst✝⁶ : NormedAddCommGroup E
f✝ : X → E
μ : Measure X
s✝ : Set X
inst✝⁵ : OpensMeasurableSpace X
A K : Set X
inst✝⁴ : LocallyCompactSpace X
inst✝³ : T2Space X
𝕜 : Type u_2
inst✝² : NormedField 𝕜
inst✝¹ : SecondCountableTopologyEither X E
inst✝ : NormedSpace 𝕜 E
f : X → 𝕜
g : X → E
s : Set X
hs : IsOpen s
hf : ∀ (k : Set X), k ⊆ s → IsCompact k → IntegrableOn f k
hg : ContinuousOn g s
⊢ ∀ (k : Set X), k ⊆ s → IsCompact k → IntegrableOn (fun x => f x • g x) k
Theorem: Stream'.Seq1.join_cons
File: Mathlib/Data/Seq/Seq.lean

tactic: dsimp [join]
state_before: α : Type u
β : Type v
γ : Type w
a b : α
s : Seq α
S : Seq (Seq1 α)
⊢ join ((a, Seq.cons b s), S) = (a, Seq.join (Seq.cons (b, s) S))

tactic: rw [destruct_cons]
state_before: α : Type u
β : Type v
γ : Type w
a b : α
s : Seq α
S : Seq (Seq1 α)
⊢ (match destruct (Seq.cons b s) with
    | none => (a, Seq.join S)
    | some s' => (a, Seq.join (Seq.cons s' S))) =
    (a, Seq.join (Seq.cons (b, s) S))
Theorem: Nat.totient_eq_card_lt_and_coprime
File: Mathlib/Data/Nat/Totient.lean

tactic: let e : { m | m < n ∧ n.coprime m } ≃ Finset.filter n.coprime (Finset.range n) :=
  { toFun := fun m => ⟨m, by simpa only [Finset.mem_filter, Finset.mem_range] using m.property⟩
    invFun := fun m => ⟨m, by simpa only [Finset.mem_filter, Finset.mem_range] using m.property⟩
    left_inv := fun m => by simp only [Subtype.coe_mk, Subtype.coe_eta]
    right_inv := fun m => by simp only [Subtype.coe_mk, Subtype.coe_eta] }
state_before: n : ℕ
⊢ φ n = Nat.card ↑{m | m < n ∧ coprime n m}

tactic: rw [totient_eq_card_coprime, card_congr e, card_eq_fintype_card, Fintype.card_coe]
state_before: n : ℕ
e : ↑{m | m < n ∧ coprime n m} ≃ { x // x ∈ filter (coprime n) (range n) } :=
  { toFun := fun m => { val := ↑m, property := (_ : ↑m ∈ filter (coprime n) (range n)) },
    invFun := fun m => { val := ↑m, property := (_ : ↑m < n ∧ coprime n ↑m) },
    left_inv :=
      (_ :
        ∀ (m : ↑{m | m < n ∧ coprime n m}),
          { val := ↑m,
              property :=
                (_ :
                  ↑((fun m => { val := ↑m, property := (_ : ↑m ∈ filter (coprime n) (range n)) }) m) < n ∧
                    coprime n ↑((fun m => { val := ↑m, property := (_ : ↑m ∈ filter (coprime n) (range n)) }) m)) } =
            m),
    right_inv :=
      (_ :
        ∀ (m : { x // x ∈ filter (coprime n) (range n) }),
          { val := ↑m,
              property :=
                (_ :
                  ↑((fun m => { val := ↑m, property := (_ : ↑m < n ∧ coprime n ↑m) }) m) ∈
                    filter (coprime n) (range n)) } =
            m) }
⊢ φ n = Nat.card ↑{m | m < n ∧ coprime n m}

tactic: simpa only [Finset.mem_filter, Finset.mem_range] using m.property
state_before: n : ℕ
m : ↑{m | m < n ∧ coprime n m}
⊢ ↑m ∈ filter (coprime n) (range n)

tactic: simpa only [Finset.mem_filter, Finset.mem_range] using m.property
state_before: n : ℕ
m : { x // x ∈ filter (coprime n) (range n) }
⊢ ↑m ∈ {m | m < n ∧ coprime n m}

tactic: simp only [Subtype.coe_mk, Subtype.coe_eta]
state_before: n : ℕ
m : ↑{m | m < n ∧ coprime n m}
⊢ (fun m => { val := ↑m, property := (_ : ↑m < n ∧ coprime n ↑m) })
      ((fun m => { val := ↑m, property := (_ : ↑m ∈ filter (coprime n) (range n)) }) m) =
    m

tactic: simp only [Subtype.coe_mk, Subtype.coe_eta]
state_before: n : ℕ
m : { x // x ∈ filter (coprime n) (range n) }
⊢ (fun m => { val := ↑m, property := (_ : ↑m ∈ filter (coprime n) (range n)) })
      ((fun m => { val := ↑m, property := (_ : ↑m < n ∧ coprime n ↑m) }) m) =
    m
Theorem: Set.mk_preimage_prod_left_fn_eq_if
File: Mathlib/Data/Set/Prod.lean

tactic: rw [← mk_preimage_prod_left_eq_if, prod_preimage_left, preimage_preimage]
state_before: α : Type u_3
β : Type u_1
γ : Type u_2
δ : Type ?u.29388
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
inst✝ : DecidablePred fun x => x ∈ t
f : γ → α
⊢ (fun a => (f a, b)) ⁻¹' s ×ˢ t = if b ∈ t then f ⁻¹' s else ∅
Theorem: BoxIntegral.Integrable.dist_integralSum_integral_le_of_memBaseSet
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: rw [convergenceR, dif_pos h₀] at hπ
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁ π₂ : TaggedPrepartition I
h : Integrable I l f vol
h₀ : 0 < ε
hπ : MemBaseSet l I c (convergenceR h ε c) π
hπp : IsPartition π
⊢ dist (integralSum f vol π) (integral I l f vol) ≤ ε

tactic: exact (hasIntegral_iff.1 h.hasIntegral ε h₀).choose_spec.2 c _ hπ hπp
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
c c₁ c₂ : ℝ≥0
ε ε₁ ε₂ : ℝ
π₁ π₂ : TaggedPrepartition I
h : Integrable I l f vol
h₀ : 0 < ε
hπ :
  MemBaseSet l I c
    (Exists.choose
      (_ :
        ∃ r,
          (∀ (c : ℝ≥0), RCond l (r c)) ∧
            ∀ (c : ℝ≥0) (π : TaggedPrepartition I),
              MemBaseSet l I c (r c) π → IsPartition π → dist (integralSum f vol π) (integral I l f vol) ≤ ε)
      c)
    π
hπp : IsPartition π
⊢ dist (integralSum f vol π) (integral I l f vol) ≤ ε
Theorem: QuaternionAlgebra.Basis.i_mul_k
File: Mathlib/Algebra/QuaternionBasis.lean

tactic: rw [← i_mul_j, ← mul_assoc, i_mul_i, smul_mul_assoc, one_mul]
state_before: R : Type u_2
A : Type u_1
B : Type ?u.21045
inst✝⁴ : CommRing R
inst✝³ : Ring A
inst✝² : Ring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
c₁ c₂ : R
q : Basis A c₁ c₂
⊢ q.i * q.k = c₁ • q.j
Theorem: Ordinal.principal_add_of_le_one
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: rcases le_one_iff.1 ho with (rfl | rfl)
state_before: o : Ordinal
ho : o ≤ 1
⊢ Principal (fun x x_1 => x + x_1) o

tactic: exact principal_zero
state_before: case inl
ho : 0 ≤ 1
⊢ Principal (fun x x_1 => x + x_1) 0

tactic: exact principal_add_one
state_before: case inr
ho : 1 ≤ 1
⊢ Principal (fun x x_1 => x + x_1) 1
Theorem: List.mem_sublistsLen_self
File: Mathlib/Data/List/Sublists.lean

tactic: induction' h with l₁ l₂ a s IH l₁ l₂ a s IH
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l l' : List α
h : l' <+ l
⊢ l' ∈ sublistsLen (length l') l

tactic: simp
state_before: case slnil
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l l' : List α
⊢ [] ∈ sublistsLen (length []) []

tactic: cases' l₁ with b l₁
state_before: case cons
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l l' l₁ l₂ : List α
a : α
s : l₁ <+ l₂
IH : l₁ ∈ sublistsLen (length l₁) l₂
⊢ l₁ ∈ sublistsLen (length l₁) (a :: l₂)

tactic: simp
state_before: case cons.nil
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l l' l₂ : List α
a : α
s : [] <+ l₂
IH : [] ∈ sublistsLen (length []) l₂
⊢ [] ∈ sublistsLen (length []) (a :: l₂)

tactic: rw [length, sublistsLen_succ_cons]
state_before: case cons.cons
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l l' l₂ : List α
a b : α
l₁ : List α
s : b :: l₁ <+ l₂
IH : b :: l₁ ∈ sublistsLen (length (b :: l₁)) l₂
⊢ b :: l₁ ∈ sublistsLen (length (b :: l₁)) (a :: l₂)

tactic: exact mem_append_left _ IH
state_before: case cons.cons
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l l' l₂ : List α
a b : α
l₁ : List α
s : b :: l₁ <+ l₂
IH : b :: l₁ ∈ sublistsLen (length (b :: l₁)) l₂
⊢ b :: l₁ ∈ sublistsLen (length l₁ + 1) l₂ ++ map (cons a) (sublistsLen (length l₁) l₂)

tactic: rw [length, sublistsLen_succ_cons]
state_before: case cons₂
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l l' l₁ l₂ : List α
a : α
s : l₁ <+ l₂
IH : l₁ ∈ sublistsLen (length l₁) l₂
⊢ a :: l₁ ∈ sublistsLen (length (a :: l₁)) (a :: l₂)

tactic: exact mem_append_right _ (mem_map.2 ⟨_, IH, rfl⟩)
state_before: case cons₂
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l l' l₁ l₂ : List α
a : α
s : l₁ <+ l₂
IH : l₁ ∈ sublistsLen (length l₁) l₂
⊢ a :: l₁ ∈ sublistsLen (length l₁ + 1) l₂ ++ map (cons a) (sublistsLen (length l₁) l₂)
Theorem: AddMonoidAlgebra.mul_of'_modOf
File: Mathlib/Algebra/MonoidAlgebra/Division.lean

tactic: refine Finsupp.ext fun g' => ?_
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g : G
⊢ x * of' k G g %ᵒᶠ g = 0

tactic: rw [Finsupp.zero_apply]
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g g' : G
⊢ ↑(x * of' k G g %ᵒᶠ g) g' = ↑0 g'

tactic: obtain ⟨d, rfl⟩ | h := em (∃ d, g' = g + d)
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g g' : G
⊢ ↑(x * of' k G g %ᵒᶠ g) g' = 0

tactic: rw [modOf_apply_self_add]
state_before: case inl.intro
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g d : G
⊢ ↑(x * of' k G g %ᵒᶠ g) (g + d) = 0

tactic: rw [modOf_apply_of_not_exists_add _ _ _ h, of'_apply, mul_single_apply_of_not_exists_add]
state_before: case inr
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g g' : G
h : ¬∃ d, g' = g + d
⊢ ↑(x * of' k G g %ᵒᶠ g) g' = 0

tactic: simpa only [add_comm] using h
state_before: case inr.h
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : AddMonoidAlgebra k G
g g' : G
h : ¬∃ d, g' = g + d
⊢ ¬∃ d, g' = d + g
Theorem: Multiset.toFinset_inter
File: Mathlib/Data/Finset/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.449865
γ : Type ?u.449868
inst✝ : DecidableEq α
s✝ t✝ s t : Multiset α
⊢ ∀ (a : α), a ∈ toFinset (s ∩ t) ↔ a ∈ toFinset s ∩ toFinset t
Theorem: AffineBasis.coord_apply_eq
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

tactic: simp only [coord, Basis.coe_sumCoords, LinearEquiv.map_zero, LinearEquiv.coe_coe, sub_zero,
  AffineMap.coe_mk, Finsupp.sum_zero_index, vsub_self]
state_before: ι : Type u_2
ι' : Type ?u.90092
k : Type u_1
V : Type u_4
P : Type u_3
inst✝³ : AddCommGroup V
inst✝² : AffineSpace V P
inst✝¹ : Ring k
inst✝ : Module k V
b : AffineBasis ι k P
s : Finset ι
i✝ j : ι
e : ι ≃ ι'
i : ι
⊢ ↑(coord b i) (↑b i) = 1
Theorem: Summable.hasSum
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simp only [tsum_def, ha, dite_true]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.13763
δ : Type ?u.13766
inst✝¹ : AddCommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
ha : Summable f
⊢ HasSum f (∑' (b : β), f b)

tactic: exact Classical.choose_spec ha
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.13763
δ : Type ?u.13766
inst✝¹ : AddCommMonoid α
inst✝ : TopologicalSpace α
f g : β → α
a b : α
s : Finset β
ha : Summable f
⊢ HasSum f (Classical.choose (_ : Summable fun b => f b))
Theorem: Filter.EventuallyEq.sub_eq
File: Mathlib/Order/Filter/Basic.lean

tactic: simpa using ((EventuallyEq.refl l f).sub h).symm
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.191118
ι : Sort x
inst✝ : AddGroup β
f g : α → β
l : Filter α
h : f =ᶠ[l] g
⊢ f - g =ᶠ[l] 0
Theorem: List.mem_insert_iff
File: Std/Data/List/Lemmas.lean

tactic: if h : b ∈ l then
  rw [insert_of_mem h]
  constructor; {apply Or.inr}
  intro
  | Or.inl h' => rw [h']; exact h
  | Or.inr h' => exact h'
else rw [insert_of_not_mem h, mem_cons]
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
⊢ a ∈ List.insert b l ↔ a = b ∨ a ∈ l

tactic: rw [insert_of_mem h]
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : b ∈ l
⊢ a ∈ List.insert b l ↔ a = b ∨ a ∈ l

tactic: constructor
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : b ∈ l
⊢ a ∈ l ↔ a = b ∨ a ∈ l

tactic: {apply Or.inr}
state_before: case mp
α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : b ∈ l
⊢ a ∈ l → a = b ∨ a ∈ l

case mpr
α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : b ∈ l
⊢ a = b ∨ a ∈ l → a ∈ l

tactic: intro
| Or.inl h' => rw [h']; exact h
| Or.inr h' => exact h'
state_before: case mpr
α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : b ∈ l
⊢ a = b ∨ a ∈ l → a ∈ l

tactic: rw [h']
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : b ∈ l
x✝ : a = b ∨ a ∈ l
h' : a = b
⊢ a ∈ l

tactic: exact h
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : b ∈ l
x✝ : a = b ∨ a ∈ l
h' : a = b
⊢ b ∈ l

tactic: exact h'
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : b ∈ l
x✝ : a = b ∨ a ∈ l
h' : a ∈ l
⊢ a ∈ l

tactic: rw [insert_of_not_mem h, mem_cons]
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : ¬b ∈ l
⊢ a ∈ List.insert b l ↔ a = b ∨ a ∈ l
Theorem: ENNReal.Tendsto.div_const
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: apply Tendsto.mul_const hm
state_before: α : Type u_1
β : Type ?u.126772
γ : Type ?u.126775
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a b : ℝ≥0∞
hm : Tendsto m f (𝓝 a)
ha : a ≠ 0 ∨ b ≠ 0
⊢ Tendsto (fun x => m x / b) f (𝓝 (a / b))

tactic: simp [ha]
state_before: α : Type u_1
β : Type ?u.126772
γ : Type ?u.126775
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a b : ℝ≥0∞
hm : Tendsto m f (𝓝 a)
ha : a ≠ 0 ∨ b ≠ 0
⊢ a ≠ 0 ∨ b⁻¹ ≠ ⊤
Theorem: EReal.add_lt_add_left_coe
File: Mathlib/Data/Real/EReal.lean

tactic: simpa [add_comm] using add_lt_add_right_coe h z
state_before: x y : EReal
h : x < y
z : ℝ
⊢ ↑z + x < ↑z + y
Theorem: Finset.wellFoundedOn_bUnion
File: Mathlib/Order/WellFoundedSet.lean

tactic: simpa only [Finset.sup_eq_iSup] using s.wellFoundedOn_sup
state_before: ι : Type u_2
α : Type u_1
β : Type ?u.124371
r : α → α → Prop
inst✝ : IsStrictOrder α r
s : Finset ι
f : ι → Set α
⊢ Set.WellFoundedOn (⋃ (i : ι) (_ : i ∈ s), f i) r ↔ ∀ (i : ι), i ∈ s → Set.WellFoundedOn (f i) r
Theorem: MeasureTheory.StronglyMeasurable.piecewise
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: refine' ⟨fun n => SimpleFunc.piecewise s hs (hf.approx n) (hg.approx n), fun x => _⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.193105
ι : Type ?u.193108
inst✝¹ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝ : TopologicalSpace β
s : Set α
x✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
hf : StronglyMeasurable f
hg : StronglyMeasurable g
⊢ StronglyMeasurable (piecewise s f g)

tactic: by_cases hx : x ∈ s
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.193105
ι : Type ?u.193108
inst✝¹ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝ : TopologicalSpace β
s : Set α
x✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
hf : StronglyMeasurable f
hg : StronglyMeasurable g
x : α
⊢ Tendsto
    (fun n =>
      ↑((fun n => SimpleFunc.piecewise s hs (StronglyMeasurable.approx hf n) (StronglyMeasurable.approx hg n)) n) x)
    atTop (𝓝 (piecewise s f g x))

tactic: simpa [@Set.piecewise_eq_of_mem _ _ _ _ _ (fun _ => Classical.propDecidable _) _ hx,
  hx] using hf.tendsto_approx x
state_before: case pos
α : Type u_1
β : Type u_2
γ : Type ?u.193105
ι : Type ?u.193108
inst✝¹ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝ : TopologicalSpace β
s : Set α
x✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
hf : StronglyMeasurable f
hg : StronglyMeasurable g
x : α
hx : x ∈ s
⊢ Tendsto
    (fun n =>
      ↑((fun n => SimpleFunc.piecewise s hs (StronglyMeasurable.approx hf n) (StronglyMeasurable.approx hg n)) n) x)
    atTop (𝓝 (piecewise s f g x))

tactic: simpa [@Set.piecewise_eq_of_not_mem _ _ _ _ _ (fun _ => Classical.propDecidable _) _ hx,
  hx] using hg.tendsto_approx x
state_before: case neg
α : Type u_1
β : Type u_2
γ : Type ?u.193105
ι : Type ?u.193108
inst✝¹ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝ : TopologicalSpace β
s : Set α
x✝ : DecidablePred fun x => x ∈ s
hs : MeasurableSet s
hf : StronglyMeasurable f
hg : StronglyMeasurable g
x : α
hx : ¬x ∈ s
⊢ Tendsto
    (fun n =>
      ↑((fun n => SimpleFunc.piecewise s hs (StronglyMeasurable.approx hf n) (StronglyMeasurable.approx hg n)) n) x)
    atTop (𝓝 (piecewise s f g x))
Theorem: Finset.union_insert
File: Mathlib/Data/Finset/Basic.lean

tactic: simp only [insert_eq, union_left_comm]
state_before: α : Type u_1
β : Type ?u.150066
γ : Type ?u.150069
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a✝ b a : α
s t : Finset α
⊢ s ∪ insert a t = insert a (s ∪ t)
Theorem: MeasureTheory.SimpleFunc.integral_add_measure
File: Mathlib/MeasureTheory/Integral/Bochner.lean

tactic: simp_rw [integral_def]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.208871
𝕜 : Type ?u.208874
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type ?u.208976
F' : Type ?u.208979
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
m : MeasurableSpace α
μ : Measure α
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : SMulCommClass ℝ 𝕜 E
ν : Measure α
f : α →ₛ E
hf : Integrable ↑f
⊢ integral (μ + ν) f = integral μ f + integral ν f

tactic: refine' setToSimpleFunc_add_left'
  (weightedSMul μ) (weightedSMul ν) (weightedSMul (μ + ν)) (fun s _ hμνs => _) hf
state_before: α : Type u_1
E : Type u_2
F : Type ?u.208871
𝕜 : Type ?u.208874
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type ?u.208976
F' : Type ?u.208979
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
m : MeasurableSpace α
μ : Measure α
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : SMulCommClass ℝ 𝕜 E
ν : Measure α
f : α →ₛ E
hf : Integrable ↑f
⊢ setToSimpleFunc (weightedSMul (μ + ν)) f = setToSimpleFunc (weightedSMul μ) f + setToSimpleFunc (weightedSMul ν) f

tactic: rw [lt_top_iff_ne_top, Measure.coe_add, Pi.add_apply, ENNReal.add_ne_top] at hμνs
state_before: α : Type u_1
E : Type u_2
F : Type ?u.208871
𝕜 : Type ?u.208874
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type ?u.208976
F' : Type ?u.208979
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
m : MeasurableSpace α
μ : Measure α
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : SMulCommClass ℝ 𝕜 E
ν : Measure α
f : α →ₛ E
hf : Integrable ↑f
s : Set α
x✝ : MeasurableSet s
hμνs : ↑↑(μ + ν) s < ⊤
⊢ weightedSMul (μ + ν) s = weightedSMul μ s + weightedSMul ν s

tactic: rw [weightedSMul_add_measure _ _ hμνs.1 hμνs.2]
state_before: α : Type u_1
E : Type u_2
F : Type ?u.208871
𝕜 : Type ?u.208874
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
p : ℝ≥0∞
G : Type ?u.208976
F' : Type ?u.208979
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedAddCommGroup F'
inst✝⁴ : NormedSpace ℝ F'
m : MeasurableSpace α
μ : Measure α
inst✝³ : NormedField 𝕜
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace ℝ E
inst✝ : SMulCommClass ℝ 𝕜 E
ν : Measure α
f : α →ₛ E
hf : Integrable ↑f
s : Set α
x✝ : MeasurableSet s
hμνs : ↑↑μ s ≠ ⊤ ∧ ↑↑ν s ≠ ⊤
⊢ weightedSMul (μ + ν) s = weightedSMul μ s + weightedSMul ν s
Theorem: isNilpotent_of_ker_le_center
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: rw [nilpotent_iff_lowerCentralSeries] at *
state_before: G : Type u_2
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : Normal H✝
H : Type u_1
inst✝ : Group H
f : G →* H
hf1 : MonoidHom.ker f ≤ center G
hH : Group.IsNilpotent H
⊢ Group.IsNilpotent G

tactic: rcases hH with ⟨n, hn⟩
state_before: G : Type u_2
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : Normal H✝
H : Type u_1
inst✝ : Group H
f : G →* H
hf1 : MonoidHom.ker f ≤ center G
hH : ∃ n, lowerCentralSeries H n = ⊥
⊢ ∃ n, lowerCentralSeries G n = ⊥

tactic: use n + 1
state_before: case intro
G : Type u_2
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : Normal H✝
H : Type u_1
inst✝ : Group H
f : G →* H
hf1 : MonoidHom.ker f ≤ center G
n : ℕ
hn : lowerCentralSeries H n = ⊥
⊢ ∃ n, lowerCentralSeries G n = ⊥

tactic: refine' lowerCentralSeries_succ_eq_bot (le_trans ((Subgroup.map_eq_bot_iff _).mp _) hf1)
state_before: case intro
G : Type u_2
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : Normal H✝
H : Type u_1
inst✝ : Group H
f : G →* H
hf1 : MonoidHom.ker f ≤ center G
n : ℕ
hn : lowerCentralSeries H n = ⊥
⊢ lowerCentralSeries G (n + 1) = ⊥

tactic: exact eq_bot_iff.mpr (hn ▸ lowerCentralSeries.map f n)
state_before: case intro
G : Type u_2
inst✝² : Group G
H✝ : Subgroup G
inst✝¹ : Normal H✝
H : Type u_1
inst✝ : Group H
f : G →* H
hf1 : MonoidHom.ker f ≤ center G
n : ℕ
hn : lowerCentralSeries H n = ⊥
⊢ Subgroup.map f (lowerCentralSeries G n) = ⊥