tasksource/leandojo huggingface dataset:
Theorem: List.formPerm_apply_of_not_mem
File: Mathlib/GroupTheory/Perm/List.lean

tactic: cases' l with y l
state_before: α : Type u_1
β : Type ?u.3357
inst✝ : DecidableEq α
l✝ : List α
x✝ x : α
l : List α
h : ¬x ∈ l
⊢ ↑(formPerm l) x = x

tactic: induction' l with z l IH generalizing x y
state_before: case cons
α : Type u_1
β : Type ?u.3357
inst✝ : DecidableEq α
l✝ : List α
x✝ x y : α
l : List α
h : ¬x ∈ y :: l
⊢ ↑(formPerm (y :: l)) x = x

tactic: simp
state_before: case nil
α : Type u_1
β : Type ?u.3357
inst✝ : DecidableEq α
l : List α
x✝ x : α
h : ¬x ∈ []
⊢ ↑(formPerm []) x = x

tactic: simp
state_before: case cons.nil
α : Type u_1
β : Type ?u.3357
inst✝ : DecidableEq α
l✝ : List α
x✝¹ x✝ y✝ : α
l : List α
h✝ : ¬x✝ ∈ y✝ :: l
x y : α
h : ¬x ∈ [y]
⊢ ↑(formPerm [y]) x = x

tactic: specialize IH x z (mt (mem_cons_of_mem y) h)
state_before: case cons.cons
α : Type u_1
β : Type ?u.3357
inst✝ : DecidableEq α
l✝¹ : List α
x✝¹ x✝ y✝ : α
l✝ : List α
h✝ : ¬x✝ ∈ y✝ :: l✝
z : α
l : List α
IH : ∀ (x y : α), ¬x ∈ y :: l → ↑(formPerm (y :: l)) x = x
x y : α
h : ¬x ∈ y :: z :: l
⊢ ↑(formPerm (y :: z :: l)) x = x

tactic: simp only [not_or, mem_cons] at h
state_before: case cons.cons
α : Type u_1
β : Type ?u.3357
inst✝ : DecidableEq α
l✝¹ : List α
x✝¹ x✝ y✝ : α
l✝ : List α
h✝ : ¬x✝ ∈ y✝ :: l✝
z : α
l : List α
x y : α
h : ¬x ∈ y :: z :: l
IH : ↑(formPerm (z :: l)) x = x
⊢ ↑(formPerm (y :: z :: l)) x = x

tactic: simp [IH, swap_apply_of_ne_of_ne, h]
state_before: case cons.cons
α : Type u_1
β : Type ?u.3357
inst✝ : DecidableEq α
l✝¹ : List α
x✝¹ x✝ y✝ : α
l✝ : List α
h✝ : ¬x✝ ∈ y✝ :: l✝
z : α
l : List α
x y : α
IH : ↑(formPerm (z :: l)) x = x
h : ¬x = y ∧ ¬x = z ∧ ¬x ∈ l
⊢ ↑(formPerm (y :: z :: l)) x = x
Theorem: SModEq.sub_mem
File: Mathlib/LinearAlgebra/SModEq.lean

tactic: rw [SModEq.def, Submodule.Quotient.eq]
state_before: R : Type u_1
inst✝⁴ : Ring R
M : Type u_2
inst✝³ : AddCommGroup M
inst✝² : Module R M
U U₁ U₂ : Submodule R M
x x₁ x₂ y y₁ y₂ z z₁ z₂ : M
N : Type ?u.30171
inst✝¹ : AddCommGroup N
inst✝ : Module R N
V V₁ V₂ : Submodule R N
⊢ x ≡ y [SMOD U] ↔ x - y ∈ U
Theorem: Nat.lcm_comm
File: Std/Data/Nat/Gcd.lean

tactic: rw [lcm, lcm, Nat.mul_comm n m, gcd_comm n m]
state_before: m n : Nat
⊢ lcm m n = lcm n m
Theorem: CompleteLattice.independent_def'
File: Mathlib/Order/SupIndep.lean

tactic: simp_rw [sSup_image]
state_before: α : Type u_2
β : Type ?u.36290
ι : Type u_1
ι' : Type ?u.36296
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
⊢ Independent t ↔ ∀ (i : ι), Disjoint (t i) (sSup (t '' {j | j ≠ i}))

tactic: rfl
state_before: α : Type u_2
β : Type ?u.36290
ι : Type u_1
ι' : Type ?u.36296
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
⊢ Independent t ↔ ∀ (i : ι), Disjoint (t i) (⨆ (a : ι) (_ : a ∈ {j | j ≠ i}), t a)
Theorem: inf_mul_sup
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: rw [mul_sup b⁻¹ a⁻¹ (a * b), mul_inv_cancel_right, mul_inv_cancel_comm]
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ (a ⊓ b) * (a ⊔ b) = (a ⊓ b) * (a * b * (b⁻¹ ⊔ a⁻¹))

tactic: rw [inv_inf_eq_sup_inv, sup_comm]
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ (a ⊓ b) * (a * b * (b⁻¹ ⊔ a⁻¹)) = (a ⊓ b) * (a * b * (a ⊓ b)⁻¹)

tactic: rw [mul_comm, inv_mul_cancel_right]
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b : α
⊢ (a ⊓ b) * (a * b * (a ⊓ b)⁻¹) = a * b
Theorem: Path.refl_range
File: Mathlib/Topology/PathConnected.lean

tactic: simp [Path.refl, CoeFun.coe]
state_before: X : Type u_1
Y : Type ?u.52075
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type ?u.52090
γ : Path x y
a : X
⊢ range ↑(refl a) = {a}
Theorem: List.sublistsAux_eq_array_foldl
File: Mathlib/Data/List/Sublists.lean

tactic: funext a r
state_before: α : Type u
β : Type v
γ : Type w
⊢ sublistsAux = fun a r =>
    Array.toList
      (Array.foldl (fun r l => Array.push (Array.push r l) (a :: l)) #[] (toArray r) 0 (Array.size (toArray r)))

tactic: simp only [sublistsAux, Array.foldl_eq_foldl_data, Array.mkEmpty]
state_before: case h.h
α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
⊢ sublistsAux a r =
    Array.toList
      (Array.foldl (fun r l => Array.push (Array.push r l) (a :: l)) #[] (toArray r) 0 (Array.size (toArray r)))

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

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

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
a : α
r : List (List α)
⊢ ∀ (x : Array (List α)) (y : List α),
    (fun r l => r ++ [l, a :: l]) (Array.toList x) y =
      Array.toList ((fun r l => Array.push (Array.push r l) (a :: l)) x y)
Theorem: LieEquiv.nilpotent_iff_equiv_nilpotent
File: Mathlib/Algebra/Lie/Nilpotent.lean

tactic: constructor <;> intro 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'
e : L ≃ₗ⁅R⁆ L'
⊢ LieAlgebra.IsNilpotent R L ↔ LieAlgebra.IsNilpotent R L'

tactic: exact e.symm.injective.lieAlgebra_isNilpotent
state_before: case mp
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'
e : L ≃ₗ⁅R⁆ L'
h : LieAlgebra.IsNilpotent R L
⊢ LieAlgebra.IsNilpotent R L'

tactic: exact e.injective.lieAlgebra_isNilpotent
state_before: case mpr
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'
e : L ≃ₗ⁅R⁆ L'
h : LieAlgebra.IsNilpotent R L'
⊢ LieAlgebra.IsNilpotent R L
Theorem: Polynomial.Chebyshev.U_complex_cos
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean

tactic: induction' n with d hd
state_before: R : Type ?u.109021
A : Type ?u.109024
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
n : ℕ
⊢ eval (cos θ) (U ℂ n) * sin θ = sin ((↑n + 1) * θ)

tactic: simp [U_zero, eval_one, zero_add, one_mul, Nat.zero_eq, CharP.cast_eq_zero]
state_before: case zero
R : Type ?u.109021
A : Type ?u.109024
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
⊢ eval (cos θ) (U ℂ Nat.zero) * sin θ = sin ((↑Nat.zero + 1) * θ)

tactic: rw [U_eq_X_mul_U_add_T]
state_before: case succ
R : Type ?u.109021
A : Type ?u.109024
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
d : ℕ
hd : eval (cos θ) (U ℂ d) * sin θ = sin ((↑d + 1) * θ)
⊢ eval (cos θ) (U ℂ (Nat.succ d)) * sin θ = sin ((↑(Nat.succ d) + 1) * θ)

tactic: simp only [eval_add, eval_mul, eval_X, T_complex_cos, add_mul, mul_assoc, hd, one_mul]
state_before: case succ
R : Type ?u.109021
A : Type ?u.109024
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
d : ℕ
hd : eval (cos θ) (U ℂ d) * sin θ = sin ((↑d + 1) * θ)
⊢ eval (cos θ) (X * U ℂ d + T ℂ (d + 1)) * sin θ = sin ((↑(Nat.succ d) + 1) * θ)

tactic: trans cos θ * sin (↑(d.succ) * θ) + cos (↑(d.succ) * θ) * sin θ
state_before: case succ
R : Type ?u.109021
A : Type ?u.109024
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
d : ℕ
hd : eval (cos θ) (U ℂ d) * sin θ = sin ((↑d + 1) * θ)
⊢ cos θ * sin (↑d * θ + θ) + cos (↑(d + 1) * θ) * sin θ = sin (↑(Nat.succ d) * θ + θ)

tactic: swap
state_before: R : Type ?u.109021
A : Type ?u.109024
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
d : ℕ
hd : eval (cos θ) (U ℂ d) * sin θ = sin ((↑d + 1) * θ)
⊢ cos θ * sin (↑d * θ + θ) + cos (↑(d + 1) * θ) * sin θ =
    cos θ * sin (↑(Nat.succ d) * θ) + cos (↑(Nat.succ d) * θ) * sin θ

R : Type ?u.109021
A : Type ?u.109024
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
d : ℕ
hd : eval (cos θ) (U ℂ d) * sin θ = sin ((↑d + 1) * θ)
⊢ cos θ * sin (↑(Nat.succ d) * θ) + cos (↑(Nat.succ d) * θ) * sin θ = sin (↑(Nat.succ d) * θ + θ)

tactic: push_cast
state_before: R : Type ?u.109021
A : Type ?u.109024
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
d : ℕ
hd : eval (cos θ) (U ℂ d) * sin θ = sin ((↑d + 1) * θ)
⊢ cos θ * sin (↑d * θ + θ) + cos (↑(d + 1) * θ) * sin θ =
    cos θ * sin (↑(Nat.succ d) * θ) + cos (↑(Nat.succ d) * θ) * sin θ

tactic: simp only [add_mul, one_mul]
state_before: R : Type ?u.109021
A : Type ?u.109024
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
d : ℕ
hd : eval (cos θ) (U ℂ d) * sin θ = sin ((↑d + 1) * θ)
⊢ cos θ * sin (↑d * θ + θ) + cos ((↑d + 1) * θ) * sin θ = cos θ * sin ((↑d + 1) * θ) + cos ((↑d + 1) * θ) * sin θ

tactic: conv_rhs => rw [sin_add, mul_comm]
state_before: R : Type ?u.109021
A : Type ?u.109024
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Algebra R A
θ : ℂ
d : ℕ
hd : eval (cos θ) (U ℂ d) * sin θ = sin ((↑d + 1) * θ)
⊢ cos θ * sin (↑(Nat.succ d) * θ) + cos (↑(Nat.succ d) * θ) * sin θ = sin (↑(Nat.succ d) * θ + θ)
Theorem: List.of_mem_dlookup
File: Mathlib/Data/List/Sigma.lean

tactic: by_cases h : a = a'
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a' : α
b' : β a'
l : List (Sigma β)
H : b ∈ dlookup a ({ fst := a', snd := b' } :: l)
⊢ { fst := a, snd := b } ∈ { fst := a', snd := b' } :: l

tactic: subst a'
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a' : α
b' : β a'
l : List (Sigma β)
H : b ∈ dlookup a ({ fst := a', snd := b' } :: l)
h : a = a'
⊢ { fst := a, snd := b } ∈ { fst := a', snd := b' } :: l

tactic: simp at H
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l : List (Sigma β)
b' : β a
H : b ∈ dlookup a ({ fst := a, snd := b' } :: l)
⊢ { fst := a, snd := b } ∈ { fst := a, snd := b' } :: l

tactic: simp [H]
state_before: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
l : List (Sigma β)
b' : β a
H : b' = b
⊢ { fst := a, snd := b } ∈ { fst := a, snd := b' } :: l

tactic: simp only [ne_eq, h, not_false_iff, dlookup_cons_ne] at H
state_before: case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a' : α
b' : β a'
l : List (Sigma β)
H : b ∈ dlookup a ({ fst := a', snd := b' } :: l)
h : ¬a = a'
⊢ { fst := a, snd := b } ∈ { fst := a', snd := b' } :: l

tactic: simp [of_mem_dlookup H]
state_before: case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
b : β a
a' : α
b' : β a'
l : List (Sigma β)
h : ¬a = a'
H : b ∈ dlookup a l
⊢ { fst := a, snd := b } ∈ { fst := a', snd := b' } :: l
Theorem: MeasurableEmbedding.memℒp_map_measure_iff
File: Mathlib/MeasureTheory/Function/LpSeminorm.lean

tactic: simp_rw [Memℒp, hf.aestronglyMeasurable_map_iff, hf.snorm_map_measure]
state_before: α : Type u_1
E : Type ?u.3104037
F : Type u_3
G : Type ?u.3104043
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
β : Type u_2
mβ : MeasurableSpace β
f : α → β
g✝ : β → E
g : β → F
hf : MeasurableEmbedding f
⊢ Memℒp g p ↔ Memℒp (g ∘ f) p
Theorem: AddCircle.norm_half_period_eq
File: Mathlib/Analysis/Normed/Group/AddCircle.lean

tactic: rcases eq_or_ne p 0 with (rfl | hp)
state_before: p : ℝ
⊢ ‖↑(p / 2)‖ = abs p / 2

tactic: rw [norm_eq, ← mul_div_assoc, inv_mul_cancel hp, one_div, round_two_inv, Int.cast_one,
  one_mul, (by linarith : p / 2 - p = -(p / 2)), abs_neg, abs_div, abs_two]
state_before: case inr
p : ℝ
hp : p ≠ 0
⊢ ‖↑(p / 2)‖ = abs p / 2

tactic: simp
state_before: case inl

⊢ ‖↑(0 / 2)‖ = abs 0 / 2

tactic: linarith
state_before: p : ℝ
hp : p ≠ 0
⊢ p / 2 - p = -(p / 2)
Theorem: NNReal.hasSum_lt
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: have A : ∀ a : α, (f a : ℝ) ≤ g a := fun a => NNReal.coe_le_coe.2 (h a)
state_before: α : Type u_1
β : Type ?u.326725
γ : Type ?u.326728
f g : α → ℝ≥0
sf sg : ℝ≥0
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hf : HasSum f sf
hg : HasSum g sg
⊢ sf < sg

tactic: have : (sf : ℝ) < sg := hasSum_lt A (NNReal.coe_lt_coe.2 hi) (hasSum_coe.2 hf) (hasSum_coe.2 hg)
state_before: α : Type u_1
β : Type ?u.326725
γ : Type ?u.326728
f g : α → ℝ≥0
sf sg : ℝ≥0
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hf : HasSum f sf
hg : HasSum g sg
A : ∀ (a : α), ↑(f a) ≤ ↑(g a)
⊢ sf < sg

tactic: exact NNReal.coe_lt_coe.1 this
state_before: α : Type u_1
β : Type ?u.326725
γ : Type ?u.326728
f g : α → ℝ≥0
sf sg : ℝ≥0
i : α
h : ∀ (a : α), f a ≤ g a
hi : f i < g i
hf : HasSum f sf
hg : HasSum g sg
A : ∀ (a : α), ↑(f a) ≤ ↑(g a)
this : ↑sf < ↑sg
⊢ sf < sg
Theorem: AffineSubspace.WSameSide.not_sOppSide
File: Mathlib/Analysis/Convex/Side.lean

tactic: intro ho
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.320253
P : Type u_3
P' : Type ?u.320259
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
h : WSameSide s x y
⊢ ¬SOppSide s x y

tactic: have hxy := wSameSide_and_wOppSide_iff.1 ⟨h, ho.1⟩
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.320253
P : Type u_3
P' : Type ?u.320259
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
h : WSameSide s x y
ho : SOppSide s x y
⊢ False

tactic: rcases hxy with (hx | hy)
state_before: R : Type u_1
V : Type u_2
V' : Type ?u.320253
P : Type u_3
P' : Type ?u.320259
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
h : WSameSide s x y
ho : SOppSide s x y
hxy : x ∈ s ∨ y ∈ s
⊢ False

tactic: exact ho.2.1 hx
state_before: case inl
R : Type u_1
V : Type u_2
V' : Type ?u.320253
P : Type u_3
P' : Type ?u.320259
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
h : WSameSide s x y
ho : SOppSide s x y
hx : x ∈ s
⊢ False

tactic: exact ho.2.2 hy
state_before: case inr
R : Type u_1
V : Type u_2
V' : Type ?u.320253
P : Type u_3
P' : Type ?u.320259
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
h : WSameSide s x y
ho : SOppSide s x y
hy : y ∈ s
⊢ False
Theorem: directedOn_range
File: Mathlib/Order/Directed.lean

tactic: simp_rw [Directed, DirectedOn, Set.forall_range_iff, Set.exists_range_iff]
state_before: α : Type u
β : Type v
ι : Sort w
r r' s : α → α → Prop
f : ι → α
⊢ Directed r f ↔ DirectedOn r (Set.range f)
Theorem: isNilpotent_pi_of_bounded_class
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: rw [nilpotent_iff_lowerCentralSeries]
state_before: G : Type ?u.339405
inst✝³ : Group G
H : Subgroup G
inst✝² : Normal H
η : Type u_2
Gs : η → Type u_1
inst✝¹ : (i : η) → Group (Gs i)
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
n : ℕ
h : ∀ (i : η), nilpotencyClass (Gs i) ≤ n
⊢ Group.IsNilpotent ((i : η) → Gs i)

tactic: refine' ⟨n, _⟩
state_before: G : Type ?u.339405
inst✝³ : Group G
H : Subgroup G
inst✝² : Normal H
η : Type u_2
Gs : η → Type u_1
inst✝¹ : (i : η) → Group (Gs i)
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
n : ℕ
h : ∀ (i : η), nilpotencyClass (Gs i) ≤ n
⊢ ∃ n, lowerCentralSeries ((i : η) → Gs i) n = ⊥

tactic: rw [eq_bot_iff]
state_before: G : Type ?u.339405
inst✝³ : Group G
H : Subgroup G
inst✝² : Normal H
η : Type u_2
Gs : η → Type u_1
inst✝¹ : (i : η) → Group (Gs i)
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
n : ℕ
h : ∀ (i : η), nilpotencyClass (Gs i) ≤ n
⊢ lowerCentralSeries ((i : η) → Gs i) n = ⊥

tactic: apply le_trans (lowerCentralSeries_pi_le _)
state_before: G : Type ?u.339405
inst✝³ : Group G
H : Subgroup G
inst✝² : Normal H
η : Type u_2
Gs : η → Type u_1
inst✝¹ : (i : η) → Group (Gs i)
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
n : ℕ
h : ∀ (i : η), nilpotencyClass (Gs i) ≤ n
⊢ lowerCentralSeries ((i : η) → Gs i) n ≤ ⊥

tactic: rw [← eq_bot_iff, pi_eq_bot_iff]
state_before: G : Type ?u.339405
inst✝³ : Group G
H : Subgroup G
inst✝² : Normal H
η : Type u_2
Gs : η → Type u_1
inst✝¹ : (i : η) → Group (Gs i)
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
n : ℕ
h : ∀ (i : η), nilpotencyClass (Gs i) ≤ n
⊢ (pi Set.univ fun i => lowerCentralSeries (Gs i) n) ≤ ⊥

tactic: intro i
state_before: G : Type ?u.339405
inst✝³ : Group G
H : Subgroup G
inst✝² : Normal H
η : Type u_2
Gs : η → Type u_1
inst✝¹ : (i : η) → Group (Gs i)
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
n : ℕ
h : ∀ (i : η), nilpotencyClass (Gs i) ≤ n
⊢ ∀ (i : η), lowerCentralSeries (Gs i) n = ⊥

tactic: apply lowerCentralSeries_eq_bot_iff_nilpotencyClass_le.mpr (h i)
state_before: G : Type ?u.339405
inst✝³ : Group G
H : Subgroup G
inst✝² : Normal H
η : Type u_2
Gs : η → Type u_1
inst✝¹ : (i : η) → Group (Gs i)
inst✝ : ∀ (i : η), Group.IsNilpotent (Gs i)
n : ℕ
h : ∀ (i : η), nilpotencyClass (Gs i) ≤ n
i : η
⊢ lowerCentralSeries (Gs i) n = ⊥
Theorem: IsLeftRegular.of_mul
File: Mathlib/Algebra/Regular/Basic.lean

tactic: rwa [comp_mul_left a b]
state_before: R : Type u_1
inst✝ : Semigroup R
a b : R
ab : IsLeftRegular (a * b)
⊢ Function.Injective (?m.3539 ab ∘ fun x => b * x)
Theorem: Set.univ_prod_univ
File: Mathlib/Data/Set/Prod.lean

tactic: ext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.7166
δ : Type ?u.7169
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ univ ×ˢ univ = univ

tactic: exact true_and_iff _
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.7166
δ : Type ?u.7169
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x✝ : α × β
⊢ x✝ ∈ univ ×ˢ univ ↔ x✝ ∈ univ
Theorem: MeasurableEmbedding.aestronglyMeasurable_map_iff
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: refine' ⟨fun H => H.comp_measurable hf.measurable, _⟩
state_before: α : Type u_2
β : Type u_3
γ✝ : Type ?u.350679
ι : Type ?u.350682
inst✝² : Countable ι
m : MeasurableSpace α
μ✝ : Measure α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ✝
f✝ g✝ : α → β
γ : Type u_1
mγ : MeasurableSpace γ
mα : MeasurableSpace α
f : γ → α
μ : Measure γ
hf : MeasurableEmbedding f
g : α → β
⊢ AEStronglyMeasurable g (Measure.map f μ) ↔ AEStronglyMeasurable (g ∘ f) μ

tactic: rintro ⟨g₁, hgm₁, heq⟩
state_before: α : Type u_2
β : Type u_3
γ✝ : Type ?u.350679
ι : Type ?u.350682
inst✝² : Countable ι
m : MeasurableSpace α
μ✝ : Measure α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ✝
f✝ g✝ : α → β
γ : Type u_1
mγ : MeasurableSpace γ
mα : MeasurableSpace α
f : γ → α
μ : Measure γ
hf : MeasurableEmbedding f
g : α → β
⊢ AEStronglyMeasurable (g ∘ f) μ → AEStronglyMeasurable g (Measure.map f μ)

tactic: rcases hf.exists_stronglyMeasurable_extend hgm₁ fun x => ⟨g x⟩ with ⟨g₂, hgm₂, rfl⟩
state_before: case intro.intro
α : Type u_2
β : Type u_3
γ✝ : Type ?u.350679
ι : Type ?u.350682
inst✝² : Countable ι
m : MeasurableSpace α
μ✝ : Measure α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ✝
f✝ g✝ : α → β
γ : Type u_1
mγ : MeasurableSpace γ
mα : MeasurableSpace α
f : γ → α
μ : Measure γ
hf : MeasurableEmbedding f
g : α → β
g₁ : γ → β
hgm₁ : StronglyMeasurable g₁
heq : g ∘ f =ᶠ[ae μ] g₁
⊢ AEStronglyMeasurable g (Measure.map f μ)

tactic: exact ⟨g₂, hgm₂, hf.ae_map_iff.2 heq⟩
state_before: case intro.intro.intro.intro
α : Type u_2
β : Type u_3
γ✝ : Type ?u.350679
ι : Type ?u.350682
inst✝² : Countable ι
m : MeasurableSpace α
μ✝ : Measure α
inst✝¹ : TopologicalSpace β
inst✝ : TopologicalSpace γ✝
f✝ g✝ : α → β
γ : Type u_1
mγ : MeasurableSpace γ
mα : MeasurableSpace α
f : γ → α
μ : Measure γ
hf : MeasurableEmbedding f
g g₂ : α → β
hgm₂ : StronglyMeasurable g₂
hgm₁ : StronglyMeasurable (g₂ ∘ f)
heq : g ∘ f =ᶠ[ae μ] g₂ ∘ f
⊢ AEStronglyMeasurable g (Measure.map f μ)
Theorem: HasDerivAt.lhopital_zero_nhds
File: Mathlib/Analysis/Calculus/LHopital.lean

tactic: apply @lhopital_zero_nhds' _ _ _ f' _ g' <;>
  (first | apply eventually_nhdsWithin_of_eventually_nhds |
    apply tendsto_nhdsWithin_of_tendsto_nhds) <;> assumption
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt f (f' x) x
hgg' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt g (g' x) x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, g' x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l
⊢ Tendsto (fun x => f x / g x) (𝓝[{a}ᶜ] a) l

tactic: first | apply eventually_nhdsWithin_of_eventually_nhds |
 apply tendsto_nhdsWithin_of_tendsto_nhds
state_before: case hdiv
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt f (f' x) x
hgg' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt g (g' x) x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, g' x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l
⊢ Tendsto (fun x => f' x / g' x) (𝓝[{a}ᶜ] a) l

tactic: apply eventually_nhdsWithin_of_eventually_nhds
state_before: case hdiv
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt f (f' x) x
hgg' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt g (g' x) x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, g' x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l
⊢ Tendsto (fun x => f' x / g' x) (𝓝[{a}ᶜ] a) l

tactic: apply tendsto_nhdsWithin_of_tendsto_nhds
state_before: case hdiv
a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hff' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt f (f' x) x
hgg' : ∀ᶠ (x : ℝ) in 𝓝 a, HasDerivAt g (g' x) x
hg' : ∀ᶠ (x : ℝ) in 𝓝 a, g' x ≠ 0
hfa : Tendsto f (𝓝 a) (𝓝 0)
hga : Tendsto g (𝓝 a) (𝓝 0)
hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l
⊢ Tendsto (fun x => f' x / g' x) (𝓝[{a}ᶜ] a) l