ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: HasFDerivAt.multiset_prod
File: Mathlib/Analysis/Calculus/FDeriv/Mul.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace 𝕜 E
F : Type u_3
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : NormedSpace 𝕜 G
G' : Type u_5
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
ι : Type u_6
𝔸 : Type u_7
𝔸' : Type u_8
inst✝⁴ : NormedRing 𝔸
inst✝³ : NormedCommRing 𝔸'
inst✝² : NormedAlgebra 𝕜 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝔸'
u✝ : Finset ι
f : ι → E → 𝔸
f' : ι → E →L[𝕜] 𝔸
g : ι → E → 𝔸'
g' : ι → E →L[𝕜] 𝔸'
inst✝ : DecidableEq ι
u : Multiset ι
x : E
h : ∀ i ∈ u, HasFDerivAt (fun x => g i x) (g' i) x
⊢ HasFDerivAt (fun x => (Multiset.map (fun x_1 => g x_1 x) u).prod)
    (Multiset.map (fun i => (Multiset.map (fun x_1 => g x_1 x) (u.erase i)).prod • g' i) u).sum x
state_after: 𝕜 : Type u_1
inst✝¹³ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹² : NormedAddCommGroup E
inst✝¹¹ : NormedSpace 𝕜 E
F : Type u_3
inst✝¹⁰ : NormedAddCommGroup F
inst✝⁹ : NormedSpace 𝕜 F
G : Type u_4
inst✝⁸ : NormedAddCommGroup G
inst✝⁷ : NormedSpace 𝕜 G
G' : Type u_5
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
ι : Type u_6
𝔸 : Type u_7
𝔸' : Type u_8
inst✝⁴ : NormedRing 𝔸
inst✝³ : NormedCommRing 𝔸'
inst✝² : NormedAlgebra 𝕜 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝔸'
u✝ : Finset ι
f : ι → E → 𝔸
f' : ι → E →L[𝕜] 𝔸
g : ι → E → 𝔸'
g' : ι → E →L[𝕜] 𝔸'
inst✝ : DecidableEq ι
u : Multiset ι
x : E
h : ∀ i ∈ u, HasFDerivAt (fun x => g i x) (g' i) x
⊢ HasFDerivAt (fun x => (Multiset.map ((fun x_1 => g x_1 x) ∘ Subtype.val) u.attach).prod)
    (Multiset.map
        ((fun x_1 =>
            (Multiset.map (fun x_2 => g x_2 x) ((Multiset.map Subtype.val u.attach).erase x_1)).prod • g' x_1) ∘
          Subtype.val)
        u.attach).sum
    x
tactic: simp only [← Multiset.attach_map_val u, Multiset.map_map]
Theorem: IsPrimitiveRoot.prime_norm_toInteger_sub_one_of_prime_ne_two'
File: Mathlib/NumberTheory/Cyclotomic/Rat.lean

Proof steps:
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
hodd : p ≠ 2
⊢ Prime ((Algebra.norm ℤ) (hζ.toInteger - 1))
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
hodd : p ≠ 2
this : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
⊢ Prime ((Algebra.norm ℤ) (hζ.toInteger - 1))
tactic: have : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K := by simpa using hcycl
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ : IsPrimitiveRoot ζ ↑p
hodd : p ≠ 2
this : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
⊢ Prime ((Algebra.norm ℤ) (hζ.toInteger - 1))
state_after: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ✝ : IsPrimitiveRoot ζ ↑p
hodd : p ≠ 2
this : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
hζ : IsPrimitiveRoot ζ (↑p ^ (0 + 1))
⊢ Prime ((Algebra.norm ℤ) (hζ✝.toInteger - 1))
tactic: replace hζ : IsPrimitiveRoot ζ (p ^ (0 + 1)) := by simpa using hζ
state_before: p : ℕ+
k : ℕ
K : Type u
inst✝¹ : Field K
inst✝ : CharZero K
ζ : K
hp : Fact (Nat.Prime ↑p)
hcycl : IsCyclotomicExtension {p} ℚ K
hζ✝ : IsPrimitiveRoot ζ ↑p
hodd : p ≠ 2
this : IsCyclotomicExtension {p ^ (0 + 1)} ℚ K
hζ : IsPrimitiveRoot ζ (↑p ^ (0 + 1))
⊢ Prime ((Algebra.norm ℤ) (hζ✝.toInteger - 1))
state_after: no goals
tactic: exact hζ.prime_norm_toInteger_sub_one_of_prime_ne_two hodd
Theorem: List.sum_toFinset
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
M : Type u_6
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
x✝ : [].Nodup
⊢ [].toFinset.prod f = (map f []).prod
state_after: no goals
tactic: simp
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
M : Type u_6
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
l : List α
hl : (a :: l).Nodup
⊢ (a :: l).toFinset.prod f = (map f (a :: l)).prod
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
M : Type u_6
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
l : List α
hl✝ : (a :: l).Nodup
not_mem : a ∉ l
hl : l.Nodup
⊢ (a :: l).toFinset.prod f = (map f (a :: l)).prod
tactic: let ⟨not_mem, hl⟩ := List.nodup_cons.mp hl
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
M : Type u_6
inst✝¹ : DecidableEq α
inst✝ : CommMonoid M
f : α → M
a : α
l : List α
hl✝ : (a :: l).Nodup
not_mem : a ∉ l
hl : l.Nodup
⊢ (a :: l).toFinset.prod f = (map f (a :: l)).prod
state_after: no goals
tactic: simp [Finset.prod_insert (mt List.mem_toFinset.mp not_mem), prod_toFinset _ hl]
Theorem: AffineSubspace.direction_top
File: Mathlib/LinearAlgebra/AffineSpace/AffineSubspace.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ : P
⊢ ⊤.direction = ⊤
state_after: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p : P
⊢ ⊤.direction = ⊤
tactic: cases' S.nonempty with p
state_before: case intro
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p : P
⊢ ⊤.direction = ⊤
state_after: case intro.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p : P
v : V
⊢ v ∈ ⊤.direction ↔ v ∈ ⊤
tactic: ext v
state_before: case intro.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p : P
v : V
⊢ v ∈ ⊤.direction ↔ v ∈ ⊤
state_after: case intro.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p : P
v : V
_hv : v ∈ ⊤
⊢ v ∈ ⊤.direction
tactic: refine ⟨imp_intro Submodule.mem_top, fun _hv => ?_⟩
state_before: case intro.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p : P
v : V
_hv : v ∈ ⊤
⊢ v ∈ ⊤.direction
state_after: case intro.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p : P
v : V
_hv : v ∈ ⊤
hpv : v +ᵥ p -ᵥ p ∈ ⊤.direction
⊢ v ∈ ⊤.direction
tactic: have hpv : (v +ᵥ p -ᵥ p : V) ∈ (⊤ : AffineSubspace k P).direction :=
    vsub_mem_direction (mem_top k V _) (mem_top k V _)
state_before: case intro.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
p₁ p₂ p : P
v : V
_hv : v ∈ ⊤
hpv : v +ᵥ p -ᵥ p ∈ ⊤.direction
⊢ v ∈ ⊤.direction
state_after: no goals
tactic: rwa [vadd_vsub] at hpv
Theorem: hasSum_geometric_of_norm_lt_one
File: Mathlib/Analysis/SpecificLimits/Normed.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : ‖ξ‖ < 1
⊢ HasSum (fun n => ξ ^ n) (1 - ξ)⁻¹
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : ‖ξ‖ < 1
xi_ne_one : ξ ≠ 1
⊢ HasSum (fun n => ξ ^ n) (1 - ξ)⁻¹
tactic: have xi_ne_one : ξ ≠ 1 := by
    contrapose! h
    simp [h]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : ‖ξ‖ < 1
xi_ne_one : ξ ≠ 1
⊢ HasSum (fun n => ξ ^ n) (1 - ξ)⁻¹
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : ‖ξ‖ < 1
xi_ne_one : ξ ≠ 1
A : Tendsto (fun n => (ξ ^ n - 1) * (ξ - 1)⁻¹) atTop (𝓝 ((0 - 1) * (ξ - 1)⁻¹))
⊢ HasSum (fun n => ξ ^ n) (1 - ξ)⁻¹
tactic: have A : Tendsto (fun n ↦ (ξ ^ n - 1) * (ξ - 1)⁻¹) atTop (𝓝 ((0 - 1) * (ξ - 1)⁻¹)) :=
    ((tendsto_pow_atTop_nhds_zero_of_norm_lt_one h).sub tendsto_const_nhds).mul tendsto_const_nhds
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : ‖ξ‖ < 1
xi_ne_one : ξ ≠ 1
A : Tendsto (fun n => (ξ ^ n - 1) * (ξ - 1)⁻¹) atTop (𝓝 ((0 - 1) * (ξ - 1)⁻¹))
⊢ HasSum (fun n => ξ ^ n) (1 - ξ)⁻¹
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : ‖ξ‖ < 1
xi_ne_one : ξ ≠ 1
A : Tendsto (fun n => (ξ ^ n - 1) * (ξ - 1)⁻¹) atTop (𝓝 ((0 - 1) * (ξ - 1)⁻¹))
⊢ Tendsto (fun n => ∑ i ∈ Finset.range n, ξ ^ i) atTop (𝓝 (1 - ξ)⁻¹)

α : Type u_1
β : Type u_2
ι : Type u_3
K : Type u_4
inst✝ : NormedDivisionRing K
ξ : K
h : ‖ξ‖ < 1
xi_ne_one : ξ ≠ 1
A : Tendsto (fun n => (ξ ^ n - 1) * (ξ - 1)⁻¹) atTop (𝓝 ((0 - 1) * (ξ - 1)⁻¹))
⊢ Summable fun i => ‖ξ ^ i‖
tactic: rw [hasSum_iff_tendsto_nat_of_summable_norm]
Theorem: List.sublists'Aux_eq_array_foldl
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
a : α
⊢ ∀ (r₁ r₂ : List (List α)),
    sublists'Aux a r₁ r₂ = (Array.foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁) 0).toList
state_after: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
⊢ sublists'Aux a r₁ r₂ = (Array.foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁) 0).toList
tactic: intro r₁ r₂
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
⊢ sublists'Aux a r₁ r₂ = (Array.foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁) 0).toList
state_after: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
⊢ foldl (fun r l => r ++ [a :: l]) r₂ r₁ = (foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁).data).toList
tactic: rw [sublists'Aux, Array.foldl_eq_foldl_data]
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
⊢ foldl (fun r l => r ++ [a :: l]) r₂ r₁ = (foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁).data).toList
state_after: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
this :
  foldl (fun r l => r ++ [a :: l]) (toArray r₂).toList r₁ = (foldl (fun r l => r.push (a :: l)) (toArray r₂) r₁).toList
⊢ foldl (fun r l => r ++ [a :: l]) r₂ r₁ = (foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁).data).toList
tactic: have := List.foldl_hom Array.toList (fun r l => r.push (a :: l))
    (fun r l => r ++ [a :: l]) r₁ r₂.toArray (by simp)
state_before: α : Type u
β : Type v
γ : Type w
a : α
r₁ r₂ : List (List α)
this :
  foldl (fun r l => r ++ [a :: l]) (toArray r₂).toList r₁ = (foldl (fun r l => r.push (a :: l)) (toArray r₂) r₁).toList
⊢ foldl (fun r l => r ++ [a :: l]) r₂ r₁ = (foldl (fun r l => r.push (a :: l)) (toArray r₂) (toArray r₁).data).toList
state_after: no goals
tactic: simpa using this
Theorem: Finset.card_filter
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
p : α → Prop
inst✝ : DecidablePred p
s : Finset α
⊢ (filter p s).card = ∑ a ∈ s, if p a then 1 else 0
state_after: no goals
tactic: simp [sum_ite]
Theorem: Ideal.powQuotSuccInclusion_injective
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
hfp : NeZero e
i : ℕ
⊢ Function.Injective ⇑(powQuotSuccInclusion f p P i)
state_after: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
⊢ ∀ (m : ↥(map (Quotient.mk (P ^ e)) (P ^ (i + 1)))), (powQuotSuccInclusion f p P i) m = 0 → m = 0
tactic: rw [← LinearMap.ker_eq_bot, LinearMap.ker_eq_bot']
state_before: R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
⊢ ∀ (m : ↥(map (Quotient.mk (P ^ e)) (P ^ (i + 1)))), (powQuotSuccInclusion f p P i) m = 0 → m = 0
state_after: case mk
R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
x : S ⧸ P ^ e
hx : x ∈ map (Quotient.mk (P ^ e)) (P ^ (i + 1))
hx0 : (powQuotSuccInclusion f p P i) ⟨x, hx⟩ = 0
⊢ ⟨x, hx⟩ = 0
tactic: rintro ⟨x, hx⟩ hx0
state_before: case mk
R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
x : S ⧸ P ^ e
hx : x ∈ map (Quotient.mk (P ^ e)) (P ^ (i + 1))
hx0 : (powQuotSuccInclusion f p P i) ⟨x, hx⟩ = 0
⊢ ⟨x, hx⟩ = 0
state_after: case mk
R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
x : S ⧸ P ^ e
hx : x ∈ map (Quotient.mk (P ^ e)) (P ^ (i + 1))
hx0 : ↑((powQuotSuccInclusion f p P i) ⟨x, hx⟩) = ↑0
⊢ ↑⟨x, hx⟩ = ↑0
tactic: rw [Subtype.ext_iff] at hx0 ⊢
state_before: case mk
R : Type u
inst✝¹ : CommRing R
S : Type v
inst✝ : CommRing S
f : R →+* S
p : Ideal R
P : Ideal S
hfp : NeZero e
i : ℕ
x : S ⧸ P ^ e
hx : x ∈ map (Quotient.mk (P ^ e)) (P ^ (i + 1))
hx0 : ↑((powQuotSuccInclusion f p P i) ⟨x, hx⟩) = ↑0
⊢ ↑⟨x, hx⟩ = ↑0
state_after: no goals
tactic: rwa [powQuotSuccInclusion_apply_coe] at hx0
Theorem: MeasureTheory.Lp.norm_const'
File: Mathlib/MeasureTheory/Function/LpSpace.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
inst✝ : IsFiniteMeasure μ
c : E
hp_zero : p ≠ 0
hp_top : p ≠ ⊤
⊢ ‖(Lp.const p μ) c‖ = ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)
state_after: α : 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
inst✝ : IsFiniteMeasure μ
c : E
hp_zero : p ≠ 0
hp_top : p ≠ ⊤
⊢ (↑‖c‖₊ * μ Set.univ ^ (1 / p.toReal)).toReal = ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)
tactic: rw [← Memℒp.toLp_const, Lp.norm_toLp, eLpNorm_const'] <;> try assumption
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
inst✝ : IsFiniteMeasure μ
c : E
hp_zero : p ≠ 0
hp_top : p ≠ ⊤
⊢ (↑‖c‖₊ * μ Set.univ ^ (1 / p.toReal)).toReal = ‖c‖ * (μ Set.univ).toReal ^ (1 / p.toReal)
state_after: no goals
tactic: rw [ENNReal.toReal_mul, ENNReal.coe_toReal, ← ENNReal.toReal_rpow, coe_nnnorm]
Theorem: Complex.nhdsWithin_stolzCone_le_nhdsWithin_stolzSet
File: Mathlib/Analysis/Complex/AbelLimit.lean

Proof steps:
state_before: s : ℝ
hs : 0 < s
⊢ ∃ M, 𝓝[stolzCone s] 1 ≤ 𝓝[stolzSet M] 1
state_after: case intro.intro.intro.intro
s : ℝ
hs : 0 < s
M ε : ℝ
left✝ : 0 < M
hε : 0 < ε
H : {z | 1 - ε < z.re} ∩ stolzCone s ⊆ stolzSet M
⊢ ∃ M, 𝓝[stolzCone s] 1 ≤ 𝓝[stolzSet M] 1
tactic: obtain ⟨M, ε, _, hε, H⟩ := stolzCone_subset_stolzSet_aux hs
state_before: case intro.intro.intro.intro
s : ℝ
hs : 0 < s
M ε : ℝ
left✝ : 0 < M
hε : 0 < ε
H : {z | 1 - ε < z.re} ∩ stolzCone s ⊆ stolzSet M
⊢ ∃ M, 𝓝[stolzCone s] 1 ≤ 𝓝[stolzSet M] 1
state_after: case h
s : ℝ
hs : 0 < s
M ε : ℝ
left✝ : 0 < M
hε : 0 < ε
H : {z | 1 - ε < z.re} ∩ stolzCone s ⊆ stolzSet M
⊢ 𝓝[stolzCone s] 1 ≤ 𝓝[stolzSet M] 1
tactic: use M
state_before: case h
s : ℝ
hs : 0 < s
M ε : ℝ
left✝ : 0 < M
hε : 0 < ε
H : {z | 1 - ε < z.re} ∩ stolzCone s ⊆ stolzSet M
⊢ 𝓝[stolzCone s] 1 ≤ 𝓝[stolzSet M] 1
state_after: case h
s : ℝ
hs : 0 < s
M ε : ℝ
left✝ : 0 < M
hε : 0 < ε
H : {z | 1 - ε < z.re} ∩ stolzCone s ⊆ stolzSet M
⊢ ∃ u, IsOpen u ∧ 1 ∈ u ∧ u ∩ stolzCone s ⊆ stolzSet M
tactic: rw [nhdsWithin_le_iff, mem_nhdsWithin]
state_before: case h
s : ℝ
hs : 0 < s
M ε : ℝ
left✝ : 0 < M
hε : 0 < ε
H : {z | 1 - ε < z.re} ∩ stolzCone s ⊆ stolzSet M
⊢ ∃ u, IsOpen u ∧ 1 ∈ u ∧ u ∩ stolzCone s ⊆ stolzSet M
state_after: case h
s : ℝ
hs : 0 < s
M ε : ℝ
left✝ : 0 < M
hε : 0 < ε
H : {z | 1 - ε < z.re} ∩ stolzCone s ⊆ stolzSet M
⊢ 1 ∈ {w | 1 - ε < w.re}
tactic: refine ⟨{w | 1 - ε < w.re}, isOpen_lt continuous_const continuous_re, ?_, H⟩
state_before: case h
s : ℝ
hs : 0 < s
M ε : ℝ
left✝ : 0 < M
hε : 0 < ε
H : {z | 1 - ε < z.re} ∩ stolzCone s ⊆ stolzSet M
⊢ 1 ∈ {w | 1 - ε < w.re}
state_after: no goals
tactic: simp only [Set.mem_setOf_eq, one_re, sub_lt_self_iff, hε]
Theorem: zpow_sub₀
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝¹ : MonoidWithZero M₀
inst✝ : GroupWithZero G₀
a b c d : G₀
m✝ n✝ : ℕ
ha : a ≠ 0
m n : ℤ
⊢ a ^ (m - n) = a ^ m / a ^ n
state_after: no goals
tactic: rw [Int.sub_eq_add_neg, zpow_add₀ ha, zpow_neg, div_eq_mul_inv]
Theorem: Basis.addHaar_eq_iff
File: Mathlib/MeasureTheory/Measure/Haar/OfBasis.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
E : Type u_3
F : Type u_4
inst✝¹⁰ : Fintype ι
inst✝⁹ : Fintype ι'
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : MeasurableSpace E
inst✝³ : BorelSpace E
inst✝² : SecondCountableTopology E
b : Basis ι ℝ E
μ : Measure E
inst✝¹ : SigmaFinite μ
inst✝ : μ.IsAddLeftInvariant
⊢ b.addHaar = μ ↔ μ ↑b.parallelepiped = 1
state_after: ι : Type u_1
ι' : Type u_2
E : Type u_3
F : Type u_4
inst✝¹⁰ : Fintype ι
inst✝⁹ : Fintype ι'
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : MeasurableSpace E
inst✝³ : BorelSpace E
inst✝² : SecondCountableTopology E
b : Basis ι ℝ E
μ : Measure E
inst✝¹ : SigmaFinite μ
inst✝ : μ.IsAddLeftInvariant
⊢ addHaarMeasure b.parallelepiped = μ ↔ μ ↑b.parallelepiped = 1
tactic: rw [Basis.addHaar_def]
state_before: ι : Type u_1
ι' : Type u_2
E : Type u_3
F : Type u_4
inst✝¹⁰ : Fintype ι
inst✝⁹ : Fintype ι'
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedSpace ℝ F
inst✝⁴ : MeasurableSpace E
inst✝³ : BorelSpace E
inst✝² : SecondCountableTopology E
b : Basis ι ℝ E
μ : Measure E
inst✝¹ : SigmaFinite μ
inst✝ : μ.IsAddLeftInvariant
⊢ addHaarMeasure b.parallelepiped = μ ↔ μ ↑b.parallelepiped = 1
state_after: no goals
tactic: exact addHaarMeasure_eq_iff b.parallelepiped μ
Theorem: LieModule.toEnd_module_end
File: Mathlib/Algebra/Lie/OfAssociative.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
⊢ toEnd R (Module.End R M) M = LieHom.id
state_after: case h.h
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
g : Module.End R M
m : M
⊢ ((toEnd R (Module.End R M) M) g) m = (LieHom.id g) m
tactic: ext g m
state_before: case h.h
R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
g : Module.End R M
m : M
⊢ ((toEnd R (Module.End R M) M) g) m = (LieHom.id g) m
state_after: no goals
tactic: simp [lie_eq_smul]
Theorem: List.monotone_sum_take
File: Mathlib/Algebra/Order/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : CanonicallyOrderedCommMonoid M
l L : List M
⊢ Monotone fun i => (take i L).prod
state_after: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : CanonicallyOrderedCommMonoid M
l L : List M
n : ℕ
⊢ (take n L).prod ≤ (take (n + 1) L).prod
tactic: refine monotone_nat_of_le_succ fun n => ?_
state_before: ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : CanonicallyOrderedCommMonoid M
l L : List M
n : ℕ
⊢ (take n L).prod ≤ (take (n + 1) L).prod
state_after: case inl
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : CanonicallyOrderedCommMonoid M
l L : List M
n : ℕ
h : n < L.length
⊢ (take n L).prod ≤ (take (n + 1) L).prod

case inr
ι : Type u_1
α : Type u_2
M : Type u_3
N : Type u_4
P : Type u_5
M₀ : Type u_6
G : Type u_7
R : Type u_8
inst✝ : CanonicallyOrderedCommMonoid M
l L : List M
n : ℕ
h : L.length ≤ n
⊢ (take n L).prod ≤ (take (n + 1) L).prod
tactic: cases' lt_or_le n L.length with h h
Theorem: Order.Ideal.IsPrime.of_mem_or_mem
File: Mathlib/Order/PrimeIdeal.lean

Proof steps:
state_before: P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : I.IsProper
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ I.IsPrime
state_after: P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : I.IsProper
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ I.IsProper ∧ IsPFilter (↑I)ᶜ
tactic: rw [isPrime_iff]
state_before: P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : I.IsProper
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ I.IsProper ∧ IsPFilter (↑I)ᶜ
state_after: case right
P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : I.IsProper
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ IsPFilter (↑I)ᶜ
tactic: use ‹_›
state_before: case right
P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : I.IsProper
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ IsPFilter (↑I)ᶜ
state_after: case right.refine_1
P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : I.IsProper
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ (↑I)ᶜ.Nonempty

case right.refine_2
P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : I.IsProper
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ DirectedOn (fun x x_1 => x ≥ x_1) (↑I)ᶜ

case right.refine_3
P : Type u_1
inst✝¹ : SemilatticeInf P
x y : P
I : Ideal P
inst✝ : I.IsProper
hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I
⊢ ∀ {x y : P}, x ≤ y → x ∈ (↑I)ᶜ → y ∈ (↑I)ᶜ
tactic: refine .of_def ?_ ?_ ?_
Theorem: AdicCompletion.ofTensorProduct_bijective_of_pi_of_fintype
File: Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean

Proof steps:
state_before: R : Type u_1
inst✝⁵ : CommRing R
I : Ideal R
M : Type u_2
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
N : Type u_3
inst✝² : AddCommGroup N
inst✝¹ : Module R N
ι : Type u_4
inst✝ : Finite ι
⊢ Function.Bijective ⇑(ofTensorProduct I (ι → R))
state_after: no goals
tactic: classical
  cases nonempty_fintype ι
  exact EquivLike.bijective (ofTensorProductEquivOfPiFintype I ι)
Theorem: WeierstrassCurve.Affine.equation_neg_iff
File: Mathlib/AlgebraicGeometry/EllipticCurve/Affine.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ W.Equation x (W.negY x y) ↔ W.Equation x y
state_after: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ (-y - W.a₁ * x - W.a₃) ^ 2 + W.a₁ * x * (-y - W.a₁ * x - W.a₃) + W.a₃ * (-y - W.a₁ * x - W.a₃) =
      x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆ ↔
    y ^ 2 + W.a₁ * x * y + W.a₃ * y = x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆
tactic: rw [equation_iff, equation_iff, negY]
state_before: R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ (-y - W.a₁ * x - W.a₃) ^ 2 + W.a₁ * x * (-y - W.a₁ * x - W.a₃) + W.a₃ * (-y - W.a₁ * x - W.a₃) =
      x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆ ↔
    y ^ 2 + W.a₁ * x * y + W.a₃ * y = x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆
state_after: case a.h.e'_2
R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ (-y - W.a₁ * x - W.a₃) ^ 2 + W.a₁ * x * (-y - W.a₁ * x - W.a₃) + W.a₃ * (-y - W.a₁ * x - W.a₃) =
    y ^ 2 + W.a₁ * x * y + W.a₃ * y
tactic: congr! 1
state_before: case a.h.e'_2
R : Type u
inst✝ : CommRing R
W : Affine R
x y : R
⊢ (-y - W.a₁ * x - W.a₃) ^ 2 + W.a₁ * x * (-y - W.a₁ * x - W.a₃) + W.a₃ * (-y - W.a₁ * x - W.a₃) =
    y ^ 2 + W.a₁ * x * y + W.a₃ * y
state_after: no goals
tactic: ring1