ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: lowerCentralSeries_pi_le
File: Mathlib/GroupTheory/Nilpotent.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : H.Normal
η : Type u_2
Gs : η → Type u_3
inst✝ : (i : η) → Group (Gs i)
n : ℕ
⊢ lowerCentralSeries ((i : η) → Gs i) n ≤ pi Set.univ fun i => lowerCentralSeries (Gs i) n
state_after: G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : H.Normal
η : Type u_2
Gs : η → Type u_3
inst✝ : (i : η) → Group (Gs i)
n : ℕ
pi : ((i : η) → Subgroup (Gs i)) → Subgroup ((i : η) → Gs i) := fun f => Subgroup.pi Set.univ f
⊢ lowerCentralSeries ((i : η) → Gs i) n ≤ Subgroup.pi Set.univ fun i => lowerCentralSeries (Gs i) n
tactic: let pi := fun f : ∀ i, Subgroup (Gs i) => Subgroup.pi Set.univ f
state_before: G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : H.Normal
η : Type u_2
Gs : η → Type u_3
inst✝ : (i : η) → Group (Gs i)
n : ℕ
pi : ((i : η) → Subgroup (Gs i)) → Subgroup ((i : η) → Gs i) := fun f => Subgroup.pi Set.univ f
⊢ lowerCentralSeries ((i : η) → Gs i) n ≤ Subgroup.pi Set.univ fun i => lowerCentralSeries (Gs i) n
state_after: case zero
G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : H.Normal
η : Type u_2
Gs : η → Type u_3
inst✝ : (i : η) → Group (Gs i)
pi : ((i : η) → Subgroup (Gs i)) → Subgroup ((i : η) → Gs i) := fun f => Subgroup.pi Set.univ f
⊢ lowerCentralSeries ((i : η) → Gs i) 0 ≤ Subgroup.pi Set.univ fun i => lowerCentralSeries (Gs i) 0

case succ
G : Type u_1
inst✝² : Group G
H : Subgroup G
inst✝¹ : H.Normal
η : Type u_2
Gs : η → Type u_3
inst✝ : (i : η) → Group (Gs i)
pi : ((i : η) → Subgroup (Gs i)) → Subgroup ((i : η) → Gs i) := fun f => Subgroup.pi Set.univ f
n : ℕ
ih : lowerCentralSeries ((i : η) → Gs i) n ≤ Subgroup.pi Set.univ fun i => lowerCentralSeries (Gs i) n
⊢ lowerCentralSeries ((i : η) → Gs i) (n + 1) ≤ Subgroup.pi Set.univ fun i => lowerCentralSeries (Gs i) (n + 1)
tactic: induction' n with n ih
Theorem: Matroid.Base.exchange_base_of_indep'
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hB : M.Base B
he : e ∈ B
hf : f ∉ B
hI : M.Indep (insert f B \ {e})
⊢ M.Base (insert f B \ {e})
state_after: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hB : M.Base B
he : e ∈ B
hf : f ∉ B
hI : M.Indep (insert f B \ {e})
hfe : f ≠ e
⊢ M.Base (insert f B \ {e})
tactic: have hfe : f ≠ e := by rintro rfl; exact hf he
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hB : M.Base B
he : e ∈ B
hf : f ∉ B
hI : M.Indep (insert f B \ {e})
hfe : f ≠ e
⊢ M.Base (insert f B \ {e})
state_after: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hB : M.Base B
he : e ∈ B
hf : f ∉ B
hI : M.Indep (insert f (B \ {e}))
hfe : f ≠ e
⊢ M.Base (insert f (B \ {e}))
tactic: rw [← insert_diff_singleton_comm hfe] at *
state_before: α : Type u_1
M : Matroid α
B B' I J D X : Set α
e f : α
hB : M.Base B
he : e ∈ B
hf : f ∉ B
hI : M.Indep (insert f (B \ {e}))
hfe : f ≠ e
⊢ M.Base (insert f (B \ {e}))
state_after: no goals
tactic: exact hB.exchange_base_of_indep hf hI
Theorem: Nat.Partrec.Code.eval_prec_succ
File: Mathlib/Computability/PartrecCode.lean

Proof steps:
state_before: cf cg : Code
a k : ℕ
⊢ (cf.prec cg).eval (Nat.pair a k.succ) = do
    let ih ← (cf.prec cg).eval (Nat.pair a k)
    cg.eval (Nat.pair a (Nat.pair k ih))
state_after: cf cg : Code
a k : ℕ
⊢ Nat.rec (cf.eval (a, k.succ).1)
      (fun y IH => do
        let i ← IH
        cg.eval (Nat.pair (a, k.succ).1 (Nat.pair y i)))
      (a, k.succ).2 =
    (unpaired
          (fun a n =>
            Nat.rec (cf.eval a)
              (fun y IH => do
                let i ← IH
                cg.eval (Nat.pair a (Nat.pair y i)))
              n)
          (Nat.pair a k)).bind
      fun ih => cg.eval (Nat.pair a (Nat.pair k ih))
tactic: rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair]
state_before: cf cg : Code
a k : ℕ
⊢ Nat.rec (cf.eval (a, k.succ).1)
      (fun y IH => do
        let i ← IH
        cg.eval (Nat.pair (a, k.succ).1 (Nat.pair y i)))
      (a, k.succ).2 =
    (unpaired
          (fun a n =>
            Nat.rec (cf.eval a)
              (fun y IH => do
                let i ← IH
                cg.eval (Nat.pair a (Nat.pair y i)))
              n)
          (Nat.pair a k)).bind
      fun ih => cg.eval (Nat.pair a (Nat.pair k ih))
state_after: no goals
tactic: simp
Theorem: SchwartzMap.norm_le_seminorm
File: Mathlib/Analysis/Distribution/SchwartzSpace.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 F
inst✝ : SMulCommClass ℝ 𝕜 F
f : 𝓢(E, F)
x₀ : E
⊢ ‖f x₀‖ ≤ (SchwartzMap.seminorm 𝕜 0 0) f
state_after: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 F
inst✝ : SMulCommClass ℝ 𝕜 F
f : 𝓢(E, F)
x₀ : E
this : ‖x₀‖ ^ 0 * ‖f x₀‖ ≤ (SchwartzMap.seminorm 𝕜 0 0) f
⊢ ‖f x₀‖ ≤ (SchwartzMap.seminorm 𝕜 0 0) f
tactic: have := norm_pow_mul_le_seminorm 𝕜 f 0 x₀
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace ℝ E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedField 𝕜
inst✝¹ : NormedSpace 𝕜 F
inst✝ : SMulCommClass ℝ 𝕜 F
f : 𝓢(E, F)
x₀ : E
this : ‖x₀‖ ^ 0 * ‖f x₀‖ ≤ (SchwartzMap.seminorm 𝕜 0 0) f
⊢ ‖f x₀‖ ≤ (SchwartzMap.seminorm 𝕜 0 0) f
state_after: no goals
tactic: rwa [pow_zero, one_mul] at this
Theorem: Int.ceil_neg
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a : α
z : ℤ
⊢ ⌈-a⌉ ≤ z ↔ -⌊a⌋ ≤ z
state_after: no goals
tactic: rw [neg_le, ceil_le, le_floor, Int.cast_neg, neg_le]
Theorem: CategoryTheory.Limits.kernelSubobjectMap_id
File: Mathlib/CategoryTheory/Subobject/Limits.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
X Y Z : C
inst✝² : HasZeroMorphisms C
f : X ⟶ Y
inst✝¹ : HasKernel f
X' Y' : C
f' : X' ⟶ Y'
inst✝ : HasKernel f'
⊢ kernelSubobjectMap (𝟙 (Arrow.mk f)) = 𝟙 (underlying.obj (kernelSubobject f))
state_after: no goals
tactic: aesop_cat
Theorem: preStoneCech_hom_ext
File: Mathlib/Topology/StoneCech.lean

Proof steps:
state_before: α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
g₁ g₂ : PreStoneCech α → β
h₁ : Continuous g₁
h₂ : Continuous g₂
h : g₁ ∘ preStoneCechUnit = g₂ ∘ preStoneCechUnit
⊢ g₁ = g₂
state_after: α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
g₁ g₂ : PreStoneCech α → β
h₁ : Continuous g₁
h₂ : Continuous g₂
h : g₁ ∘ preStoneCechUnit = g₂ ∘ preStoneCechUnit
⊢ EqOn g₁ g₂ (range preStoneCechUnit)
tactic: apply Continuous.ext_on denseRange_preStoneCechUnit h₁ h₂
state_before: α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
g₁ g₂ : PreStoneCech α → β
h₁ : Continuous g₁
h₂ : Continuous g₂
h : g₁ ∘ preStoneCechUnit = g₂ ∘ preStoneCechUnit
⊢ EqOn g₁ g₂ (range preStoneCechUnit)
state_after: case intro
α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
g₁ g₂ : PreStoneCech α → β
h₁ : Continuous g₁
h₂ : Continuous g₂
h : g₁ ∘ preStoneCechUnit = g₂ ∘ preStoneCechUnit
x : α
⊢ g₁ (preStoneCechUnit x) = g₂ (preStoneCechUnit x)
tactic: rintro x ⟨x, rfl⟩
state_before: case intro
α : Type u
inst✝³ : TopologicalSpace α
β : Type v
inst✝² : TopologicalSpace β
inst✝¹ : T2Space β
inst✝ : CompactSpace β
g : α → β
hg : Continuous g
g₁ g₂ : PreStoneCech α → β
h₁ : Continuous g₁
h₂ : Continuous g₂
h : g₁ ∘ preStoneCechUnit = g₂ ∘ preStoneCechUnit
x : α
⊢ g₁ (preStoneCechUnit x) = g₂ (preStoneCechUnit x)
state_after: no goals
tactic: apply congr_fun h x
Theorem: MonoidHom.map_neg_one
File: Mathlib/Algebra/Order/Ring/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
R : Type u_3
inst✝³ : Ring R
inst✝² : Monoid M
inst✝¹ : LinearOrder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
f : R →* M
⊢ f (-1) ^ Nat.succ 1 = 1
state_after: no goals
tactic: rw [← map_pow, neg_one_sq, map_one]
Theorem: dNext_eq_zero
File: Mathlib/Algebra/Homology/Homotopy.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i✝ : ι
f : (i j : ι) → C.X i ⟶ D.X j
i : ι
hi : ¬c.Rel i (c.next i)
⊢ (dNext i) f = 0
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i✝ : ι
f : (i j : ι) → C.X i ⟶ D.X j
i : ι
hi : ¬c.Rel i (c.next i)
⊢ C.d i (c.next i) ≫ f (c.next i) i = 0
tactic: dsimp [dNext]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f✝ g : C ⟶ D
h k : D ⟶ E
i✝ : ι
f : (i j : ι) → C.X i ⟶ D.X j
i : ι
hi : ¬c.Rel i (c.next i)
⊢ C.d i (c.next i) ≫ f (c.next i) i = 0
state_after: no goals
tactic: rw [shape _ _ _ hi, zero_comp]
Theorem: List.length_eraseP_of_mem
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α✝ : Type u_1
a : α✝
l : List α✝
p : α✝ → Bool
al : a ∈ l
pa : p a = true
⊢ (eraseP p l).length = l.length.pred
state_after: α✝ : Type u_1
a : α✝
l : List α✝
p : α✝ → Bool
al : a ∈ l
pa : p a = true
w✝ : α✝
l₁ l₂ : List α✝
left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
e₁ : l = l₁ ++ w✝ :: l₂
e₂ : eraseP p l = l₁ ++ l₂
⊢ (eraseP p l).length = l.length.pred
tactic: let ⟨_, l₁, l₂, _, _, e₁, e₂⟩ := exists_of_eraseP al pa
state_before: α✝ : Type u_1
a : α✝
l : List α✝
p : α✝ → Bool
al : a ∈ l
pa : p a = true
w✝ : α✝
l₁ l₂ : List α✝
left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
e₁ : l = l₁ ++ w✝ :: l₂
e₂ : eraseP p l = l₁ ++ l₂
⊢ (eraseP p l).length = l.length.pred
state_after: α✝ : Type u_1
a : α✝
l : List α✝
p : α✝ → Bool
al : a ∈ l
pa : p a = true
w✝ : α✝
l₁ l₂ : List α✝
left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
e₁ : l = l₁ ++ w✝ :: l₂
e₂ : eraseP p l = l₁ ++ l₂
⊢ (l₁ ++ l₂).length = l.length.pred
tactic: rw [e₂]
state_before: α✝ : Type u_1
a : α✝
l : List α✝
p : α✝ → Bool
al : a ∈ l
pa : p a = true
w✝ : α✝
l₁ l₂ : List α✝
left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
e₁ : l = l₁ ++ w✝ :: l₂
e₂ : eraseP p l = l₁ ++ l₂
⊢ (l₁ ++ l₂).length = l.length.pred
state_after: α✝ : Type u_1
a : α✝
l : List α✝
p : α✝ → Bool
al : a ∈ l
pa : p a = true
w✝ : α✝
l₁ l₂ : List α✝
left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
e₁ : l = l₁ ++ w✝ :: l₂
e₂ : eraseP p l = l₁ ++ l₂
⊢ l₁.length + l₂.length = l₁.length + (l₂.length + 1) - 1
tactic: simp [length_append, e₁]
state_before: α✝ : Type u_1
a : α✝
l : List α✝
p : α✝ → Bool
al : a ∈ l
pa : p a = true
w✝ : α✝
l₁ l₂ : List α✝
left✝¹ : ∀ (b : α✝), b ∈ l₁ → ¬p b = true
left✝ : p w✝ = true
e₁ : l = l₁ ++ w✝ :: l₂
e₂ : eraseP p l = l₁ ++ l₂
⊢ l₁.length + l₂.length = l₁.length + (l₂.length + 1) - 1
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Limits.Cocone.toOver_pt
File: Mathlib/CategoryTheory/Limits/ConeCategory.lean

Proof steps:
state_before: J : Type u₁
inst✝³ : Category.{v₁, u₁} J
K : Type u₂
inst✝² : Category.{v₂, u₂} K
C : Type u₃
inst✝¹ : Category.{v₃, u₃} C
D : Type u₄
inst✝ : Category.{v₄, u₄} D
F : J ⥤ C
c : Cocone F
j : J
⊢ c.ι.app j ≫ (((const J).obj (Over.mk (𝟙 c.pt))).obj j).hom =
    ((c.toCostructuredArrow ⋙ CostructuredArrow.toOver F c.pt).obj j).hom
state_after: no goals
tactic: simp
Theorem: Matrix.cons_vecMul_cons
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : NonUnitalNonAssocSemiring α
x : α
v : Fin n → α
w : o' → α
B : Fin n → o' → α
⊢ vecCons x v ᵥ* of (vecCons w B) = x • w + v ᵥ* of B
state_after: no goals
tactic: simp
Theorem: PosNum.bit1_of_bit1
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
n : PosNum
⊢ n + n + 1 = n.bit1
state_after: no goals
tactic: rw [add_one, bit0_of_bit0, succ]
Theorem: subset_coborder
File: Mathlib/Topology/LocallyClosed.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
⊢ s ⊆ coborder s
state_after: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
⊢ Disjoint s (closure s \ s)
tactic: rw [coborder, subset_compl_iff_disjoint_right]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
⊢ Disjoint s (closure s \ s)
state_after: no goals
tactic: exact disjoint_sdiff_self_right
Theorem: PNat.card_fintype_Ioc
File: Mathlib/Data/PNat/Interval.lean

Proof steps:
state_before: a b : ℕ+
⊢ Fintype.card ↑(Set.Ioc a b) = ↑b - ↑a
state_after: no goals
tactic: rw [← card_Ioc, Fintype.card_ofFinset]
Theorem: hasSum_zeta_four
File: Mathlib/NumberTheory/ZetaValues.lean

Proof steps:
state_before: ⊢ HasSum (fun n => 1 / ↑n ^ 4) (π ^ 4 / 90)
state_after: case h.e'_6

⊢ π ^ 4 / 90 = (-1) ^ (2 + 1) * 2 ^ (2 * 2 - 1) * π ^ (2 * 2) * ↑(bernoulli (2 * 2)) / ↑(2 * 2)!
tactic: convert hasSum_zeta_nat two_ne_zero using 1
state_before: case h.e'_6

⊢ π ^ 4 / 90 = (-1) ^ (2 + 1) * 2 ^ (2 * 2 - 1) * π ^ (2 * 2) * ↑(bernoulli (2 * 2)) / ↑(2 * 2)!
state_after: case h.e'_6

⊢ π ^ 4 / 90 = -(8 * π ^ 4 * ↑(bernoulli 4)) / ↑4!
tactic: norm_num
state_before: case h.e'_6

⊢ π ^ 4 / 90 = -(8 * π ^ 4 * ↑(bernoulli 4)) / ↑4!
state_after: case h.e'_6

⊢ π ^ 4 / 90 = -(8 * π ^ 4 * ↑(-1 / 30)) / ↑4!

case h.e'_6

⊢ 4 ≠ 1
tactic: rw [bernoulli_eq_bernoulli'_of_ne_one, bernoulli'_four]
Theorem: MeasureTheory.eLpNorm_nnreal_eq_eLpNorm'
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p✝ : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
p : ℝ≥0
hp : p ≠ 0
⊢ ↑p ≠ 0
state_after: no goals
tactic: exact_mod_cast hp
Theorem: ProbabilityTheory.Kernel.integrable_densityProcess
File: Mathlib/Probability/Kernel/Disintegration/Density.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
n : ℕ
a : α
s : Set β
hs : MeasurableSet s
⊢ Integrable (fun x => κ.densityProcess ν n a x s) (ν a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
n : ℕ
a : α
s : Set β
hs : MeasurableSet s
⊢ Memℒp (fun x => κ.densityProcess ν n a x s) 1 (ν a)
tactic: rw [← memℒp_one_iff_integrable]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
n : ℕ
a : α
s : Set β
hs : MeasurableSet s
⊢ Memℒp (fun x => κ.densityProcess ν n a x s) 1 (ν a)
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
n : ℕ
a : α
s : Set β
hs : MeasurableSet s
⊢ Measurable fun x => κ.densityProcess ν n a x s

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝¹ : CountablyGenerated γ
κ : Kernel α (γ × β)
ν : Kernel α γ
hκν : κ.fst ≤ ν
inst✝ : IsFiniteKernel ν
n : ℕ
a : α
s : Set β
hs : MeasurableSet s
⊢ eLpNorm (fun x => κ.densityProcess ν n a x s) 1 (ν a) < ⊤
tactic: refine ⟨Measurable.aestronglyMeasurable ?_, ?_⟩
Theorem: MellinConvergent.cpow_smul
File: Mathlib/Analysis/MellinTransform.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
s a : ℂ
⊢ MellinConvergent (fun t => ↑t ^ a • f t) s ↔ MellinConvergent f (s + a)
state_after: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
s a : ℂ
t : ℝ
ht : t ∈ Ioi 0
⊢ ↑t ^ (s - 1) • (fun t => ↑t ^ a • f t) t = ↑t ^ (s + a - 1) • f t
tactic: refine integrableOn_congr_fun (fun t ht => ?_) measurableSet_Ioi
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
s a : ℂ
t : ℝ
ht : t ∈ Ioi 0
⊢ ↑t ^ (s - 1) • (fun t => ↑t ^ a • f t) t = ↑t ^ (s + a - 1) • f t
state_after: no goals
tactic: simp_rw [← sub_add_eq_add_sub, cpow_add _ _ (ofReal_ne_zero.2 <| ne_of_gt ht), mul_smul]
Theorem: MvPolynomial.support_X
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p q : MvPolynomial σ R
inst✝ : Nontrivial R
⊢ (X n).support = {Finsupp.single n 1}
state_after: no goals
tactic: classical rw [X, support_monomial, if_neg]; exact one_ne_zero
Theorem: Set.Finite.einfsep
File: Mathlib/Topology/MetricSpace/Infsep.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
hs : s.Finite
⊢ s.einfsep = ⋯.toFinset.inf (uncurry edist)
state_after: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
hs : s.Finite
x✝ : ℝ≥0∞
⊢ x✝ ≤ s.einfsep ↔ x✝ ≤ ⋯.toFinset.inf (uncurry edist)
tactic: refine eq_of_forall_le_iff fun _ => ?_
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
hs : s.Finite
x✝ : ℝ≥0∞
⊢ x✝ ≤ s.einfsep ↔ x✝ ≤ ⋯.toFinset.inf (uncurry edist)
state_after: no goals
tactic: simp_rw [le_einfsep_iff, imp_forall_iff, Finset.le_inf_iff, Finite.mem_toFinset, mem_offDiag,
    Prod.forall, uncurry_apply_pair, and_imp]
Theorem: HasDerivAtFilter.sub
File: Mathlib/Analysis/Calculus/Deriv/Add.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
hf : HasDerivAtFilter f f' x L
hg : HasDerivAtFilter g g' x L
⊢ HasDerivAtFilter (fun x => f x - g x) (f' - g') x L
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using hf.add hg.neg
Theorem: Ideal.ramificationIdx_of_not_le
File: Mathlib/NumberTheory/RamificationInertia.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
h : ¬map f p ≤ P
⊢ map f p ≤ P ^ 0
state_after: no goals
tactic: simp
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
h : ¬map f p ≤ P
⊢ ¬map f p ≤ P ^ (0 + 1)
state_after: no goals
tactic: simpa using h
Theorem: Set.image_const_mul_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
⊢ (fun x => a * x) '' [[b, c]] = [[a * b, a * c]]
state_after: no goals
tactic: simpa only [mul_comm] using image_mul_const_uIcc a b c
Theorem: Linarith.zero_mul_eq
File: Mathlib/Tactic/Linarith/Lemmas.lean

Proof steps:
state_before: α : Type u_1
R : α → α → Prop
inst✝ : Semiring α
a b : α
h : a = 0
x✝ : R b 0
⊢ a * b = 0
state_after: no goals
tactic: simp [h]
Theorem: Finset.inf_congr
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeInf α
inst✝ : OrderTop α
s s₁ s₂ : Finset β
f✝ g✝ : β → α
a : α
f g : β → α
hs : s₁ = s₂
hfg : ∀ a ∈ s₂, f a = g a
⊢ s₁.inf f = s₂.inf g
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeInf α
inst✝ : OrderTop α
s s₁ : Finset β
f✝ g✝ : β → α
a : α
f g : β → α
hfg : ∀ a ∈ s₁, f a = g a
⊢ s₁.inf f = s₁.inf g
tactic: subst hs
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeInf α
inst✝ : OrderTop α
s s₁ : Finset β
f✝ g✝ : β → α
a : α
f g : β → α
hfg : ∀ a ∈ s₁, f a = g a
⊢ s₁.inf f = s₁.inf g
state_after: no goals
tactic: exact Finset.fold_congr hfg
Theorem: UniformCauchySeqOnFilter.mono_left
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
⊢ UniformCauchySeqOnFilter F p'' p'
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
u : Set (β × β)
hu : u ∈ 𝓤 β
⊢ ∀ᶠ (m : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F m.1.1 m.2, F m.1.2 m.2) ∈ u
tactic: intro u hu
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
u : Set (β × β)
hu : u ∈ 𝓤 β
⊢ ∀ᶠ (m : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F m.1.1 m.2, F m.1.2 m.2) ∈ u
state_after: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
u : Set (β × β)
hu : u ∈ 𝓤 β
this : ∀ᶠ (x : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F x.1.1 x.2, F x.1.2 x.2) ∈ u
⊢ ∀ᶠ (m : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F m.1.1 m.2, F m.1.2 m.2) ∈ u
tactic: have := (hf u hu).filter_mono (p'.prod_mono_left (Filter.prod_mono hp hp))
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
p'' : Filter ι
hf : UniformCauchySeqOnFilter F p p'
hp : p'' ≤ p
u : Set (β × β)
hu : u ∈ 𝓤 β
this : ∀ᶠ (x : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F x.1.1 x.2, F x.1.2 x.2) ∈ u
⊢ ∀ᶠ (m : (ι × ι) × α) in (p'' ×ˢ p'') ×ˢ p', (F m.1.1 m.2, F m.1.2 m.2) ∈ u
state_after: no goals
tactic: exact this.mono (by simp)
Theorem: Polynomial.card_support_eq
File: Mathlib/Algebra/Polynomial/EraseLead.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
n : ℕ
⊢ f.support.card = n ↔ ∃ k x, ∃ (_ : StrictMono k) (_ : ∀ (i : Fin n), x i ≠ 0), f = ∑ i : Fin n, C (x i) * X ^ k i
state_after: R : Type u_1
inst✝ : Semiring R
f : R[X]
n : ℕ
⊢ f.support.card = n → ∃ k x, ∃ (_ : StrictMono k) (_ : ∀ (i : Fin n), x i ≠ 0), f = ∑ i : Fin n, C (x i) * X ^ k i
tactic: refine ⟨?_, fun ⟨k, x, hk, hx, hf⟩ => hf.symm ▸ card_support_eq' k x hk.injective hx⟩
state_before: R : Type u_1
inst✝ : Semiring R
f : R[X]
n : ℕ
⊢ f.support.card = n → ∃ k x, ∃ (_ : StrictMono k) (_ : ∀ (i : Fin n), x i ≠ 0), f = ∑ i : Fin n, C (x i) * X ^ k i
state_after: case zero
R : Type u_1
inst✝ : Semiring R
f : R[X]
⊢ f.support.card = 0 → ∃ k x, ∃ (_ : StrictMono k) (_ : ∀ (i : Fin 0), x i ≠ 0), f = ∑ i : Fin 0, C (x i) * X ^ k i

case succ
R : Type u_1
inst✝ : Semiring R
n : ℕ
hn :
  ∀ {f : R[X]},
    f.support.card = n → ∃ k x, ∃ (_ : StrictMono k) (_ : ∀ (i : Fin n), x i ≠ 0), f = ∑ i : Fin n, C (x i) * X ^ k i
f : R[X]
⊢ f.support.card = n + 1 →
    ∃ k x, ∃ (_ : StrictMono k) (_ : ∀ (i : Fin (n + 1)), x i ≠ 0), f = ∑ i : Fin (n + 1), C (x i) * X ^ k i
tactic: induction' n with n hn generalizing f