tasksource/leandojo huggingface dataset:
Theorem: List.getLast_eq_get
File: Std/Data/List/Lemmas.lean

tactic: rw [getLast_singleton, get_singleton]
state_before: α : Type u_1
a : α
h : [a] ≠ []
⊢ getLast [a] h = get [a] { val := length [a] - 1, isLt := (_ : length [a] - 1 < length [a]) }

tactic: rw [getLast_cons', getLast_eq_get (b :: l)]
state_before: α : Type u_1
a b : α
l : List α
h : a :: b :: l ≠ []
⊢ getLast (a :: b :: l) h =
    get (a :: b :: l) { val := length (a :: b :: l) - 1, isLt := (_ : length (a :: b :: l) - 1 < length (a :: b :: l)) }

tactic: {rfl}
state_before: α : Type u_1
a b : α
l : List α
h : a :: b :: l ≠ []
⊢ get (b :: l) { val := length (b :: l) - 1, isLt := (_ : length (b :: l) - 1 < length (b :: l)) } =
    get (a :: b :: l) { val := length (a :: b :: l) - 1, isLt := (_ : length (a :: b :: l) - 1 < length (a :: b :: l)) }

α : Type u_1
a b : α
l : List α
h : a :: b :: l ≠ []
⊢ b :: l ≠ []

tactic: exact cons_ne_nil b l
state_before: α : Type u_1
a b : α
l : List α
h : a :: b :: l ≠ []
⊢ b :: l ≠ []
Theorem: TendstoLocallyUniformlyOn.comp
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: intro u hu x hx
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g✝ : ι → α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace γ
t : Set γ
h : TendstoLocallyUniformlyOn F f p s
g : γ → α
hg : MapsTo g t s
cg : ContinuousOn g t
⊢ TendstoLocallyUniformlyOn (fun n => F n ∘ g) (f ∘ g) p t

tactic: rcases h u hu (g x) (hg hx) with ⟨a, ha, H⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g✝ : ι → α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace γ
t : Set γ
h : TendstoLocallyUniformlyOn F f p s
g : γ → α
hg : MapsTo g t s
cg : ContinuousOn g t
u : Set (β × β)
hu : u ∈ 𝓤 β
x : γ
hx : x ∈ t
⊢ ∃ t_1, t_1 ∈ 𝓝[t] x ∧ ∀ᶠ (n : ι) in p, ∀ (y : γ), y ∈ t_1 → ((f ∘ g) y, (fun n => F n ∘ g) n y) ∈ u

tactic: have : g ⁻¹' a ∈ 𝓝[t] x :=
  (cg x hx).preimage_mem_nhdsWithin' (nhdsWithin_mono (g x) hg.image_subset ha)
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g✝ : ι → α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace γ
t : Set γ
h : TendstoLocallyUniformlyOn F f p s
g : γ → α
hg : MapsTo g t s
cg : ContinuousOn g t
u : Set (β × β)
hu : u ∈ 𝓤 β
x : γ
hx : x ∈ t
a : Set α
ha : a ∈ 𝓝[s] g x
H : ∀ᶠ (n : ι) in p, ∀ (y : α), y ∈ a → (f y, F n y) ∈ u
⊢ ∃ t_1, t_1 ∈ 𝓝[t] x ∧ ∀ᶠ (n : ι) in p, ∀ (y : γ), y ∈ t_1 → ((f ∘ g) y, (fun n => F n ∘ g) n y) ∈ u

tactic: exact ⟨g ⁻¹' a, this, H.mono fun n hn y hy => hn _ hy⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝² : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x✝ : α
p : Filter ι
p' : Filter α
g✝ : ι → α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace γ
t : Set γ
h : TendstoLocallyUniformlyOn F f p s
g : γ → α
hg : MapsTo g t s
cg : ContinuousOn g t
u : Set (β × β)
hu : u ∈ 𝓤 β
x : γ
hx : x ∈ t
a : Set α
ha : a ∈ 𝓝[s] g x
H : ∀ᶠ (n : ι) in p, ∀ (y : α), y ∈ a → (f y, F n y) ∈ u
this : g ⁻¹' a ∈ 𝓝[t] x
⊢ ∃ t_1, t_1 ∈ 𝓝[t] x ∧ ∀ᶠ (n : ι) in p, ∀ (y : γ), y ∈ t_1 → ((f ∘ g) y, (fun n => F n ∘ g) n y) ∈ u
Theorem: Polynomial.divByMonic_add_X_sub_C_mul_derivate_divByMonic_eq_derivative
File: Mathlib/Data/Polynomial/FieldDivision.lean

tactic: have key := by apply congrArg derivative <| X_sub_C_mul_divByMonic_eq_sub_modByMonic f a
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
⊢ f /ₘ (X - ↑C a) + (X - ↑C a) * ↑derivative (f /ₘ (X - ↑C a)) = ↑derivative f

tactic: rw [modByMonic_X_sub_C_eq_C_eval] at key
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
key : ↑derivative ((X - ↑C a) * (f /ₘ (X - ↑C a))) = ↑derivative (f - f %ₘ (X - ↑C a))
⊢ f /ₘ (X - ↑C a) + (X - ↑C a) * ↑derivative (f /ₘ (X - ↑C a)) = ↑derivative f

tactic: rw [derivative_mul,derivative_sub,derivative_X,derivative_sub] at key
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
key : ↑derivative ((X - ↑C a) * (f /ₘ (X - ↑C a))) = ↑derivative (f - ↑C (eval a f))
⊢ f /ₘ (X - ↑C a) + (X - ↑C a) * ↑derivative (f /ₘ (X - ↑C a)) = ↑derivative f

tactic: rw [derivative_C,sub_zero,one_mul] at key
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
key :
  (1 - ↑derivative (↑C a)) * (f /ₘ (X - ↑C a)) + (X - ↑C a) * ↑derivative (f /ₘ (X - ↑C a)) =
    ↑derivative f - ↑derivative (↑C (eval a f))
⊢ f /ₘ (X - ↑C a) + (X - ↑C a) * ↑derivative (f /ₘ (X - ↑C a)) = ↑derivative f

tactic: rw [derivative_C,sub_zero] at key
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
key : f /ₘ (X - ↑C a) + (X - ↑C a) * ↑derivative (f /ₘ (X - ↑C a)) = ↑derivative f - ↑derivative (↑C (eval a f))
⊢ f /ₘ (X - ↑C a) + (X - ↑C a) * ↑derivative (f /ₘ (X - ↑C a)) = ↑derivative f

tactic: assumption
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
key : f /ₘ (X - ↑C a) + (X - ↑C a) * ↑derivative (f /ₘ (X - ↑C a)) = ↑derivative f
⊢ f /ₘ (X - ↑C a) + (X - ↑C a) * ↑derivative (f /ₘ (X - ↑C a)) = ↑derivative f

tactic: apply congrArg derivative <| X_sub_C_mul_divByMonic_eq_sub_modByMonic f a
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a✝ b : R
n : ℕ
inst✝¹ : Field R
p q : R[X]
K : Type u_1
inst✝ : Field K
f : K[X]
a : K
⊢ ?m.1889975
Theorem: Int.lt_add_of_neg_add_lt_left
File: Std/Data/Int/Lemmas.lean

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

tactic: exact Int.lt_add_of_sub_left_lt h
state_before: a b c : Int
h : a + -b < c
⊢ a < b + c
Theorem: Rat.zero_mk
File: Mathlib/Data/Rat/Defs.lean

tactic: congr
state_before: d : ℕ
h : d ≠ 0
w : Nat.coprime (Int.natAbs 0) d
⊢ mk' 0 d = 0
Theorem: Finset.zero_div_subset
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp [subset_iff, mem_div]
state_before: F : Type ?u.657730
α : Type u_1
β : Type ?u.657736
γ : Type ?u.657739
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : GroupWithZero α
s✝ t s : Finset α
⊢ 0 / s ⊆ 0
Theorem: Nat.cast_factorial
File: Mathlib/Data/Nat/Factorial/Cast.lean

tactic: rw [← zero_ascFactorial, cast_ascFactorial, cast_zero, zero_add]
state_before: S : Type u_1
inst✝ : Semiring S
a b : ℕ
⊢ ↑a ! = Polynomial.eval 1 (pochhammer S a)
Theorem: Nat.ArithmeticFunction.zeta_pmul
File: Mathlib/NumberTheory/ArithmeticFunction.lean

tactic: ext x
state_before: R : Type u_1
inst✝ : NonAssocSemiring R
f : ArithmeticFunction R
⊢ pmul (↑ζ) f = f

tactic: cases x <;> simp [Nat.succ_ne_zero]
state_before: case h
R : Type u_1
inst✝ : NonAssocSemiring R
f : ArithmeticFunction R
x : ℕ
⊢ ↑(pmul (↑ζ) f) x = ↑f x
Theorem: Ideal.KerLift.map_smul
File: Mathlib/RingTheory/Ideal/QuotientOperations.lean

tactic: obtain ⟨a, rfl⟩ := Quotient.mkₐ_surjective R₁ _ x
state_before: R : Type u
S : Type v
F : Type w
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
R₁ : Type u_1
R₂ : Type ?u.775415
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R₁
inst✝⁵ : CommSemiring R₂
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra R₁ A
inst✝¹ : Algebra R₂ A
inst✝ : Algebra R₁ B
f : A →ₐ[R₁] B
r : R₁
x : A ⧸ RingHom.ker ↑f
⊢ ↑(RingHom.kerLift ↑f) (r • x) = r • ↑(RingHom.kerLift ↑f) x

tactic: exact f.map_smul _ _
state_before: case intro
R : Type u
S : Type v
F : Type w
inst✝⁸ : CommRing R
inst✝⁷ : CommRing S
R₁ : Type u_1
R₂ : Type ?u.775415
A : Type u_2
B : Type u_3
inst✝⁶ : CommSemiring R₁
inst✝⁵ : CommSemiring R₂
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra R₁ A
inst✝¹ : Algebra R₂ A
inst✝ : Algebra R₁ B
f : A →ₐ[R₁] B
r : R₁
a : A
⊢ ↑(RingHom.kerLift ↑f) (r • ↑(Quotient.mkₐ R₁ (RingHom.ker ↑f)) a) =
    r • ↑(RingHom.kerLift ↑f) (↑(Quotient.mkₐ R₁ (RingHom.ker ↑f)) a)
Theorem: MeasureTheory.Lp.simpleFunc.sub_toSimpleFunc
File: Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean

tactic: filter_upwards [toSimpleFunc_eq_toFun (f - g), toSimpleFunc_eq_toFun f,
  toSimpleFunc_eq_toFun g, Lp.coeFn_sub (f : Lp E p μ) g] with _
state_before: α : Type u_1
β : Type ?u.1588527
ι : Type ?u.1588530
E : Type u_2
F : Type ?u.1588536
𝕜 : Type ?u.1588539
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f g : { x // x ∈ simpleFunc E p μ }
⊢ ↑(toSimpleFunc (f - g)) =ᵐ[μ] ↑(toSimpleFunc f) - ↑(toSimpleFunc g)

tactic: simp only [AddSubgroup.coe_sub, Pi.sub_apply]
state_before: case h
α : Type u_1
β : Type ?u.1588527
ι : Type ?u.1588530
E : Type u_2
F : Type ?u.1588536
𝕜 : Type ?u.1588539
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f g : { x // x ∈ simpleFunc E p μ }
a✝ : α
⊢ ↑(toSimpleFunc (f - g)) a✝ = ↑↑↑(f - g) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ →
      ↑(toSimpleFunc g) a✝ = ↑↑↑g a✝ →
        ↑↑(↑f - ↑g) a✝ = (↑↑↑f - ↑↑↑g) a✝ → ↑(toSimpleFunc (f - g)) a✝ = (↑(toSimpleFunc f) - ↑(toSimpleFunc g)) a✝

tactic: repeat' intro h; rw [h]
state_before: case h
α : Type u_1
β : Type ?u.1588527
ι : Type ?u.1588530
E : Type u_2
F : Type ?u.1588536
𝕜 : Type ?u.1588539
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f g : { x // x ∈ simpleFunc E p μ }
a✝ : α
⊢ ↑(toSimpleFunc (f - g)) a✝ = ↑(↑↑f - ↑↑g) a✝ →
    ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝ →
      ↑(toSimpleFunc g) a✝ = ↑↑↑g a✝ →
        ↑(↑↑f - ↑↑g) a✝ = ↑↑↑f a✝ - ↑↑↑g a✝ → ↑(toSimpleFunc (f - g)) a✝ = ↑(toSimpleFunc f) a✝ - ↑(toSimpleFunc g) a✝

tactic: intro h
state_before: case h
α : Type u_1
β : Type ?u.1588527
ι : Type ?u.1588530
E : Type u_2
F : Type ?u.1588536
𝕜 : Type ?u.1588539
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f g : { x // x ∈ simpleFunc E p μ }
a✝ : α
h✝¹ : ↑(toSimpleFunc (f - g)) a✝ = ↑(↑↑f - ↑↑g) a✝
h✝ : ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝
h : ↑(toSimpleFunc g) a✝ = ↑↑↑g a✝
⊢ ↑(↑↑f - ↑↑g) a✝ = ↑↑↑f a✝ - ↑↑↑g a✝ → ↑(↑↑f - ↑↑g) a✝ = ↑↑↑f a✝ - ↑↑↑g a✝

tactic: rw [h]
state_before: case h
α : Type u_1
β : Type ?u.1588527
ι : Type ?u.1588530
E : Type u_2
F : Type ?u.1588536
𝕜 : Type ?u.1588539
inst✝² : MeasurableSpace α
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
p : ℝ≥0∞
μ : Measure α
f g : { x // x ∈ simpleFunc E p μ }
a✝ : α
h✝² : ↑(toSimpleFunc (f - g)) a✝ = ↑(↑↑f - ↑↑g) a✝
h✝¹ : ↑(toSimpleFunc f) a✝ = ↑↑↑f a✝
h✝ : ↑(toSimpleFunc g) a✝ = ↑↑↑g a✝
h : ↑(↑↑f - ↑↑g) a✝ = ↑↑↑f a✝ - ↑↑↑g a✝
⊢ ↑(↑↑f - ↑↑g) a✝ = ↑↑↑f a✝ - ↑↑↑g a✝
Theorem: Equiv.naturality
File: Mathlib/Control/Traversable/Equiv.lean

tactic: simp only [Equiv.traverse, functor_norm]
state_before: t t' : Type u → Type u
eqv : (α : Type u) → t α ≃ t' α
inst✝⁵ : Traversable t
inst✝⁴ : IsLawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : Applicative G
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
η : ApplicativeTransformation F G
α β γ : Type u
f : α → F β
x : t' α
⊢ (fun {α} => ApplicativeTransformation.app η α) (Equiv.traverse eqv f x) =
    Equiv.traverse eqv ((fun {α} => ApplicativeTransformation.app η α) ∘ f) x
Theorem: CategoryTheory.Limits.biproduct.matrix_desc
File: Mathlib/CategoryTheory/Preadditive/Biproducts.lean

tactic: ext
state_before: C : Type u
inst✝⁵ : Category C
inst✝⁴ : Preadditive C
J : Type
inst✝³ : Fintype J
f✝ : J → C
inst✝² : HasBiproduct f✝
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
P : C
x : (k : K) → g k ⟶ P
⊢ matrix m ≫ desc x = desc fun j => ∑ k : K, m j k ≫ x k

tactic: simp
state_before: case w
C : Type u
inst✝⁵ : Category C
inst✝⁴ : Preadditive C
J : Type
inst✝³ : Fintype J
f✝ : J → C
inst✝² : HasBiproduct f✝
K : Type
inst✝¹ : Fintype K
inst✝ : HasFiniteBiproducts C
f : J → C
g : K → C
m : (j : J) → (k : K) → f j ⟶ g k
P : C
x : (k : K) → g k ⟶ P
j✝ : J
⊢ ι (fun j => f j) j✝ ≫ matrix m ≫ desc x = ι (fun j => f j) j✝ ≫ desc fun j => ∑ k : K, m j k ≫ x k
Theorem: Set.mem_dite_empty_right
File: Mathlib/Data/Set/Basic.lean

tactic: simp only [mem_dite, mem_empty_iff_false, imp_false, not_not]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t✝ t₁ t₂ u : Set α
p : Prop
inst✝ : Decidable p
t : p → Set α
x : α
⊢ (x ∈ if h : p then t h else ∅) ↔ ∃ h, x ∈ t h

tactic: exact ⟨fun h => ⟨h.2, h.1 h.2⟩, fun ⟨h₁, h₂⟩ => ⟨fun _ => h₂, h₁⟩⟩
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t✝ t₁ t₂ u : Set α
p : Prop
inst✝ : Decidable p
t : p → Set α
x : α
⊢ (∀ (h : p), x ∈ t h) ∧ p ↔ ∃ h, x ∈ t h
Theorem: Int.ofNat_add_negSucc_of_ge
File: Mathlib/Data/Int/Div.lean

tactic: rw [negSucc_eq, ofNat_eq_cast, ofNat_eq_cast, ← Nat.cast_one, ← Nat.cast_add,
  ← sub_eq_add_neg, ← Nat.cast_sub h]
state_before: m n : ℕ
h : Nat.succ n ≤ m
⊢ ofNat m + -[n+1] = ofNat (m - Nat.succ n)
Theorem: single_le_finprod
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: classical calc
    f i ≤ ∏ j in insert i hf.toFinset, f j :=
      Finset.single_le_prod' (fun j _ => h j) (Finset.mem_insert_self _ _)
    _ = ∏ᶠ j, f j :=
      (finprod_eq_prod_of_mulSupport_toFinset_subset _ hf (Finset.subset_insert _ _)).symm
state_before: α : Type u_2
β : Type ?u.380672
ι : Type ?u.380675
G : Type ?u.380678
M✝ : Type ?u.380681
N : Type ?u.380684
inst✝² : CommMonoid M✝
inst✝¹ : CommMonoid N
f✝ g : α → M✝
a b : α
s t : Set α
M : Type u_1
inst✝ : OrderedCommMonoid M
i : α
f : α → M
hf : Set.Finite (mulSupport f)
h : ∀ (j : α), 1 ≤ f j
⊢ f i ≤ ∏ᶠ (j : α), f j

tactic: calc
f i ≤ ∏ j in insert i hf.toFinset, f j :=
Finset.single_le_prod' (fun j _ => h j) (Finset.mem_insert_self _ _)
_ = ∏ᶠ j, f j :=
(finprod_eq_prod_of_mulSupport_toFinset_subset _ hf (Finset.subset_insert _ _)).symm
state_before: α : Type u_2
β : Type ?u.380672
ι : Type ?u.380675
G : Type ?u.380678
M✝ : Type ?u.380681
N : Type ?u.380684
inst✝² : CommMonoid M✝
inst✝¹ : CommMonoid N
f✝ g : α → M✝
a b : α
s t : Set α
M : Type u_1
inst✝ : OrderedCommMonoid M
i : α
f : α → M
hf : Set.Finite (mulSupport f)
h : ∀ (j : α), 1 ≤ f j
⊢ f i ≤ ∏ᶠ (j : α), f j
Theorem: Set.image_sub_const_Iic
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [sub_eq_neg_add]
state_before: α : Type u_1
inst✝ : OrderedAddCommGroup α
a b c : α
⊢ (fun x => x - a) '' Iic b = Iic (b - a)
Theorem: List.prod_eq_zero_iff
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: induction' L with a L ihL
state_before: ι : Type ?u.109197
α : Type ?u.109200
M : Type ?u.109203
N : Type ?u.109206
P : Type ?u.109209
M₀ : Type u_1
G : Type ?u.109215
R : Type ?u.109218
inst✝² : MonoidWithZero M₀
inst✝¹ : Nontrivial M₀
inst✝ : NoZeroDivisors M₀
L : List M₀
⊢ prod L = 0 ↔ 0 ∈ L

tactic: simp
state_before: case nil
ι : Type ?u.109197
α : Type ?u.109200
M : Type ?u.109203
N : Type ?u.109206
P : Type ?u.109209
M₀ : Type u_1
G : Type ?u.109215
R : Type ?u.109218
inst✝² : MonoidWithZero M₀
inst✝¹ : Nontrivial M₀
inst✝ : NoZeroDivisors M₀
⊢ prod [] = 0 ↔ 0 ∈ []

tactic: rw [prod_cons, mul_eq_zero, ihL, mem_cons, eq_comm]
state_before: case cons
ι : Type ?u.109197
α : Type ?u.109200
M : Type ?u.109203
N : Type ?u.109206
P : Type ?u.109209
M₀ : Type u_1
G : Type ?u.109215
R : Type ?u.109218
inst✝² : MonoidWithZero M₀
inst✝¹ : Nontrivial M₀
inst✝ : NoZeroDivisors M₀
a : M₀
L : List M₀
ihL : prod L = 0 ↔ 0 ∈ L
⊢ prod (a :: L) = 0 ↔ 0 ∈ a :: L
Theorem: MeasureTheory.measure_iUnion
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

tactic: rw [measure_eq_extend (MeasurableSet.iUnion h),
  extend_iUnion MeasurableSet.empty _ MeasurableSet.iUnion _ hn h]
state_before: ι : Type u_2
α : Type u_1
β : Type ?u.8694
γ : Type ?u.8697
m0✝ : MeasurableSpace α
μ✝ : Measure α
s t : Set α
m0 : MeasurableSpace α
μ : Measure α
inst✝ : Countable ι
f : ι → Set α
hn : Pairwise (Disjoint on f)
h : ∀ (i : ι), MeasurableSet (f i)
⊢ ↑↑μ (⋃ (i : ι), f i) = ∑' (i : ι), ↑↑μ (f i)

tactic: simp [measure_eq_extend, h]
state_before: ι : Type u_2
α : Type u_1
β : Type ?u.8694
γ : Type ?u.8697
m0✝ : MeasurableSpace α
μ✝ : Measure α
s t : Set α
m0 : MeasurableSpace α
μ : Measure α
inst✝ : Countable ι
f : ι → Set α
hn : Pairwise (Disjoint on f)
h : ∀ (i : ι), MeasurableSet (f i)
⊢ (∑' (i : ι), extend (fun t _ht => ↑↑μ t) (f i)) = ∑' (i : ι), ↑↑μ (f i)

tactic: exact μ.empty
state_before: ι : Type u_2
α : Type u_1
β : Type ?u.8694
γ : Type ?u.8697
m0✝ : MeasurableSpace α
μ✝ : Measure α
s t : Set α
m0 : MeasurableSpace α
μ : Measure α
inst✝ : Countable ι
f : ι → Set α
hn : Pairwise (Disjoint on f)
h : ∀ (i : ι), MeasurableSet (f i)
⊢ ↑↑μ ∅ = 0

tactic: exact μ.m_iUnion
state_before: ι : Type u_2
α : Type u_1
β : Type ?u.8694
γ : Type ?u.8697
m0✝ : MeasurableSpace α
μ✝ : Measure α
s t : Set α
m0 : MeasurableSpace α
μ : Measure α
inst✝ : Countable ι
f : ι → Set α
hn : Pairwise (Disjoint on f)
h : ∀ (i : ι), MeasurableSet (f i)
⊢ ∀ ⦃f : ℕ → Set α⦄,
    (∀ (i : ℕ), MeasurableSet (f i)) → Pairwise (Disjoint on f) → ↑↑μ (⋃ (i : ℕ), f i) = ∑' (i : ℕ), ↑↑μ (f i)
Theorem: HasFDerivWithinAt.iterate
File: Mathlib/Analysis/Calculus/FDeriv/Comp.lean

tactic: refine' HasFDerivAtFilter.iterate hf _ hx n
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type ?u.144903
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.144998
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.145093
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → E
f' : E →L[𝕜] E
hf : HasFDerivWithinAt f f' s x
hx : f x = x
hs : MapsTo f s s
n : ℕ
⊢ HasFDerivWithinAt (f^[n]) (f' ^ n) s x

tactic: rw [_root_.nhdsWithin]
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type ?u.144903
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.144998
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.145093
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → E
f' : E →L[𝕜] E
hf : HasFDerivWithinAt f f' s x
hx : f x = x
hs : MapsTo f s s
n : ℕ
⊢ Tendsto f (𝓝[s] x) (𝓝[s] x)

tactic: convert tendsto_inf.2 ⟨hf.continuousWithinAt, _⟩
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type ?u.144903
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.144998
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.145093
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → E
f' : E →L[𝕜] E
hf : HasFDerivWithinAt f f' s x
hx : f x = x
hs : MapsTo f s s
n : ℕ
⊢ Tendsto f (𝓝 x ⊓ 𝓟 s) (𝓝 x ⊓ 𝓟 s)

tactic: exacts [hx.symm, (tendsto_principal_principal.2 hs).mono_left inf_le_right]
state_before: case h.e'_5.h.e'_3.h.e'_3
𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type ?u.144903
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.144998
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.145093
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → E
f' : E →L[𝕜] E
hf : HasFDerivWithinAt f f' s x
hx : f x = x
hs : MapsTo f s s
n : ℕ
⊢ x = f x

case convert_2
𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type ?u.144903
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type ?u.144998
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type ?u.145093
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f'✝ f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
f : E → E
f' : E →L[𝕜] E
hf : HasFDerivWithinAt f f' s x
hx : f x = x
hs : MapsTo f s s
n : ℕ
⊢ Tendsto f (𝓝[s] x) (𝓟 s)
Theorem: exists_pow_eq_one
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: have H : (Set.univ : Set G).Finite := Set.univ.toFinite
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝² : LeftCancelMonoid G
inst✝¹ : AddLeftCancelMonoid A
inst✝ : Finite G
x : G
⊢ IsOfFinOrder x

tactic: contrapose! H
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝² : LeftCancelMonoid G
inst✝¹ : AddLeftCancelMonoid A
inst✝ : Finite G
x : G
H : Set.Finite Set.univ
⊢ IsOfFinOrder x

tactic: exact Set.Infinite.mono (Set.subset_univ _) (infinite_not_isOfFinOrder H)
state_before: G : Type u
A : Type v
x✝ y : G
a b : A
n m : ℕ
inst✝² : LeftCancelMonoid G
inst✝¹ : AddLeftCancelMonoid A
inst✝ : Finite G
x : G
H : ¬IsOfFinOrder x
⊢ ¬Set.Finite Set.univ
Theorem: Filter.comap_eval_neBot_iff'
File: Mathlib/Order/Filter/Basic.lean

tactic: cases' isEmpty_or_nonempty (∀ j, α j) with H H
state_before: α✝ : Type u
β : Type v
γ : Type w
δ : Type ?u.269920
ι✝ : Sort x
f✝ f₁ f₂ : Filter α✝
g g₁ g₂ : Filter β
m : α✝ → β
m' : β → γ
s : Set α✝
t : Set β
ι : Type u_1
α : ι → Type u_2
i : ι
f : Filter (α i)
⊢ NeBot (comap (eval i) f) ↔ (∀ (j : ι), Nonempty (α j)) ∧ NeBot f

tactic: rw [filter_eq_bot_of_isEmpty (f.comap _), ← not_iff_not]
state_before: case inl
α✝ : Type u
β : Type v
γ : Type w
δ : Type ?u.269920
ι✝ : Sort x
f✝ f₁ f₂ : Filter α✝
g g₁ g₂ : Filter β
m : α✝ → β
m' : β → γ
s : Set α✝
t : Set β
ι : Type u_1
α : ι → Type u_2
i : ι
f : Filter (α i)
H : IsEmpty ((j : ι) → α j)
⊢ NeBot (comap (eval i) f) ↔ (∀ (j : ι), Nonempty (α j)) ∧ NeBot f

tactic: simp [← Classical.nonempty_pi]
state_before: case inl
α✝ : Type u
β : Type v
γ : Type w
δ : Type ?u.269920
ι✝ : Sort x
f✝ f₁ f₂ : Filter α✝
g g₁ g₂ : Filter β
m : α✝ → β
m' : β → γ
s : Set α✝
t : Set β
ι : Type u_1
α : ι → Type u_2
i : ι
f : Filter (α i)
H : IsEmpty ((j : ι) → α j)
⊢ ¬NeBot ⊥ ↔ ¬((∀ (j : ι), Nonempty (α j)) ∧ NeBot f)

tactic: have : ∀ j, Nonempty (α j) := Classical.nonempty_pi.1 H
state_before: case inr
α✝ : Type u
β : Type v
γ : Type w
δ : Type ?u.269920
ι✝ : Sort x
f✝ f₁ f₂ : Filter α✝
g g₁ g₂ : Filter β
m : α✝ → β
m' : β → γ
s : Set α✝
t : Set β
ι : Type u_1
α : ι → Type u_2
i : ι
f : Filter (α i)
H : Nonempty ((j : ι) → α j)
⊢ NeBot (comap (eval i) f) ↔ (∀ (j : ι), Nonempty (α j)) ∧ NeBot f

tactic: simp [comap_neBot_iff_frequently, *]
state_before: case inr
α✝ : Type u
β : Type v
γ : Type w
δ : Type ?u.269920
ι✝ : Sort x
f✝ f₁ f₂ : Filter α✝
g g₁ g₂ : Filter β
m : α✝ → β
m' : β → γ
s : Set α✝
t : Set β
ι : Type u_1
α : ι → Type u_2
i : ι
f : Filter (α i)
H : Nonempty ((j : ι) → α j)
this : ∀ (j : ι), Nonempty (α j)
⊢ NeBot (comap (eval i) f) ↔ (∀ (j : ι), Nonempty (α j)) ∧ NeBot f
Theorem: WithTop.image_coe_Iic
File: Mathlib/Data/Set/Intervals/WithBotTop.lean

tactic: rw [← preimage_coe_Iic, image_preimage_eq_inter_range, range_coe,
  inter_eq_self_of_subset_left (Iic_subset_Iio.2 <| coe_lt_top a)]
state_before: α : Type u_1
inst✝ : PartialOrder α
a b : α
⊢ some '' Iic a = Iic ↑a