tasksource/leandojo huggingface dataset:
Theorem: LinearMap.adjoint_adjoint
File: Mathlib/Analysis/InnerProductSpace/Adjoint.lean

tactic: ext v
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1748753
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
⊢ ↑adjoint (↑adjoint A) = A

tactic: refine' ext_inner_left 𝕜 fun w => _
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1748753
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
v : E
⊢ ↑(↑adjoint (↑adjoint A)) v = ↑A v

tactic: rw [adjoint_inner_right, adjoint_inner_left]
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type ?u.1748753
inst✝⁹ : IsROrC 𝕜
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : InnerProductSpace 𝕜 F
inst✝³ : InnerProductSpace 𝕜 G
inst✝² : FiniteDimensional 𝕜 E
inst✝¹ : FiniteDimensional 𝕜 F
inst✝ : FiniteDimensional 𝕜 G
A : E →ₗ[𝕜] F
v : E
w : (fun x => F) v
⊢ inner w (↑(↑adjoint (↑adjoint A)) v) = inner w (↑A v)
Theorem: Fin.prod_univ_four
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [prod_univ_castSucc, prod_univ_three]
state_before: α : Type ?u.20144
β : Type u_1
inst✝ : CommMonoid β
f : Fin 4 → β
⊢ ∏ i : Fin 4, f i = f 0 * f 1 * f 2 * f 3

tactic: rfl
state_before: α : Type ?u.20144
β : Type u_1
inst✝ : CommMonoid β
f : Fin 4 → β
⊢ f (↑castSucc 0) * f (↑castSucc 1) * f (↑castSucc 2) * f (last 3) = f 0 * f 1 * f 2 * f 3
Theorem: linearIndependent_comp_subtype_disjoint
File: Mathlib/LinearAlgebra/LinearIndependent.lean

tactic: rw [linearIndependent_comp_subtype, LinearMap.disjoint_ker]
state_before: ι : Type u'
ι' : Type ?u.199259
R : Type u_1
K : Type ?u.199265
M : Type u_2
M' : Type ?u.199271
M'' : Type ?u.199274
V : Type u
V' : Type ?u.199279
v : ι → M
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M'
inst✝³ : AddCommMonoid M''
inst✝² : Module R M
inst✝¹ : Module R M'
inst✝ : Module R M''
a b : R
x y : M
s : Set ι
⊢ LinearIndependent R (v ∘ Subtype.val) ↔ Disjoint (Finsupp.supported R R s) (LinearMap.ker (Finsupp.total ι M R v))
Theorem: Matrix.col_add
File: Mathlib/Data/Matrix/Basic.lean

tactic: ext
state_before: l : Type ?u.1212442
m : Type u_1
n : Type ?u.1212448
o : Type ?u.1212451
m' : o → Type ?u.1212456
n' : o → Type ?u.1212461
R : Type ?u.1212464
S : Type ?u.1212467
α : Type v
β : Type w
γ : Type ?u.1212474
inst✝ : Add α
v w : m → α
⊢ col (v + w) = col v + col w

tactic: rfl
state_before: case a.h
l : Type ?u.1212442
m : Type u_1
n : Type ?u.1212448
o : Type ?u.1212451
m' : o → Type ?u.1212456
n' : o → Type ?u.1212461
R : Type ?u.1212464
S : Type ?u.1212467
α : Type v
β : Type w
γ : Type ?u.1212474
inst✝ : Add α
v w : m → α
i✝ : m
x✝ : Unit
⊢ col (v + w) i✝ x✝ = (col v + col w) i✝ x✝
Theorem: Int.emod_neg
File: Std/Data/Int/DivMod.lean

tactic: rw [emod_def, emod_def, Int.ediv_neg, Int.neg_mul_neg]
state_before: a b : Int
⊢ a % -b = a % b
Theorem: closure_eq_uniformity
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: ext ⟨x, y⟩
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.85860
inst✝ : UniformSpace α
s : Set (α × α)
⊢ closure s = ⋂ (V : Set (α × α)) (_ : V ∈ {V | V ∈ 𝓤 α ∧ SymmetricRel V}), V ○ s ○ V

tactic: simp (config := { contextual := true }) only
  [mem_closure_iff_nhds_basis (UniformSpace.hasBasis_nhds_prod x y), mem_iInter, mem_setOf_eq,
    and_imp, mem_comp_comp, exists_prop, ← mem_inter_iff, inter_comm, Set.Nonempty]
state_before: case h.mk
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort ?u.85860
inst✝ : UniformSpace α
s : Set (α × α)
x y : α
⊢ (x, y) ∈ closure s ↔ (x, y) ∈ ⋂ (V : Set (α × α)) (_ : V ∈ {V | V ∈ 𝓤 α ∧ SymmetricRel V}), V ○ s ○ V
Theorem: ENNReal.iInf_mul_right'
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: simpa only [mul_comm a] using iInf_mul_left' h h0
state_before: α : Type ?u.118140
β : Type ?u.118143
γ : Type ?u.118146
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
ι : Sort u_1
f : ι → ℝ≥0∞
a : ℝ≥0∞
h : a = ⊤ → (⨅ (i : ι), f i) = 0 → ∃ i, f i = 0
h0 : a = 0 → Nonempty ι
⊢ (⨅ (i : ι), f i * a) = (⨅ (i : ι), f i) * a
Theorem: OreLocalization.zero_mul
File: Mathlib/RingTheory/OreLocalization/Basic.lean

tactic: induction' x using OreLocalization.ind with r s
state_before: R : Type u_1
inst✝¹ : Semiring R
S : Submonoid R
inst✝ : OreSet S
x : OreLocalization R S
⊢ 0 * x = 0

tactic: rw [OreLocalization.zero_def, oreDiv_mul_char 0 r 1 s r 1 (by simp)]
state_before: case c
R : Type u_1
inst✝¹ : Semiring R
S : Submonoid R
inst✝ : OreSet S
r : R
s : { x // x ∈ S }
⊢ 0 * (r /ₒ s) = 0

tactic: simp
state_before: case c
R : Type u_1
inst✝¹ : Semiring R
S : Submonoid R
inst✝ : OreSet S
r : R
s : { x // x ∈ S }
⊢ 0 * r /ₒ (s * 1) = 0 /ₒ 1

tactic: simp
state_before: R : Type u_1
inst✝¹ : Semiring R
S : Submonoid R
inst✝ : OreSet S
r : R
s : { x // x ∈ S }
⊢ r * ↑1 = ↑1 * r
Theorem: Function.Antiperiodic.periodic
File: Mathlib/Algebra/Periodic.lean

tactic: simp [two_mul, ← add_assoc, h _]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.143065
f g : α → β
c c₁ c₂ x : α
inst✝¹ : Semiring α
inst✝ : InvolutiveNeg β
h : Antiperiodic f c
⊢ Periodic f (2 * c)
Theorem: Set.range_diag
File: Mathlib/Data/Set/Prod.lean

tactic: ext ⟨x, y⟩
state_before: α : Type u_1
s t : Set α
⊢ (range fun x => (x, x)) = diagonal α

tactic: simp [diagonal, eq_comm]
state_before: case h.mk
α : Type u_1
s t : Set α
x y : α
⊢ ((x, y) ∈ range fun x => (x, x)) ↔ (x, y) ∈ diagonal α
Theorem: HasCompactSupport.smul_left'
File: Mathlib/Topology/Support.lean

tactic: rw [hasCompactSupport_iff_eventuallyEq] at hf ⊢
state_before: X : Type ?u.28023
α : Type u_1
α' : Type ?u.28029
β : Type ?u.28032
γ : Type ?u.28035
δ : Type ?u.28038
M : Type u_2
E : Type ?u.28044
R : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
f : α → R
f' : α → M
x : α
hf : HasCompactSupport f'
⊢ HasCompactSupport (f • f')

tactic: refine' hf.mono fun x hx => by simp_rw [Pi.smul_apply', hx, Pi.zero_apply, smul_zero]
state_before: X : Type ?u.28023
α : Type u_1
α' : Type ?u.28029
β : Type ?u.28032
γ : Type ?u.28035
δ : Type ?u.28038
M : Type u_2
E : Type ?u.28044
R : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
f : α → R
f' : α → M
x : α
hf : f' =ᶠ[coclosedCompact α] 0
⊢ f • f' =ᶠ[coclosedCompact α] 0

tactic: simp_rw [Pi.smul_apply', hx, Pi.zero_apply, smul_zero]
state_before: X : Type ?u.28023
α : Type u_1
α' : Type ?u.28029
β : Type ?u.28032
γ : Type ?u.28035
δ : Type ?u.28038
M : Type u_2
E : Type ?u.28044
R : Type u_3
inst✝³ : TopologicalSpace α
inst✝² : Zero R
inst✝¹ : Zero M
inst✝ : SMulWithZero R M
f : α → R
f' : α → M
x✝ : α
hf : f' =ᶠ[coclosedCompact α] 0
x : α
hx : f' x = OfNat.ofNat 0 x
⊢ (f • f') x = OfNat.ofNat 0 x
Theorem: Basis.repr_reindex
File: Mathlib/LinearAlgebra/Basis.lean

tactic: simp [repr_reindex_apply]
state_before: ι : Type u_4
ι' : Type u_1
R : Type u_2
R₂ : Type ?u.362162
K : Type ?u.362165
M : Type u_3
M' : Type ?u.362171
M'' : Type ?u.362174
V : Type u
V' : Type ?u.362179
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : Module R M
inst✝¹ : AddCommMonoid M'
inst✝ : Module R M'
b b₁ : Basis ι R M
i : ι
c : R
x : M
b' : Basis ι' R M'
e : ι ≃ ι'
⊢ ∀ (x_1 : ι'), ↑(↑(reindex b e).repr x) x_1 = ↑(Finsupp.mapDomain (↑e) (↑b.repr x)) x_1
Theorem: NNReal.summable_coe
File: Mathlib/Topology/Instances/NNReal.lean

tactic: constructor
state_before: α : Type u_1
f : α → ℝ≥0
⊢ (Summable fun a => ↑(f a)) ↔ Summable f

tactic: exact fun ⟨a, ha⟩ => ⟨⟨a, ha.nonneg fun x => (f x).2⟩, hasSum_coe.1 ha⟩
state_before: case mp
α : Type u_1
f : α → ℝ≥0
⊢ (Summable fun a => ↑(f a)) → Summable f

case mpr
α : Type u_1
f : α → ℝ≥0
⊢ Summable f → Summable fun a => ↑(f a)

tactic: exact fun ⟨a, ha⟩ => ⟨a.1, hasSum_coe.2 ha⟩
state_before: case mpr
α : Type u_1
f : α → ℝ≥0
⊢ Summable f → Summable fun a => ↑(f a)
Theorem: Ordinal.one_CNF
File: Mathlib/SetTheory/Ordinal/CantorNormalForm.lean

tactic: simp [CNF_ne_zero ho]
state_before: o : Ordinal
ho : o ≠ 0
⊢ CNF 1 o = [(0, o)]
Theorem: Submodule.iSup_eq_span
File: Mathlib/LinearAlgebra/Span.lean

tactic: simp_rw [← iSup_span, span_eq]
state_before: R : Type u_2
R₂ : Type ?u.210219
K : Type ?u.210222
M : Type u_3
M₂ : Type ?u.210228
V : Type ?u.210231
S : Type ?u.210234
inst✝⁵ : Semiring R
inst✝⁴ : AddCommMonoid M
inst✝³ : Module R M
x : M
p✝ p' : Submodule R M
inst✝² : Semiring R₂
σ₁₂ : R →+* R₂
inst✝¹ : AddCommMonoid M₂
inst✝ : Module R₂ M₂
s t : Set M
ι : Sort u_1
p : ι → Submodule R M
⊢ (⨆ (i : ι), p i) = span R (⋃ (i : ι), ↑(p i))
Theorem: Rat.cast_inv_nat
File: Mathlib/Data/Rat/Cast.lean

tactic: cases' n with n
state_before: F : Type ?u.32377
ι : Type ?u.32380
α : Type u_1
β : Type ?u.32386
inst✝ : DivisionRing α
n : ℕ
⊢ ↑(↑n)⁻¹ = (↑n)⁻¹

tactic: rw [cast_def, inv_coe_nat_num, inv_coe_nat_den, if_neg n.succ_ne_zero,
  Int.sign_eq_one_of_pos (Nat.cast_pos.mpr n.succ_pos), Int.cast_one, one_div]
state_before: case succ
F : Type ?u.32377
ι : Type ?u.32380
α : Type u_1
β : Type ?u.32386
inst✝ : DivisionRing α
n : ℕ
⊢ ↑(↑(Nat.succ n))⁻¹ = (↑(Nat.succ n))⁻¹

tactic: simp
state_before: case zero
F : Type ?u.32377
ι : Type ?u.32380
α : Type u_1
β : Type ?u.32386
inst✝ : DivisionRing α
⊢ ↑(↑Nat.zero)⁻¹ = (↑Nat.zero)⁻¹
Theorem: ConvexOn.convex_le
File: Mathlib/Analysis/Convex/Function.lean

tactic: gcongr
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.63607
α : Type ?u.63610
β : Type u_3
ι : Type ?u.63616
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : AddCommMonoid E
inst✝⁵ : AddCommMonoid F
inst✝⁴ : OrderedAddCommMonoid α
inst✝³ : OrderedAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
hf : ConvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x ≤ r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x ≤ r}
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • f x + b • f y ≤ a • r + b • r

tactic: exact hx.2
state_before: case h₁.h₁
𝕜 : Type u_1
E : Type u_2
F : Type ?u.63607
α : Type ?u.63610
β : Type u_3
ι : Type ?u.63616
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : AddCommMonoid E
inst✝⁵ : AddCommMonoid F
inst✝⁴ : OrderedAddCommMonoid α
inst✝³ : OrderedAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
hf : ConvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x ≤ r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x ≤ r}
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ f x ≤ r

case h₂.h₁
𝕜 : Type u_1
E : Type u_2
F : Type ?u.63607
α : Type ?u.63610
β : Type u_3
ι : Type ?u.63616
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : AddCommMonoid E
inst✝⁵ : AddCommMonoid F
inst✝⁴ : OrderedAddCommMonoid α
inst✝³ : OrderedAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
hf : ConvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x ≤ r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x ≤ r}
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ f y ≤ r

tactic: exact hy.2
state_before: case h₂.h₁
𝕜 : Type u_1
E : Type u_2
F : Type ?u.63607
α : Type ?u.63610
β : Type u_3
ι : Type ?u.63616
inst✝⁷ : OrderedSemiring 𝕜
inst✝⁶ : AddCommMonoid E
inst✝⁵ : AddCommMonoid F
inst✝⁴ : OrderedAddCommMonoid α
inst✝³ : OrderedAddCommMonoid β
inst✝² : SMul 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
hf : ConvexOn 𝕜 s f
r : β
x : E
hx : x ∈ {x | x ∈ s ∧ f x ≤ r}
y : E
hy : y ∈ {x | x ∈ s ∧ f x ≤ r}
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ f y ≤ r
Theorem: Complex.sin_zero
File: Mathlib/Data/Complex/Exponential.lean

tactic: simp [sin]
state_before: x y : ℂ
⊢ sin 0 = 0
Theorem: intervalIntegral.integral_nonneg_of_ae_restrict
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

tactic: let H := ae_restrict_of_ae_restrict_of_subset Ioc_subset_Icc_self hf
state_before: ι : Type ?u.20278930
𝕜 : Type ?u.20278933
E : Type ?u.20278936
F : Type ?u.20278939
A : Type ?u.20278942
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : MeasureTheory.Measure ℝ
hab : a ≤ b
hf : 0 ≤ᵐ[Measure.restrict μ (Icc a b)] f
⊢ 0 ≤ ∫ (u : ℝ) in a..b, f u ∂μ

tactic: simpa only [integral_of_le hab] using set_integral_nonneg_of_ae_restrict H
state_before: ι : Type ?u.20278930
𝕜 : Type ?u.20278933
E : Type ?u.20278936
F : Type ?u.20278939
A : Type ?u.20278942
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
f g : ℝ → ℝ
a b : ℝ
μ : MeasureTheory.Measure ℝ
hab : a ≤ b
hf : 0 ≤ᵐ[Measure.restrict μ (Icc a b)] f
H : ∀ᵐ (x : ℝ) ∂Measure.restrict μ (Ioc a b), OfNat.ofNat 0 x ≤ f x :=
  ae_restrict_of_ae_restrict_of_subset Ioc_subset_Icc_self hf
⊢ 0 ≤ ∫ (u : ℝ) in a..b, f u ∂μ
Theorem: Cardinal.mk_toNat_eq_card
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: simp
state_before: α β : Type u
inst✝ : Fintype α
⊢ ↑toNat (#α) = Fintype.card α
Theorem: Real.summable_nat_rpow_inv
File: Mathlib/Analysis/PSeries.lean

tactic: cases' le_or_lt 0 p with hp hp
state_before: p : ℝ
⊢ (Summable fun n => (↑n ^ p)⁻¹) ↔ 1 < p

tactic: rw [← summable_condensed_iff_of_nonneg]
state_before: case inl
p : ℝ
hp : 0 ≤ p
⊢ (Summable fun n => (↑n ^ p)⁻¹) ↔ 1 < p

tactic: simp_rw [Nat.cast_pow, Nat.cast_two, ← rpow_nat_cast, ← rpow_mul zero_lt_two.le, mul_comm _ p,
  rpow_mul zero_lt_two.le, rpow_nat_cast, ← inv_pow, ← mul_pow,
  summable_geometric_iff_norm_lt_1]
state_before: case inl
p : ℝ
hp : 0 ≤ p
⊢ (Summable fun k => 2 ^ ↑k * (↑(2 ^ k) ^ p)⁻¹) ↔ 1 < p

tactic: nth_rw 1 [← rpow_one 2]
state_before: case inl
p : ℝ
hp : 0 ≤ p
⊢ ‖2 * (2 ^ p)⁻¹‖ < 1 ↔ 1 < p

tactic: rw [← division_def, ← rpow_sub zero_lt_two, norm_eq_abs,
  abs_of_pos (rpow_pos_of_pos zero_lt_two _), rpow_lt_one_iff zero_lt_two.le]
state_before: case inl
p : ℝ
hp : 0 ≤ p
⊢ ‖2 ^ 1 * (2 ^ p)⁻¹‖ < 1 ↔ 1 < p

tactic: norm_num
state_before: case inl
p : ℝ
hp : 0 ≤ p
⊢ 2 = 0 ∧ 1 - p ≠ 0 ∨ 1 < 2 ∧ 1 - p < 0 ∨ 2 < 1 ∧ 0 < 1 - p ↔ 1 < p

tactic: intro n
state_before: case inl.h_nonneg
p : ℝ
hp : 0 ≤ p
⊢ ∀ (n : ℕ), 0 ≤ (↑n ^ p)⁻¹

tactic: exact inv_nonneg.2 (rpow_nonneg_of_nonneg n.cast_nonneg _)
state_before: case inl.h_nonneg
p : ℝ
hp : 0 ≤ p
n : ℕ
⊢ 0 ≤ (↑n ^ p)⁻¹

tactic: intro m n hm hmn
state_before: case inl.h_mono
p : ℝ
hp : 0 ≤ p
⊢ ∀ ⦃m n : ℕ⦄, 0 < m → m ≤ n → (↑n ^ p)⁻¹ ≤ (↑m ^ p)⁻¹

tactic: exact
  inv_le_inv_of_le (rpow_pos_of_pos (Nat.cast_pos.2 hm) _)
    (rpow_le_rpow m.cast_nonneg (Nat.cast_le.2 hmn) hp)
state_before: case inl.h_mono
p : ℝ
hp : 0 ≤ p
m n : ℕ
hm : 0 < m
hmn : m ≤ n
⊢ (↑n ^ p)⁻¹ ≤ (↑m ^ p)⁻¹

tactic: suffices ¬Summable (fun n => (n ^ p)⁻¹ : ℕ → ℝ) by
  have : ¬1 < p := fun hp₁ => hp.not_le (zero_le_one.trans hp₁.le)
  simpa only [this, iff_false]
state_before: case inr
p : ℝ
hp : p < 0
⊢ (Summable fun n => (↑n ^ p)⁻¹) ↔ 1 < p

tactic: have : ¬1 < p := fun hp₁ => hp.not_le (zero_le_one.trans hp₁.le)
state_before: p : ℝ
hp : p < 0
this : ¬Summable fun n => (↑n ^ p)⁻¹
⊢ (Summable fun n => (↑n ^ p)⁻¹) ↔ 1 < p

tactic: simpa only [this, iff_false]
state_before: p : ℝ
hp : p < 0
this✝ : ¬Summable fun n => (↑n ^ p)⁻¹
this : ¬1 < p
⊢ (Summable fun n => (↑n ^ p)⁻¹) ↔ 1 < p

tactic: intro h
state_before: case inr
p : ℝ
hp : p < 0
⊢ ¬Summable fun n => (↑n ^ p)⁻¹

tactic: obtain ⟨k : ℕ, hk₁ : ((k ^ p)⁻¹ : ℝ) < 1, hk₀ : k ≠ 0⟩ :=
  ((h.tendsto_cofinite_zero.eventually (gt_mem_nhds zero_lt_one)).and
      (eventually_cofinite_ne 0)).exists
state_before: case inr
p : ℝ
hp : p < 0
h : Summable fun n => (↑n ^ p)⁻¹
⊢ False

tactic: apply hk₀
state_before: case inr.intro.intro
p : ℝ
hp : p < 0
h : Summable fun n => (↑n ^ p)⁻¹
k : ℕ
hk₁ : (↑k ^ p)⁻¹ < 1
hk₀ : k ≠ 0
⊢ False

tactic: rw [← pos_iff_ne_zero, ← @Nat.cast_pos ℝ] at hk₀
state_before: case inr.intro.intro
p : ℝ
hp : p < 0
h : Summable fun n => (↑n ^ p)⁻¹
k : ℕ
hk₁ : (↑k ^ p)⁻¹ < 1
hk₀ : k ≠ 0
⊢ k = 0

tactic: simpa [inv_lt_one_iff_of_pos (rpow_pos_of_pos hk₀ _), one_lt_rpow_iff_of_pos hk₀, hp,
  hp.not_lt, hk₀] using hk₁
state_before: case inr.intro.intro
p : ℝ
hp : p < 0
h : Summable fun n => (↑n ^ p)⁻¹
k : ℕ
hk₁ : (↑k ^ p)⁻¹ < 1
hk₀ : 0 < ↑k
⊢ k = 0
Theorem: List.mem_union_iff
File: Std/Data/List/Lemmas.lean

tactic: induction l₁ <;> simp [*, or_assoc]
state_before: α : Type u_1
inst✝¹ inst✝ : DecidableEq α
x : α
l₁ l₂ : List α
⊢ x ∈ List.union l₁ l₂ ↔ x ∈ l₁ ∨ x ∈ l₂
Theorem: Cycle.mem_lists_iff_coe_eq
File: Mathlib/Data/List/Cycle.lean

tactic: rw [lists, Quotient.liftOn'_mk'']
state_before: α : Type u_1
s : Cycle α
l✝ l : List α
⊢ l✝ ∈ lists (Quotient.mk'' l) ↔ ↑l✝ = Quotient.mk'' l

tactic: simp
state_before: α : Type u_1
s : Cycle α
l✝ l : List α
⊢ l✝ ∈ ↑(cyclicPermutations l) ↔ ↑l✝ = Quotient.mk'' l
Theorem: Array.back?_push
File: Std/Data/Array/Lemmas.lean

tactic: simp [back?, getElem?_eq_data_get?]
state_before: α : Type u_1
x : α
a : Array α
⊢ back? (push a x) = some x
Theorem: PartENat.lt_wf
File: Mathlib/Data/Nat/PartENat.lean

tactic: classical
  change WellFounded fun a b : PartENat => a < b
  simp_rw [← withTopEquiv_lt]
  exact InvImage.wf _ (WithTop.wellFounded_lt Nat.lt_wfRel.wf)
state_before: ⊢ WellFounded fun x x_1 => x < x_1

tactic: change WellFounded fun a b : PartENat => a < b
state_before: ⊢ WellFounded fun x x_1 => x < x_1

tactic: simp_rw [← withTopEquiv_lt]
state_before: ⊢ WellFounded fun a b => a < b

tactic: exact InvImage.wf _ (WithTop.wellFounded_lt Nat.lt_wfRel.wf)
state_before: ⊢ WellFounded fun a b => ↑withTopEquiv a < ↑withTopEquiv b
Theorem: HasFPowerSeriesAt.eq_zero
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: funext n
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1132100
G : Type ?u.1132103
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 𝕜 E
x : 𝕜
h : HasFPowerSeriesAt 0 p x
⊢ p = 0

tactic: ext x
state_before: case h
𝕜 : Type u_1
E : Type u_2
F : Type ?u.1132100
G : Type ?u.1132103
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 𝕜 E
x : 𝕜
h : HasFPowerSeriesAt 0 p x
n : ℕ
⊢ p n = OfNat.ofNat 0 n

tactic: rw [← mkPiField_apply_one_eq_self (p n)]
state_before: case h.H
𝕜 : Type u_1
E : Type u_2
F : Type ?u.1132100
G : Type ?u.1132103
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 𝕜 E
x✝ : 𝕜
h : HasFPowerSeriesAt 0 p x✝
n : ℕ
x : Fin n → 𝕜
⊢ ↑(p n) x = ↑(OfNat.ofNat 0 n) x

tactic: have := Or.intro_right ?_ (h.apply_eq_zero n 1)
state_before: case h.H
𝕜 : Type u_1
E : Type u_2
F : Type ?u.1132100
G : Type ?u.1132103
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 𝕜 E
x✝ : 𝕜
h : HasFPowerSeriesAt 0 p x✝
n : ℕ
x : Fin n → 𝕜
⊢ ↑(ContinuousMultilinearMap.mkPiField 𝕜 (Fin n) (↑(p n) fun x => 1)) x = ↑(OfNat.ofNat 0 n) x

tactic: simpa using this
state_before: case h.H.refine_2
𝕜 : Type u_1
E : Type u_2
F : Type ?u.1132100
G : Type ?u.1132103
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 𝕜 E
x✝ : 𝕜
h : HasFPowerSeriesAt 0 p x✝
n : ℕ
x : Fin n → 𝕜
this : ?h.H.refine_1 ∨ (↑(p n) fun x => 1) = 0
⊢ ↑(ContinuousMultilinearMap.mkPiField 𝕜 (Fin n) (↑(p n) fun x => 1)) x = ↑(OfNat.ofNat 0 n) x

case h.H.refine_1
𝕜 : Type u_1
E : Type u_2
F : Type ?u.1132100
G : Type ?u.1132103
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
p : FormalMultilinearSeries 𝕜 𝕜 E
x✝ : 𝕜
h : HasFPowerSeriesAt 0 p x✝
n : ℕ
x : Fin n → 𝕜
⊢ Prop
Theorem: Polynomial.not_isField
File: Mathlib/Data/Polynomial/Div.lean

tactic: nontriviality R
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
⊢ ¬IsField R[X]

tactic: rw [Ring.not_isField_iff_exists_ideal_bot_lt_and_lt_top]
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
✝ : Nontrivial R
⊢ ¬IsField R[X]

tactic: use Ideal.span {Polynomial.X}
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
✝ : Nontrivial R
⊢ ∃ I, ⊥ < I ∧ I < ⊤

tactic: constructor
state_before: R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
✝ : Nontrivial R
⊢ ⊥ < Ideal.span {X} ∧ Ideal.span {X} < ⊤

tactic: rw [bot_lt_iff_ne_bot, Ne.def, Ideal.span_singleton_eq_bot]
state_before: case left
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
✝ : Nontrivial R
⊢ ⊥ < Ideal.span {X}

tactic: exact Polynomial.X_ne_zero
state_before: case left
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
✝ : Nontrivial R
⊢ ¬X = 0

tactic: rw [lt_top_iff_ne_top, Ne.def, Ideal.eq_top_iff_one, Ideal.mem_span_singleton,
  Polynomial.X_dvd_iff, Polynomial.coeff_one_zero]
state_before: case right
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
✝ : Nontrivial R
⊢ Ideal.span {X} < ⊤

tactic: exact one_ne_zero
state_before: case right
R : Type u
S : Type v
T : Type w
A : Type z
a b : R
n : ℕ
inst✝ : CommRing R
p q : R[X]
✝ : Nontrivial R
⊢ ¬1 = 0
Theorem: CategoryTheory.eq_of_comp_right_eq
File: Mathlib/CategoryTheory/Category/Basic.lean

tactic: convert w (𝟙 Y) <;>
aesop
state_before: C : Type u
inst✝ : Category C
X Y Z : C
f g : Y ⟶ Z
w : ∀ {X : C} (h : X ⟶ Y), h ≫ f = h ≫ g
⊢ f = g
Theorem: List.getLast_mem
File: Mathlib/Data/List/Basic.lean

tactic: simp only [getLast, mem_singleton]
state_before: ι : Type ?u.32017
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a : α
x✝ : [a] ≠ []
⊢ getLast [a] x✝ ∈ [a]

tactic: rw [getLast_cons_cons]
state_before: ι : Type ?u.32017
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a b : α
l : List α
h : a :: b :: l ≠ []
⊢ getLast (a :: b :: l) h ∈ b :: l

tactic: exact getLast_mem (cons_ne_nil b l)
state_before: ι : Type ?u.32017
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
a b : α
l : List α
h : a :: b :: l ≠ []
⊢ getLast (b :: l) (_ : b :: l ≠ []) ∈ b :: l