tasksource/leandojo huggingface dataset:
Theorem: Multiset.aestronglyMeasurable_prod'
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: rcases l with ⟨l⟩
state_before: α : Type u_1
β : Type ?u.316502
γ : Type ?u.316505
ι : Type ?u.316508
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f g : α → β
M : Type u_2
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l : Multiset (α → M)
hl : ∀ (f : α → M), f ∈ l → AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable (Multiset.prod l) μ

tactic: simpa using l.aestronglyMeasurable_prod' (by simpa using hl)
state_before: case mk
α : Type u_1
β : Type ?u.316502
γ : Type ?u.316505
ι : Type ?u.316508
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f g : α → β
M : Type u_2
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ (f : α → M), f ∈ Quot.mk Setoid.r l → AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable (Multiset.prod (Quot.mk Setoid.r l)) μ

tactic: simpa using hl
state_before: α : Type u_1
β : Type ?u.316502
γ : Type ?u.316505
ι : Type ?u.316508
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f g : α → β
M : Type u_2
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
l✝ : Multiset (α → M)
l : List (α → M)
hl : ∀ (f : α → M), f ∈ Quot.mk Setoid.r l → AEStronglyMeasurable f μ
⊢ ∀ (f : α → M), f ∈ l → AEStronglyMeasurable f μ
Theorem: EuclideanGeometry.angle_pos_of_angle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/RightAngle.lean

tactic: rw [angle, ← inner_eq_zero_iff_angle_eq_pi_div_two, real_inner_comm, ← neg_eq_zero, ←
  inner_neg_left, neg_vsub_eq_vsub_rev] at h
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : ∠ p₁ p₂ p₃ = π / 2
h0 : p₁ ≠ p₂ ∨ p₃ = p₂
⊢ 0 < ∠ p₂ p₃ p₁

tactic: rw [← @vsub_ne_zero V, eq_comm, ← @vsub_eq_zero_iff_eq V, or_comm] at h0
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
h0 : p₁ ≠ p₂ ∨ p₃ = p₂
⊢ 0 < ∠ p₂ p₃ p₁

tactic: rw [angle, ← vsub_add_vsub_cancel p₁ p₂ p₃, add_comm]
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
h0 : p₂ -ᵥ p₃ = 0 ∨ p₁ -ᵥ p₂ ≠ 0
⊢ 0 < ∠ p₂ p₃ p₁

tactic: exact angle_add_pos_of_inner_eq_zero h h0
state_before: V : Type u_1
P : Type u_2
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p₁ p₂ p₃ : P
h : inner (p₂ -ᵥ p₃) (p₁ -ᵥ p₂) = 0
h0 : p₂ -ᵥ p₃ = 0 ∨ p₁ -ᵥ p₂ ≠ 0
⊢ 0 < InnerProductGeometry.angle (p₂ -ᵥ p₃) (p₂ -ᵥ p₃ + (p₁ -ᵥ p₂))
Theorem: IsLocalizedModule.ringHom_ext
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: rw [← lift_unique S f (k.comp f) map_unit j h, lift_unique]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_4
M' : Type u_3
M'' : Type u_2
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
map_unit : ∀ (x : { x // x ∈ S }), IsUnit (↑(algebraMap R (Module.End R M'')) ↑x)
j k : M' →ₗ[R] M''
h : LinearMap.comp j f = LinearMap.comp k f
⊢ j = k

tactic: rfl
state_before: case hl
R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_4
M' : Type u_3
M'' : Type u_2
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
map_unit : ∀ (x : { x // x ∈ S }), IsUnit (↑(algebraMap R (Module.End R M'')) ↑x)
j k : M' →ₗ[R] M''
h : LinearMap.comp j f = LinearMap.comp k f
⊢ LinearMap.comp k f = LinearMap.comp k f
Theorem: List.pmap_next_eq_rotate_one
File: Mathlib/Data/List/Cycle.lean

tactic: apply List.ext_nthLe
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : Nodup l
⊢ pmap (next l) l (_ : ∀ (x : α), x ∈ l → x ∈ l) = rotate l 1

tactic: simp
state_before: case hl
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : Nodup l
⊢ length (pmap (next l) l (_ : ∀ (x : α), x ∈ l → x ∈ l)) = length (rotate l 1)

tactic: intros
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : Nodup l
⊢ ∀ (n : ℕ) (h₁ : n < length (pmap (next l) l (_ : ∀ (x : α), x ∈ l → x ∈ l))) (h₂ : n < length (rotate l 1)),
    nthLe (pmap (next l) l (_ : ∀ (x : α), x ∈ l → x ∈ l)) n h₁ = nthLe (rotate l 1) n h₂

tactic: rw [nthLe_pmap, nthLe_rotate, next_nthLe _ h]
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
l : List α
x : α
h : Nodup l
n✝ : ℕ
h₁✝ : n✝ < length (pmap (next l) l (_ : ∀ (x : α), x ∈ l → x ∈ l))
h₂✝ : n✝ < length (rotate l 1)
⊢ nthLe (pmap (next l) l (_ : ∀ (x : α), x ∈ l → x ∈ l)) n✝ h₁✝ = nthLe (rotate l 1) n✝ h₂✝
Theorem: Nat.squarefree_of_factorization_le_one
File: Mathlib/Data/Nat/Squarefree.lean

tactic: rw [squarefree_iff_nodup_factors hn, List.nodup_iff_count_le_one]
state_before: n : ℕ
hn : n ≠ 0
hn' : ∀ (p : ℕ), ↑(factorization n) p ≤ 1
⊢ Squarefree n

tactic: intro a
state_before: n : ℕ
hn : n ≠ 0
hn' : ∀ (p : ℕ), ↑(factorization n) p ≤ 1
⊢ ∀ (a : ℕ), List.count a (factors n) ≤ 1

tactic: rw [factors_count_eq]
state_before: n : ℕ
hn : n ≠ 0
hn' : ∀ (p : ℕ), ↑(factorization n) p ≤ 1
a : ℕ
⊢ List.count a (factors n) ≤ 1

tactic: apply hn'
state_before: n : ℕ
hn : n ≠ 0
hn' : ∀ (p : ℕ), ↑(factorization n) p ≤ 1
a : ℕ
⊢ ↑(factorization n) a ≤ 1
Theorem: Polynomial.natDegree_derivative_lt
File: Mathlib/Data/Polynomial/Derivative.lean

tactic: cases' eq_or_ne (derivative p) 0 with hp' hp'
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
hp : natDegree p ≠ 0
⊢ natDegree (↑derivative p) < natDegree p

tactic: rw [hp', Polynomial.natDegree_zero]
state_before: case inl
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
hp : natDegree p ≠ 0
hp' : ↑derivative p = 0
⊢ natDegree (↑derivative p) < natDegree p

tactic: exact hp.bot_lt
state_before: case inl
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
hp : natDegree p ≠ 0
hp' : ↑derivative p = 0
⊢ 0 < natDegree p

tactic: rw [natDegree_lt_natDegree_iff hp']
state_before: case inr
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
hp : natDegree p ≠ 0
hp' : ↑derivative p ≠ 0
⊢ natDegree (↑derivative p) < natDegree p

tactic: exact degree_derivative_lt fun h => hp (h.symm ▸ natDegree_zero)
state_before: case inr
R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Semiring R
p : R[X]
hp : natDegree p ≠ 0
hp' : ↑derivative p ≠ 0
⊢ degree (↑derivative p) < degree p
Theorem: CategoryTheory.NatTrans.leftDerived_comp
File: Mathlib/CategoryTheory/Functor/LeftDerived.lean

tactic: simp [NatTrans.leftDerived]
state_before: C : Type u
inst✝¹⁴ : Category C
D : Type u_2
inst✝¹³ : Category D
inst✝¹² : Preadditive C
inst✝¹¹ : HasZeroObject C
inst✝¹⁰ : HasEqualizers C
inst✝⁹ : HasImages C
inst✝⁸ : HasProjectiveResolutions C
inst✝⁷ : Preadditive D
inst✝⁶ : HasEqualizers D
inst✝⁵ : HasCokernels D
inst✝⁴ : HasImages D
inst✝³ : HasImageMaps D
F G H : C ⥤ D
inst✝² : Functor.Additive F
inst✝¹ : Functor.Additive G
inst✝ : Functor.Additive H
α : F ⟶ G
β : G ⟶ H
n : ℕ
⊢ leftDerived (α ≫ β) n = leftDerived α n ≫ leftDerived β n
Theorem: Filter.OrderIso.apply_blimsup
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp only [blimsup_eq, map_sInf, Function.comp_apply]
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
ι : Type ?u.142814
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
⊢ ↑e (blimsup u f p) = blimsup (↑e ∘ u) f p

tactic: congr
state_before: α : Type u_2
β : Type u_3
γ : Type u_1
ι : Type ?u.142814
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
⊢ sInf ((fun a => ↑e a) '' {a | ∀ᶠ (x : β) in f, p x → u x ≤ a}) = sInf {a | ∀ᶠ (x : β) in f, p x → ↑e (u x) ≤ a}

tactic: ext c
state_before: case e_a
α : Type u_2
β : Type u_3
γ : Type u_1
ι : Type ?u.142814
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
⊢ (fun a => ↑e a) '' {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} = {a | ∀ᶠ (x : β) in f, p x → ↑e (u x) ≤ a}

tactic: obtain ⟨a, rfl⟩ := e.surjective c
state_before: case e_a.h
α : Type u_2
β : Type u_3
γ : Type u_1
ι : Type ?u.142814
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
c : γ
⊢ c ∈ (fun a => ↑e a) '' {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} ↔ c ∈ {a | ∀ᶠ (x : β) in f, p x → ↑e (u x) ≤ a}

tactic: simp
state_before: case e_a.h.intro
α : Type u_2
β : Type u_3
γ : Type u_1
ι : Type ?u.142814
inst✝¹ : CompleteLattice α
f g : Filter β
p q : β → Prop
u v : β → α
inst✝ : CompleteLattice γ
e : α ≃o γ
a : α
⊢ ↑e a ∈ (fun a => ↑e a) '' {a | ∀ᶠ (x : β) in f, p x → u x ≤ a} ↔ ↑e a ∈ {a | ∀ᶠ (x : β) in f, p x → ↑e (u x) ≤ a}
Theorem: CategoryTheory.Subobject.inf_arrow_factors_left
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: simp
state_before: C : Type u₁
inst✝² : Category C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
B : C
X Y : Subobject B
⊢ ofLE (X ⊓ Y) X (_ : (inf.obj X).obj Y ≤ X) ≫ MonoOver.arrow (representative.obj X) = arrow (X ⊓ Y)
Theorem: vectorSpan_image_eq_span_vsub_set_left_ne
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: conv_lhs =>
  rw [vectorSpan_eq_span_vsub_set_left k (Set.mem_image_of_mem p hi), ← Set.insert_eq_of_mem hi, ←
    Set.insert_diff_singleton, Set.image_insert_eq, Set.image_insert_eq]
state_before: k : Type u_3
V : Type u_2
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_1
p : ι → P
s : Set ι
i : ι
hi : i ∈ s
⊢ vectorSpan k (p '' s) = Submodule.span k ((fun x x_1 => x -ᵥ x_1) (p i) '' (p '' (s \ {i})))

tactic: simp [Submodule.span_insert_eq_span]
state_before: k : Type u_3
V : Type u_2
P : Type u_4
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_1
p : ι → P
s : Set ι
i : ι
hi : i ∈ s
⊢ Submodule.span k (insert ((fun x x_1 => x -ᵥ x_1) (p i) (p i)) ((fun x x_1 => x -ᵥ x_1) (p i) '' (p '' (s \ {i})))) =
    Submodule.span k ((fun x x_1 => x -ᵥ x_1) (p i) '' (p '' (s \ {i})))
Theorem: ContinuousLinearMap.IsPositive.inner_nonneg_right
File: Mathlib/Analysis/InnerProductSpace/Positive.lean

tactic: rw [inner_re_symm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.43212
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace 𝕜 F
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
T : E →L[𝕜] E
hT : IsPositive T
x : E
⊢ 0 ≤ ↑re (inner x (↑T x))

tactic: exact hT.inner_nonneg_left x
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.43212
inst✝⁶ : IsROrC 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace 𝕜 E
inst✝² : InnerProductSpace 𝕜 F
inst✝¹ : CompleteSpace E
inst✝ : CompleteSpace F
T : E →L[𝕜] E
hT : IsPositive T
x : E
⊢ 0 ≤ ↑re (inner (↑T x) x)
Theorem: MeasureTheory.ite_ae_eq_of_measure_zero
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: have h_ss : sᶜ ⊆ { a : α | ite (a ∈ s) (f a) (g a) = g a } := fun x hx => by
  simp [(Set.mem_compl_iff _ _).mp hx]
state_before: α : Type u_2
β : Type ?u.717923
γ✝ : Type ?u.717926
δ : Type ?u.717929
ι : Type ?u.717932
R : Type ?u.717935
R' : Type ?u.717938
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ✝
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
γ : Type u_1
f g : α → γ
s : Set α
hs_zero : ↑↑μ s = 0
⊢ (fun x => if x ∈ s then f x else g x) =ᶠ[ae μ] g

tactic: refine' measure_mono_null _ hs_zero
state_before: α : Type u_2
β : Type ?u.717923
γ✝ : Type ?u.717926
δ : Type ?u.717929
ι : Type ?u.717932
R : Type ?u.717935
R' : Type ?u.717938
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ✝
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
γ : Type u_1
f g : α → γ
s : Set α
hs_zero : ↑↑μ s = 0
h_ss : sᶜ ⊆ {a | (if a ∈ s then f a else g a) = g a}
⊢ (fun x => if x ∈ s then f x else g x) =ᶠ[ae μ] g

tactic: conv_rhs => rw [← compl_compl s]
state_before: α : Type u_2
β : Type ?u.717923
γ✝ : Type ?u.717926
δ : Type ?u.717929
ι : Type ?u.717932
R : Type ?u.717935
R' : Type ?u.717938
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ✝
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
γ : Type u_1
f g : α → γ
s : Set α
hs_zero : ↑↑μ s = 0
h_ss : sᶜ ⊆ {a | (if a ∈ s then f a else g a) = g a}
⊢ {x | (fun x => (fun x => if x ∈ s then f x else g x) x = g x) x}ᶜ ⊆ s

tactic: rwa [Set.compl_subset_compl]
state_before: α : Type u_2
β : Type ?u.717923
γ✝ : Type ?u.717926
δ : Type ?u.717929
ι : Type ?u.717932
R : Type ?u.717935
R' : Type ?u.717938
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ✝
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
γ : Type u_1
f g : α → γ
s : Set α
hs_zero : ↑↑μ s = 0
h_ss : sᶜ ⊆ {a | (if a ∈ s then f a else g a) = g a}
⊢ {x | (fun x => (fun x => if x ∈ s then f x else g x) x = g x) x}ᶜ ⊆ sᶜᶜ

tactic: simp [(Set.mem_compl_iff _ _).mp hx]
state_before: α : Type u_2
β : Type ?u.717923
γ✝ : Type ?u.717926
δ : Type ?u.717929
ι : Type ?u.717932
R : Type ?u.717935
R' : Type ?u.717938
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ✝
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
γ : Type u_1
f g : α → γ
s : Set α
hs_zero : ↑↑μ s = 0
x : α
hx : x ∈ sᶜ
⊢ x ∈ {a | (if a ∈ s then f a else g a) = g a}
Theorem: AffineSubspace.comap_span
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

tactic: rw [← map_symm, map_span, AffineEquiv.coe_coe, f.image_symm]
state_before: k : Type u_1
V₁ : Type u_4
P₁ : Type u_2
V₂ : Type u_5
P₂ : Type u_3
V₃ : Type ?u.642758
P₃ : Type ?u.642761
inst✝⁹ : Ring k
inst✝⁸ : AddCommGroup V₁
inst✝⁷ : Module k V₁
inst✝⁶ : AffineSpace V₁ P₁
inst✝⁵ : AddCommGroup V₂
inst✝⁴ : Module k V₂
inst✝³ : AffineSpace V₂ P₂
inst✝² : AddCommGroup V₃
inst✝¹ : Module k V₃
inst✝ : AffineSpace V₃ P₃
f : P₁ ≃ᵃ[k] P₂
s : Set P₂
⊢ comap (↑f) (affineSpan k s) = affineSpan k (↑f ⁻¹' s)
Theorem: Nat.beq_refl
File: src/lean/Init/Data/Nat/Basic.lean

tactic: induction a with simp [Nat.beq]
| succ a ih => simp [ih]
state_before: a : Nat
⊢ beq a a = true

tactic: simp [ih]
state_before: case succ
a : Nat
ih : beq a a = true
⊢ beq a a = true
Theorem: nilpotencyClass_pi
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: apply eq_of_forall_ge_iff
state_before: G : Type ?u.351081
inst✝⁴ : Group G
H : Subgroup G
inst✝³ : Normal H
η : Type u_1
Gs : η → Type u_2
inst✝² : (i : η) → Group (Gs i)
inst✝¹ : Fintype η
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
⊢ nilpotencyClass ((i : η) → Gs i) = Finset.sup Finset.univ fun i => nilpotencyClass (Gs i)

tactic: intro k
state_before: case H
G : Type ?u.351081
inst✝⁴ : Group G
H : Subgroup G
inst✝³ : Normal H
η : Type u_1
Gs : η → Type u_2
inst✝² : (i : η) → Group (Gs i)
inst✝¹ : Fintype η
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
⊢ ∀ (c : ℕ), nilpotencyClass ((i : η) → Gs i) ≤ c ↔ (Finset.sup Finset.univ fun i => nilpotencyClass (Gs i)) ≤ c

tactic: simp only [Finset.sup_le_iff, ← lowerCentralSeries_eq_bot_iff_nilpotencyClass_le,
  lowerCentralSeries_pi_of_finite, pi_eq_bot_iff, Finset.mem_univ, true_imp_iff]
state_before: case H
G : Type ?u.351081
inst✝⁴ : Group G
H : Subgroup G
inst✝³ : Normal H
η : Type u_1
Gs : η → Type u_2
inst✝² : (i : η) → Group (Gs i)
inst✝¹ : Fintype η
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
k : ℕ
⊢ nilpotencyClass ((i : η) → Gs i) ≤ k ↔ (Finset.sup Finset.univ fun i => nilpotencyClass (Gs i)) ≤ k
Theorem: lipschitzWith_iff_norm_div_le
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp only [lipschitzWith_iff_dist_le_mul, dist_eq_norm_div]
state_before: 𝓕 : Type ?u.194419
𝕜 : Type ?u.194422
α : Type ?u.194425
ι : Type ?u.194428
κ : Type ?u.194431
E : Type u_1
F : Type u_2
G : Type ?u.194440
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
f : E → F
C : ℝ≥0
⊢ LipschitzWith C f ↔ ∀ (x y : E), ‖f x / f y‖ ≤ ↑C * ‖x / y‖
Theorem: frontier_univ
File: Mathlib/Topology/Basic.lean

tactic: simp [frontier]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
⊢ frontier univ = ∅
Theorem: Real.Angle.two_zsmul_eq_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: have : Int.natAbs 2 = 2 := rfl
state_before: ψ θ : Angle
⊢ 2 • ψ = 2 • θ ↔ ψ = θ ∨ ψ = θ + ↑π

tactic: rw [zsmul_eq_iff two_ne_zero, this, Fin.exists_fin_two, Fin.val_zero,
  Fin.val_one, zero_smul, coe_zero, add_zero, one_smul, Int.cast_two,
  mul_div_cancel_left (_ : ℝ) two_ne_zero]
state_before: ψ θ : Angle
this : Int.natAbs 2 = 2
⊢ 2 • ψ = 2 • θ ↔ ψ = θ ∨ ψ = θ + ↑π
Theorem: Finset.prod_range_div'
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: apply prod_range_induction <;> simp
state_before: ι : Type ?u.619182
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
M : Type u_1
inst✝ : CommGroup M
f : ℕ → M
n : ℕ
⊢ ∏ i in range n, f i / f (i + 1) = f 0 / f n
Theorem: Set.disjoint_right
File: Mathlib/Data/Set/Basic.lean

tactic: rw [disjoint_comm, disjoint_left]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ Disjoint s t ↔ ∀ ⦃a : α⦄, a ∈ t → ¬a ∈ s
Theorem: pi_eq_generateFrom
File: Mathlib/Topology/Constructions.lean

tactic: simp only [generateFrom_setOf_isOpen]
state_before: α : Type u
β : Type v
γ : Type ?u.372393
δ : Type ?u.372396
ε : Type ?u.372399
ζ : Type ?u.372402
ι : Type u_2
π : ι → Type u_1
κ : Type ?u.372413
inst✝¹ : TopologicalSpace α
inst✝ : (i : ι) → TopologicalSpace (π i)
f : α → (i : ι) → π i
⊢ Pi.topologicalSpace = Pi.topologicalSpace
Theorem: Filter.tendsto_const_mul_atBot_iff_neg
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: simp [tendsto_const_mul_atBot_iff, h, h.not_tendsto disjoint_atTop_atBot]
state_before: ι : Type ?u.244706
ι' : Type ?u.244709
α : Type u_2
β : Type u_1
γ : Type ?u.244718
inst✝¹ : LinearOrderedField α
l : Filter β
f : β → α
r : α
inst✝ : NeBot l
h : Tendsto f l atTop
⊢ Tendsto (fun x => r * f x) l atBot ↔ r < 0
Theorem: Complex.exp_ofReal_im
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_exp_ofReal_re, ofReal_im]
state_before: x✝ y : ℂ
x : ℝ
⊢ (exp ↑x).im = 0
Theorem: EMetric.diam_closure
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: refine' le_antisymm (diam_le fun x hx y hy => _) (diam_mono subset_closure)
state_before: α : Type u_1
β : Type ?u.430325
γ : Type ?u.430328
inst✝ : PseudoEMetricSpace α
s : Set α
⊢ diam (closure s) = diam s

tactic: have : edist x y ∈ closure (Iic (diam s)) :=
  map_mem_closure₂ continuous_edist hx hy fun x hx y hy => edist_le_diam_of_mem hx hy
state_before: α : Type u_1
β : Type ?u.430325
γ : Type ?u.430328
inst✝ : PseudoEMetricSpace α
s : Set α
x : α
hx : x ∈ closure s
y : α
hy : y ∈ closure s
⊢ edist x y ≤ diam s

tactic: rwa [closure_Iic] at this
state_before: α : Type u_1
β : Type ?u.430325
γ : Type ?u.430328
inst✝ : PseudoEMetricSpace α
s : Set α
x : α
hx : x ∈ closure s
y : α
hy : y ∈ closure s
this : edist x y ∈ closure (Iic (diam s))
⊢ edist x y ≤ diam s
Theorem: Mathlib.Tactic.Ring.add_pf_zero_add
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
b : R
⊢ 0 + b = b
Theorem: Matrix.one_hadamard
File: Mathlib/Data/Matrix/Hadamard.lean

tactic: ext i j
state_before: α : Type u_1
β : Type ?u.20614
γ : Type ?u.20617
m : Type ?u.20620
n : Type u_2
R : Type ?u.20626
A B C : Matrix m n α
inst✝¹ : DecidableEq n
inst✝ : MulZeroOneClass α
M : Matrix n n α
⊢ 1 ⊙ M = diagonal fun i => M i i

tactic: by_cases h : i = j <;> simp [h]
state_before: case a.h
α : Type u_1
β : Type ?u.20614
γ : Type ?u.20617
m : Type ?u.20620
n : Type u_2
R : Type ?u.20626
A B C : Matrix m n α
inst✝¹ : DecidableEq n
inst✝ : MulZeroOneClass α
M : Matrix n n α
i j : n
⊢ (1 ⊙ M) i j = diagonal (fun i => M i i) i j
Theorem: Set.preimage_mul_const_Ioo_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ioi_inter_Iio, h, inter_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : c < 0
⊢ (fun x => x * c) ⁻¹' Ioo a b = Ioo (b / c) (a / c)
Theorem: le_nhds_iff
File: Mathlib/Topology/Basic.lean

tactic: simp [nhds_def]
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
f : Filter α
a : α
⊢ f ≤ 𝓝 a ↔ ∀ (s : Set α), a ∈ s → IsOpen s → s ∈ f
Theorem: Multiset.disjoint_ndinsert_right
File: Mathlib/Data/Multiset/FinsetOps.lean

tactic: rw [disjoint_comm, disjoint_ndinsert_left]
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s t : Multiset α
⊢ Disjoint s (ndinsert a t) ↔ ¬a ∈ s ∧ Disjoint s t

tactic: tauto
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s t : Multiset α
⊢ ¬a ∈ s ∧ Disjoint t s ↔ ¬a ∈ s ∧ Disjoint s t
Theorem: Multiset.aestronglyMeasurable_prod
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: simpa only [← Pi.multiset_prod_apply] using s.aestronglyMeasurable_prod' hs
state_before: α : Type u_1
β : Type ?u.327416
γ : Type ?u.327419
ι : Type ?u.327422
inst✝⁵ : Countable ι
m : MeasurableSpace α
μ : Measure α
inst✝⁴ : TopologicalSpace β
inst✝³ : TopologicalSpace γ
f g : α → β
M : Type u_2
inst✝² : CommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : ContinuousMul M
s : Multiset (α → M)
hs : ∀ (f : α → M), f ∈ s → AEStronglyMeasurable f μ
⊢ AEStronglyMeasurable (fun x => Multiset.prod (Multiset.map (fun f => f x) s)) μ
Theorem: Submodule.mem_orthogonal_singleton_iff_inner_left
File: Mathlib/Analysis/InnerProductSpace/Orthogonal.lean

tactic: rw [mem_orthogonal_singleton_iff_inner_right, inner_eq_zero_symm]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.29619
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace 𝕜 F
K : Submodule 𝕜 E
u v : E
⊢ v ∈ (span 𝕜 {u})ᗮ ↔ inner v u = 0
Theorem: FreeProduct.Word.fstIdx_ne_iff
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: simp [fstIdx]
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.373127
inst✝ : Monoid N
w : Word M
i : ι
⊢ ¬fstIdx w ≠ some i ↔ ¬∀ (l : (i : ι) × M i), l ∈ List.head? w.toList → i ≠ l.fst
Theorem: Nat.lt_of_sub_eq_succ
File: Std/Data/Nat/Lemmas.lean

tactic: simp [Nat.sub_eq_zero_of_le H'] at H
state_before: m n l : Nat
H : m - n = succ l
H' : m ≤ n
⊢ False