tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.analyticSet_empty
File: Mathlib/MeasureTheory/Constructions/Polish.lean

tactic: rw [AnalyticSet]
state_before: α : Type u_1
inst✝ : TopologicalSpace α
ι : Type ?u.465
⊢ AnalyticSet ∅

tactic: exact Or.inl rfl
state_before: α : Type u_1
inst✝ : TopologicalSpace α
ι : Type ?u.465
⊢ ∅ = ∅ ∨ ∃ f, Continuous f ∧ range f = ∅
Theorem: Finset.eraseNone_union
File: Mathlib/Data/Finset/Option.lean

tactic: ext
state_before: α : Type u_1
β : Type ?u.11560
inst✝¹ : DecidableEq (Option α)
inst✝ : DecidableEq α
s t : Finset (Option α)
⊢ ↑eraseNone (s ∪ t) = ↑eraseNone s ∪ ↑eraseNone t

tactic: simp
state_before: case a
α : Type u_1
β : Type ?u.11560
inst✝¹ : DecidableEq (Option α)
inst✝ : DecidableEq α
s t : Finset (Option α)
a✝ : α
⊢ a✝ ∈ ↑eraseNone (s ∪ t) ↔ a✝ ∈ ↑eraseNone s ∪ ↑eraseNone t
Theorem: Int.add_modEq_left
File: Mathlib/Data/Int/ModEq.lean

tactic: simp
state_before: m n a b c d : ℤ
⊢ n ∣ n + a - a
Theorem: rank_span_le
File: Mathlib/LinearAlgebra/Dimension.lean

tactic: obtain ⟨b, hb, hsab, hlib⟩ := exists_linearIndependent K s
state_before: K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.566078
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s : Set V
⊢ Module.rank K { x // x ∈ span K s } ≤ (#↑s)

tactic: convert Cardinal.mk_le_mk_of_subset hb
state_before: case intro.intro.intro
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.566078
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s b : Set V
hb : b ⊆ s
hsab : span K b = span K s
hlib : LinearIndependent K Subtype.val
⊢ Module.rank K { x // x ∈ span K s } ≤ (#↑s)

tactic: rw [← hsab, rank_span_set hlib]
state_before: case h.e'_3
K : Type u
V V₁ V₂ V₃ : Type v
V' V'₁ : Type v'
V'' : Type v''
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type ?u.566078
inst✝⁶ : DivisionRing K
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module K V
inst✝³ : AddCommGroup V'
inst✝² : Module K V'
inst✝¹ : AddCommGroup V₁
inst✝ : Module K V₁
s b : Set V
hb : b ⊆ s
hsab : span K b = span K s
hlib : LinearIndependent K Subtype.val
⊢ Module.rank K { x // x ∈ span K s } = (#↑b)
Theorem: Fin.prod_trunc
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [prod_univ_add, Fintype.prod_eq_one _ hf, mul_one]
state_before: α : Type ?u.74019
β : Type ?u.74022
M : Type u_1
inst✝ : CommMonoid M
a b : ℕ
f : Fin (a + b) → M
hf : ∀ (j : Fin b), f (↑(natAdd a) j) = 1
⊢ ∏ i : Fin (a + b), f i = ∏ i : Fin a, f (↑(castLE (_ : a ≤ a + b)) i)

tactic: rfl
state_before: α : Type ?u.74019
β : Type ?u.74022
M : Type u_1
inst✝ : CommMonoid M
a b : ℕ
f : Fin (a + b) → M
hf : ∀ (j : Fin b), f (↑(natAdd a) j) = 1
⊢ ∏ i : Fin a, f (↑(castAdd b) i) = ∏ i : Fin a, f (↑(castLE (_ : a ≤ a + b)) i)
Theorem: List.sublists'Aux_eq_array_foldl
File: Mathlib/Data/List/Sublists.lean

tactic: intro r₁ r₂
state_before: α : Type u
β : Type v
γ : Type w
a : α
⊢ ∀ (r₁ r₂ : List (List α)),
    sublists'Aux a r₁ r₂ =
      Array.toList
        (Array.foldl (fun r l => Array.push r (a :: l)) (toArray r₂) (toArray r₁) 0 (Array.size (toArray r₁)))

tactic: rw [sublists'Aux, Array.foldl_eq_foldl_data]
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
⊢ sublists'Aux a r₁ r₂ =
    Array.toList (Array.foldl (fun r l => Array.push r (a :: l)) (toArray r₂) (toArray r₁) 0 (Array.size (toArray r₁)))

tactic: have := List.foldl_hom Array.toList (fun r l => r.push (a :: l))
  (fun r l => r ++ [a :: l]) r₁ r₂.toArray (by simp)
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
⊢ foldl (fun r l => r ++ [a :: l]) r₂ r₁ =
    Array.toList (foldl (fun r l => Array.push r (a :: l)) (toArray r₂) (toArray r₁).data)

tactic: simpa using this
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
this :
  foldl (fun r l => r ++ [a :: l]) (Array.toList (toArray r₂)) r₁ =
    Array.toList (foldl (fun r l => Array.push r (a :: l)) (toArray r₂) r₁)
⊢ foldl (fun r l => r ++ [a :: l]) r₂ r₁ =
    Array.toList (foldl (fun r l => Array.push r (a :: l)) (toArray r₂) (toArray r₁).data)

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
⊢ ∀ (x : Array (List α)) (y : List α),
    (fun r l => r ++ [a :: l]) (Array.toList x) y = Array.toList ((fun r l => Array.push r (a :: l)) x y)
Theorem: Int.preimage_Ioc
File: Mathlib/Algebra/Order/Floor.lean

tactic: ext
state_before: F : Type ?u.240835
α : Type u_1
β : Type ?u.240841
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ Int.cast ⁻¹' Ioc a b = Ioc ⌊a⌋ ⌊b⌋

tactic: simp [floor_lt, le_floor]
state_before: case h
F : Type ?u.240835
α : Type u_1
β : Type ?u.240841
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
x✝ : ℤ
⊢ x✝ ∈ Int.cast ⁻¹' Ioc a b ↔ x✝ ∈ Ioc ⌊a⌋ ⌊b⌋
Theorem: inv_eq_one_divp
File: Mathlib/Algebra/Group/Units.lean

tactic: rw [one_divp]
state_before: α : Type u
inst✝ : Monoid α
a b c : α
u : αˣ
⊢ ↑u⁻¹ = 1 /ₚ u
Theorem: Asymptotics.IsBigOWith.eventually_mul_div_cancel
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simpa [hv] using hy
state_before: α : Type u_1
β : Type ?u.617198
E : Type ?u.617201
F : Type ?u.617204
G : Type ?u.617207
E' : Type ?u.617210
F' : Type ?u.617213
G' : Type ?u.617216
E'' : Type ?u.617219
F'' : Type ?u.617222
G'' : Type ?u.617225
R : Type ?u.617228
R' : Type ?u.617231
𝕜 : Type u_2
𝕜' : Type ?u.617237
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 α
u v : α → 𝕜
h : IsBigOWith c l u v
y : α
hy : ‖u y‖ ≤ c * ‖v y‖
hv : v y = 0
⊢ u y = 0
Theorem: aux2
File: Mathlib/Algebra/Jordan/Basic.lean

tactic: rw [(commute_lmul_lmul_sq a).lie_eq, (commute_lmul_lmul_sq b).lie_eq,
  (commute_lmul_lmul_sq c).lie_eq, zero_add, add_zero, add_zero]
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (a * a)⁆ + ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ +
          ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (b * b)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ +
            ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, ↑L (c * c)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆) =
    ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
          (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
        (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆)) +
      (2 • ⁅↑L a, ↑L (b * c)⁆ + 2 • ⁅↑L b, ↑L (c * a)⁆ + 2 • ⁅↑L c, ↑L (a * b)⁆)

tactic: simp only [lie_nsmul]
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + ⁅↑L a, 2 • ↑L (a * b)⁆ + ⁅↑L a, 2 • ↑L (c * a)⁆ + ⁅↑L a, 2 • ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (c * c)⁆ + ⁅↑L b, 2 • ↑L (a * b)⁆ + ⁅↑L b, 2 • ↑L (c * a)⁆ +
          ⁅↑L b, 2 • ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + ⁅↑L c, 2 • ↑L (a * b)⁆ + ⁅↑L c, 2 • ↑L (c * a)⁆ +
        ⁅↑L c, 2 • ↑L (b * c)⁆) =
    ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
          (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
        (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆)) +
      (2 • ⁅↑L a, ↑L (b * c)⁆ + 2 • ⁅↑L b, ↑L (c * a)⁆ + 2 • ⁅↑L c, ↑L (a * b)⁆)

tactic: abel
state_before: A : Type u_1
inst✝¹ : NonUnitalNonAssocRing A
inst✝ : IsCommJordan A
a b c : A
⊢ ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L a, ↑L (c * c)⁆ + 2 • ⁅↑L a, ↑L (a * b)⁆ + 2 • ⁅↑L a, ↑L (c * a)⁆ + 2 • ⁅↑L a, ↑L (b * c)⁆ +
        (⁅↑L b, ↑L (a * a)⁆ + ⁅↑L b, ↑L (c * c)⁆ + 2 • ⁅↑L b, ↑L (a * b)⁆ + 2 • ⁅↑L b, ↑L (c * a)⁆ +
          2 • ⁅↑L b, ↑L (b * c)⁆) +
      (⁅↑L c, ↑L (a * a)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • ⁅↑L c, ↑L (a * b)⁆ + 2 • ⁅↑L c, ↑L (c * a)⁆ +
        2 • ⁅↑L c, ↑L (b * c)⁆) =
    ⁅↑L a, ↑L (b * b)⁆ + ⁅↑L b, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (a * b)⁆ + ⁅↑L b, ↑L (a * b)⁆) +
          (⁅↑L a, ↑L (c * c)⁆ + ⁅↑L c, ↑L (a * a)⁆ + 2 • (⁅↑L a, ↑L (c * a)⁆ + ⁅↑L c, ↑L (c * a)⁆)) +
        (⁅↑L b, ↑L (c * c)⁆ + ⁅↑L c, ↑L (b * b)⁆ + 2 • (⁅↑L b, ↑L (b * c)⁆ + ⁅↑L c, ↑L (b * c)⁆)) +
      (2 • ⁅↑L a, ↑L (b * c)⁆ + 2 • ⁅↑L b, ↑L (c * a)⁆ + 2 • ⁅↑L c, ↑L (a * b)⁆)
Theorem: MeasureTheory.ProbabilityMeasure.tendsto_iff_forall_lintegral_tendsto
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: rw [tendsto_nhds_iff_toFiniteMeasure_tendsto_nhds]
state_before: Ω : Type u_2
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ Tendsto μs F (𝓝 μ) ↔ ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ∫⁻ (ω : Ω), ↑(↑f ω) ∂↑(μs i)) F (𝓝 (∫⁻ (ω : Ω), ↑(↑f ω) ∂↑μ))

tactic: exact FiniteMeasure.tendsto_iff_forall_lintegral_tendsto
state_before: Ω : Type u_2
inst✝² : MeasurableSpace Ω
inst✝¹ : TopologicalSpace Ω
inst✝ : OpensMeasurableSpace Ω
γ : Type u_1
F : Filter γ
μs : γ → ProbabilityMeasure Ω
μ : ProbabilityMeasure Ω
⊢ Tendsto (toFiniteMeasure ∘ μs) F (𝓝 (toFiniteMeasure μ)) ↔
    ∀ (f : Ω →ᵇ ℝ≥0), Tendsto (fun i => ∫⁻ (ω : Ω), ↑(↑f ω) ∂↑(μs i)) F (𝓝 (∫⁻ (ω : Ω), ↑(↑f ω) ∂↑μ))
Theorem: List.duplicate_iff_two_le_count
File: Mathlib/Data/List/Duplicate.lean

tactic: simp [duplicate_iff_sublist, le_count_iff_replicate_sublist]
state_before: α : Type u_1
l : List α
x : α
inst✝ : DecidableEq α
⊢ x ∈+ l ↔ 2 ≤ count x l
Theorem: Finset.weightedVSubOfPoint_vadd_eq_of_sum_eq_one
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: erw [weightedVSubOfPoint_apply, weightedVSubOfPoint_apply, ← @vsub_eq_zero_iff_eq V,
  vadd_vsub_assoc, vsub_vadd_eq_vsub_sub, ← add_sub_assoc, add_comm, add_sub_assoc, ←
  sum_sub_distrib]
state_before: k : Type u_1
V : Type u_4
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.38533
s₂ : Finset ι₂
w : ι → k
p : ι → P
h : ∑ i in s, w i = 1
b₁ b₂ : P
⊢ ↑(weightedVSubOfPoint s p b₁) w +ᵥ b₁ = ↑(weightedVSubOfPoint s p b₂) w +ᵥ b₂

tactic: rw [← sum_smul, h, one_smul, vsub_add_vsub_cancel, vsub_self]
state_before: k : Type u_1
V : Type u_4
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.38533
s₂ : Finset ι₂
w : ι → k
p : ι → P
h : ∑ i in s, w i = 1
b₁ b₂ : P
⊢ b₁ -ᵥ b₂ + ∑ x in s, w x • (b₂ -ᵥ b₁) = 0
Theorem: CategoryTheory.Abelian.IsEquivalence.exact_iff
File: Mathlib/CategoryTheory/Abelian/Exact.lean

tactic: simp only [exact_iff, ← F.map_eq_zero_iff, F.map_comp, Category.assoc, ←
  kernelComparison_comp_ι g F, ← π_comp_cokernelComparison f F]
state_before: C : Type u₁
inst✝⁴ : Category C
inst✝³ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
D : Type u₁
inst✝² : Category D
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : IsEquivalence F
⊢ Exact (F.map f) (F.map g) ↔ Exact f g

tactic: rw [IsIso.comp_left_eq_zero (kernelComparison g F), ← Category.assoc,
  IsIso.comp_right_eq_zero _ (cokernelComparison f F)]
state_before: C : Type u₁
inst✝⁴ : Category C
inst✝³ : Abelian C
X Y Z : C
f : X ⟶ Y
g : Y ⟶ Z
D : Type u₁
inst✝² : Category D
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : IsEquivalence F
⊢ F.map f ≫ F.map g = 0 ∧ kernel.ι (F.map g) ≫ cokernel.π (F.map f) = 0 ↔
    F.map f ≫ F.map g = 0 ∧
      kernelComparison g F ≫ kernel.ι (F.map g) ≫ cokernel.π (F.map f) ≫ cokernelComparison f F = 0
Theorem: map_isIntegral
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: obtain ⟨P, hP⟩ := hb
state_before: R : Type u_4
A : Type u_5
B✝ : Type ?u.113227
S : Type ?u.113230
inst✝¹⁴ : CommRing R
inst✝¹³ : CommRing A
inst✝¹² : CommRing B✝
inst✝¹¹ : CommRing S
inst✝¹⁰ : Algebra R A
inst✝⁹ : Algebra R B✝
f✝ : R →+* S
B : Type u_1
C : Type u_2
F : Type u_3
inst✝⁸ : Ring B
inst✝⁷ : Ring C
inst✝⁶ : Algebra R B
inst✝⁵ : Algebra A B
inst✝⁴ : Algebra R C
inst✝³ : IsScalarTower R A B
inst✝² : Algebra A C
inst✝¹ : IsScalarTower R A C
b : B
inst✝ : AlgHomClass F A B C
f : F
hb : IsIntegral R b
⊢ IsIntegral R (↑f b)

tactic: refine' ⟨P, hP.1, _⟩
state_before: case intro
R : Type u_4
A : Type u_5
B✝ : Type ?u.113227
S : Type ?u.113230
inst✝¹⁴ : CommRing R
inst✝¹³ : CommRing A
inst✝¹² : CommRing B✝
inst✝¹¹ : CommRing S
inst✝¹⁰ : Algebra R A
inst✝⁹ : Algebra R B✝
f✝ : R →+* S
B : Type u_1
C : Type u_2
F : Type u_3
inst✝⁸ : Ring B
inst✝⁷ : Ring C
inst✝⁶ : Algebra R B
inst✝⁵ : Algebra A B
inst✝⁴ : Algebra R C
inst✝³ : IsScalarTower R A B
inst✝² : Algebra A C
inst✝¹ : IsScalarTower R A C
b : B
inst✝ : AlgHomClass F A B C
f : F
P : R[X]
hP : Monic P ∧ eval₂ (algebraMap R B) b P = 0
⊢ IsIntegral R (↑f b)

tactic: rw [← aeval_def, show (aeval (f b)) P = (aeval (f b)) (P.map (algebraMap R A)) by simp,
  aeval_algHom_apply, aeval_map_algebraMap, aeval_def, hP.2, _root_.map_zero]
state_before: case intro
R : Type u_4
A : Type u_5
B✝ : Type ?u.113227
S : Type ?u.113230
inst✝¹⁴ : CommRing R
inst✝¹³ : CommRing A
inst✝¹² : CommRing B✝
inst✝¹¹ : CommRing S
inst✝¹⁰ : Algebra R A
inst✝⁹ : Algebra R B✝
f✝ : R →+* S
B : Type u_1
C : Type u_2
F : Type u_3
inst✝⁸ : Ring B
inst✝⁷ : Ring C
inst✝⁶ : Algebra R B
inst✝⁵ : Algebra A B
inst✝⁴ : Algebra R C
inst✝³ : IsScalarTower R A B
inst✝² : Algebra A C
inst✝¹ : IsScalarTower R A C
b : B
inst✝ : AlgHomClass F A B C
f : F
P : R[X]
hP : Monic P ∧ eval₂ (algebraMap R B) b P = 0
⊢ eval₂ (algebraMap R ((fun x => C) b)) (↑f b) P = 0

tactic: simp
state_before: R : Type u_4
A : Type u_5
B✝ : Type ?u.113227
S : Type ?u.113230
inst✝¹⁴ : CommRing R
inst✝¹³ : CommRing A
inst✝¹² : CommRing B✝
inst✝¹¹ : CommRing S
inst✝¹⁰ : Algebra R A
inst✝⁹ : Algebra R B✝
f✝ : R →+* S
B : Type u_1
C : Type u_2
F : Type u_3
inst✝⁸ : Ring B
inst✝⁷ : Ring C
inst✝⁶ : Algebra R B
inst✝⁵ : Algebra A B
inst✝⁴ : Algebra R C
inst✝³ : IsScalarTower R A B
inst✝² : Algebra A C
inst✝¹ : IsScalarTower R A C
b : B
inst✝ : AlgHomClass F A B C
f : F
P : R[X]
hP : Monic P ∧ eval₂ (algebraMap R B) b P = 0
⊢ ↑(aeval (↑f b)) P = ↑(aeval (↑f b)) (Polynomial.map (algebraMap R A) P)
Theorem: LieAlgebra.nilpotent_of_nilpotent_quotient
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: suffices LieModule.IsNilpotent R L (L ⧸ I) by
  exact LieModule.nilpotentOfNilpotentQuotient R L L h₁ this
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I : LieIdeal R L
h₁ : I ≤ center R L
h₂ : IsNilpotent R (L ⧸ I)
⊢ IsNilpotent R L

tactic: obtain ⟨k, hk⟩ := h₂
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I : LieIdeal R L
h₁ : I ≤ center R L
h₂ : IsNilpotent R (L ⧸ I)
⊢ LieModule.IsNilpotent R L (L ⧸ I)

tactic: use k
state_before: case mk.intro
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I : LieIdeal R L
h₁ : I ≤ center R L
k : ℕ
hk : lowerCentralSeries R (L ⧸ I) (L ⧸ I) k = ⊥
⊢ LieModule.IsNilpotent R L (L ⧸ I)

tactic: simp [← LieSubmodule.coe_toSubmodule_eq_iff, coe_lowerCentralSeries_ideal_quot_eq, hk]
state_before: case mk.intro
R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I : LieIdeal R L
h₁ : I ≤ center R L
k : ℕ
hk : lowerCentralSeries R (L ⧸ I) (L ⧸ I) k = ⊥
⊢ lowerCentralSeries R L (L ⧸ I) k = ⊥

tactic: exact LieModule.nilpotentOfNilpotentQuotient R L L h₁ this
state_before: R : Type u
L : Type v
L' : Type w
inst✝⁴ : CommRing R
inst✝³ : LieRing L
inst✝² : LieAlgebra R L
inst✝¹ : LieRing L'
inst✝ : LieAlgebra R L'
I : LieIdeal R L
h₁ : I ≤ center R L
h₂ : IsNilpotent R (L ⧸ I)
this : LieModule.IsNilpotent R L (L ⧸ I)
⊢ IsNilpotent R L
Theorem: AlgebraicTopology.DoldKan.MorphComponents.id_φ
File: Mathlib/AlgebraicTopology/DoldKan/Decomposition.lean

tactic: simp only [← P_add_Q_f (n + 1) (n + 1), φ]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ φ (id X n) = 𝟙 (X.obj [n + 1].op)

tactic: congr 1
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ HomologicalComplex.Hom.f PInfty (n + 1) ≫ (id X n).a +
      ∑ x : Fin (n + 1),
        HomologicalComplex.Hom.f (P ↑x) (n + 1) ≫
          SimplicialObject.δ X (Fin.succ (↑Fin.rev x)) ≫ b (id X n) (↑Fin.rev x) =
    HomologicalComplex.Hom.f (P (n + 1)) (n + 1) + HomologicalComplex.Hom.f (Q (n + 1)) (n + 1)

tactic: . exact Eq.trans (by congr ; simp) (decomposition_Q n (n + 1)).symm
state_before: case e_a
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ ∑ x : Fin (n + 1),
      HomologicalComplex.Hom.f (P ↑x) (n + 1) ≫ SimplicialObject.δ X (Fin.succ (↑Fin.rev x)) ≫ b (id X n) (↑Fin.rev x) =
    HomologicalComplex.Hom.f (Q (n + 1)) (n + 1)

tactic: simp only [id, PInfty_f, P_f_idem]
state_before: case e_a
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ HomologicalComplex.Hom.f PInfty (n + 1) ≫ (id X n).a = HomologicalComplex.Hom.f (P (n + 1)) (n + 1)

tactic: exact Eq.trans (by congr ; simp) (decomposition_Q n (n + 1)).symm
state_before: case e_a
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ ∑ x : Fin (n + 1),
      HomologicalComplex.Hom.f (P ↑x) (n + 1) ≫ SimplicialObject.δ X (Fin.succ (↑Fin.rev x)) ≫ b (id X n) (↑Fin.rev x) =
    HomologicalComplex.Hom.f (Q (n + 1)) (n + 1)

tactic: congr
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ ∑ x : Fin (n + 1),
      HomologicalComplex.Hom.f (P ↑x) (n + 1) ≫ SimplicialObject.δ X (Fin.succ (↑Fin.rev x)) ≫ b (id X n) (↑Fin.rev x) =
    ∑ i in Finset.filter (fun i => ↑i < n + 1) Finset.univ,
      HomologicalComplex.Hom.f (P ↑i) (n + 1) ≫
        SimplicialObject.δ X (Fin.succ (↑Fin.rev i)) ≫ SimplicialObject.σ X (↑Fin.rev i)

tactic: simp
state_before: case e_s
C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ Finset.univ = Finset.filter (fun i => ↑i < n + 1) Finset.univ
Theorem: toIocMod_zsmul_add'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [add_comm, toIocMod_add_zsmul', add_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIocMod hp (m • p + a) b = m • p + toIocMod hp a b
Theorem: Lists'.ofList_subset
File: Mathlib/SetTheory/Lists.lean

tactic: induction' l₁ with _ _ l₁_ih
state_before: α : Type u_1
l₁ l₂ : List (Lists α)
h : l₁ ⊆ l₂
⊢ ofList l₁ ⊆ ofList l₂

tactic: refine' Subset.cons (Lists.Equiv.refl _) _ (l₁_ih (List.subset_of_cons_subset h))
state_before: case cons
α : Type u_1
l₁ l₂ : List (Lists α)
h✝ : l₁ ⊆ l₂
head✝ : Lists α
tail✝ : List (Lists α)
l₁_ih : tail✝ ⊆ l₂ → ofList tail✝ ⊆ ofList l₂
h : head✝ :: tail✝ ⊆ l₂
⊢ ofList (head✝ :: tail✝) ⊆ ofList l₂

tactic: simp at h
state_before: case cons
α : Type u_1
l₁ l₂ : List (Lists α)
h✝ : l₁ ⊆ l₂
head✝ : Lists α
tail✝ : List (Lists α)
l₁_ih : tail✝ ⊆ l₂ → ofList tail✝ ⊆ ofList l₂
h : head✝ :: tail✝ ⊆ l₂
⊢ head✝ ∈ toList (ofList l₂)

tactic: simp [h]
state_before: case cons
α : Type u_1
l₁ l₂ : List (Lists α)
h✝ : l₁ ⊆ l₂
head✝ : Lists α
tail✝ : List (Lists α)
l₁_ih : tail✝ ⊆ l₂ → ofList tail✝ ⊆ ofList l₂
h : head✝ ∈ l₂ ∧ tail✝ ⊆ l₂
⊢ head✝ ∈ toList (ofList l₂)

tactic: exact Subset.nil
state_before: case nil
α : Type u_1
l₁ l₂ : List (Lists α)
h✝ : l₁ ⊆ l₂
h : [] ⊆ l₂
⊢ ofList [] ⊆ ofList l₂
Theorem: IsFractionRing.num_mul_den_eq_num_mul_den_iff_eq
File: Mathlib/RingTheory/Localization/NumDen.lean

tactic: simpa only [mk'_num_den] using mk'_eq_of_eq' (S := K) h
state_before: R : Type ?u.148388
inst✝⁹ : CommRing R
M : Submonoid R
S : Type ?u.148594
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type ?u.148848
inst✝⁶ : CommRing P
A : Type u_1
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x y : K
h : num A y * ↑(den A x) = num A x * ↑(den A y)
⊢ x = y

tactic: rw [h]
state_before: R : Type ?u.148388
inst✝⁹ : CommRing R
M : Submonoid R
S : Type ?u.148594
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type ?u.148848
inst✝⁶ : CommRing P
A : Type u_1
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_2
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x y : K
h : x = y
⊢ num A y * ↑(den A x) = num A x * ↑(den A y)
Theorem: String.Iterator.ValidFor.extract
File: Std/Data/String/Lemmas.lean

tactic: cases h₁.out
state_before: l m r : List Char
it₁ it₂ : Iterator
h₁ : ValidFor l (m ++ r) it₁
h₂ : ValidFor (List.reverse m ++ l) r it₂
⊢ Iterator.extract it₁ it₂ = { data := m }

tactic: cases h₂.out
state_before: case refl
l m r : List Char
it₂ : Iterator
h₂ : ValidFor (List.reverse m ++ l) r it₂
h₁ : ValidFor l (m ++ r) { s := { data := List.reverseAux l (m ++ r) }, i := { byteIdx := utf8Len l } }
⊢ Iterator.extract { s := { data := List.reverseAux l (m ++ r) }, i := { byteIdx := utf8Len l } } it₂ = { data := m }

tactic: simp [Iterator.extract, List.reverseAux_eq, Nat.not_lt.2 (Nat.le_add_left ..)]
state_before: case refl.refl
l m r : List Char
h₁ : ValidFor l (m ++ r) { s := { data := List.reverseAux l (m ++ r) }, i := { byteIdx := utf8Len l } }
h₂ :
  ValidFor (List.reverse m ++ l) r
    { s := { data := List.reverseAux (List.reverse m ++ l) r }, i := { byteIdx := utf8Len (List.reverse m ++ l) } }
⊢ Iterator.extract { s := { data := List.reverseAux l (m ++ r) }, i := { byteIdx := utf8Len l } }
      { s := { data := List.reverseAux (List.reverse m ++ l) r }, i := { byteIdx := utf8Len (List.reverse m ++ l) } } =
    { data := m }

tactic: simpa [Nat.add_comm] using extract_of_valid l.reverse m r
state_before: case refl.refl
l m r : List Char
h₁ : ValidFor l (m ++ r) { s := { data := List.reverseAux l (m ++ r) }, i := { byteIdx := utf8Len l } }
h₂ :
  ValidFor (List.reverse m ++ l) r
    { s := { data := List.reverseAux (List.reverse m ++ l) r }, i := { byteIdx := utf8Len (List.reverse m ++ l) } }
⊢ String.extract { data := List.reverse l ++ (m ++ r) } { byteIdx := utf8Len l } { byteIdx := utf8Len m + utf8Len l } =
    { data := m }
Theorem: beq_eq_false_iff_ne
File: Std/Classes/BEq.lean

tactic: rw [ne_eq, ← beq_iff_eq a b]
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
⊢ (a == b) = false ↔ a ≠ b

tactic: cases a == b <;> decide
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a b : α
⊢ (a == b) = false ↔ ¬(a == b) = true
Theorem: not_countable_complex
File: Mathlib/Data/Complex/Cardinality.lean

tactic: rw [← le_aleph0_iff_set_countable, not_le, mk_univ_complex]
state_before: ⊢ ¬Set.Countable Set.univ

tactic: apply cantor
state_before: ⊢ ℵ₀ < 𝔠
Theorem: Multiset.card_powerset
File: Mathlib/Data/Multiset/Powerset.lean

tactic: simp
state_before: α : Type u_1
s : Multiset α
⊢ ∀ (a : List α), ↑card (powerset (Quotient.mk (isSetoid α) a)) = 2 ^ ↑card (Quotient.mk (isSetoid α) a)