1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: TopologicalSpace.IsTopologicalBasis.inf_induced
File: Mathlib/Topology/Bases.lean

tactic: simpa only [image2_image_left, image2_image_right] using (h₁.induced f₁).inf (h₂.induced f₂)
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s✝ : Set α
γ : Type u_2
s : TopologicalSpace β
B₁ : Set (Set α)
B₂ : Set (Set β)
h₁ : IsTopologicalBasis B₁
h₂ : IsTopologicalBasis B₂
f₁ : γ → α
f₂ : γ → β
⊢ IsTopologicalBasis (image2 (fun x x_1 => f₁ ⁻¹' x ∩ f₂ ⁻¹' x_1) B₁ B₂)
state_after: no goals
Theorem: Cardinal.nat_mul_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rwa [← Nat.cast_one, natCast_le, Nat.one_le_iff_ne_zero]
state_before: α β : Type u
n : ℕ
hn : n ≠ 0
⊢ 1 ≤ ↑n
state_after: no goals
Theorem: AffineBasis.linear_combination_coord_eq_self
File: Mathlib/LinearAlgebra/AffineSpace/Basis.lean

tactic: have hb := b.affineCombination_coord_eq_self v
state_before: ι : Type u_1
ι' : Type u_2
k : Type u_3
V : Type u_4
P : Type u_5
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b✝ : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
inst✝ : Fintype ι
b : AffineBasis ι k V
v : V
⊢ ∑ i : ι, (b.coord i) v • b i = v
state_after: ι : Type u_1
ι' : Type u_2
k : Type u_3
V : Type u_4
P : Type u_5
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b✝ : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
inst✝ : Fintype ι
b : AffineBasis ι k V
v : V
hb : ((Finset.affineCombination k Finset.univ ⇑b) fun i => (b.coord i) v) = v
⊢ ∑ i : ι, (b.coord i) v • b i = v

tactic: rwa [Finset.univ.affineCombination_eq_linear_combination _ _ (b.sum_coord_apply_eq_one v)] at hb
state_before: ι : Type u_1
ι' : Type u_2
k : Type u_3
V : Type u_4
P : Type u_5
inst✝⁴ : AddCommGroup V
inst✝³ : AffineSpace V P
inst✝² : Ring k
inst✝¹ : Module k V
b✝ : AffineBasis ι k P
s : Finset ι
i j : ι
e : ι ≃ ι'
inst✝ : Fintype ι
b : AffineBasis ι k V
v : V
hb : ((Finset.affineCombination k Finset.univ ⇑b) fun i => (b.coord i) v) = v
⊢ ∑ i : ι, (b.coord i) v • b i = v
state_after: no goals
Theorem: List.getElem?_getD_replicate_default_eq
File: Mathlib/Data/List/GetD.lean

tactic: induction r generalizing n with
| zero => simp
| succ n ih => simp at ih; cases n <;> simp [ih, replicate_succ]
state_before: α : Type u
β : Type v
l : List α
x : α
xs : List α
n✝ : ℕ
d : α
r n : ℕ
⊢ (replicate r d)[n]?.getD d = d
state_after: no goals

tactic: simp
state_before: case zero
α : Type u
β : Type v
l : List α
x : α
xs : List α
n✝ : ℕ
d : α
n : ℕ
⊢ (replicate 0 d)[n]?.getD d = d
state_after: no goals

tactic: cases n <;> simp [ih, replicate_succ]
state_before: case succ
α : Type u
β : Type v
l : List α
x : α
xs : List α
n✝¹ : ℕ
d : α
n✝ : ℕ
ih : ∀ (n : ℕ), (replicate n✝ d)[n]?.getD d = d
n : ℕ
⊢ (replicate (n✝ + 1) d)[n]?.getD d = d
state_after: no goals
Theorem: norm_iteratedFDerivWithin_fderivWithin
File: Mathlib/Analysis/Calculus/ContDiff/Defs.lean

tactic: rw [iteratedFDerivWithin_succ_eq_comp_right hs hx, comp_apply, LinearIsometryEquiv.norm_map]
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n✝ : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
n : ℕ
hs : UniqueDiffOn 𝕜 s
hx : x ∈ s
⊢ ‖iteratedFDerivWithin 𝕜 n (fderivWithin 𝕜 f s) s x‖ = ‖iteratedFDerivWithin 𝕜 (n + 1) f s x‖
state_after: no goals
Theorem: MvPFunctor.wPathCasesOn_eta
File: Mathlib/Data/PFunctor/Multivariate/W.lean

tactic: ext i x
state_before: n : ℕ
P : MvPFunctor.{u} (n + 1)
α : TypeVec.{u_1} n
a : P.A
f : P.last.B a → P.last.W
h : P.WPath (WType.mk a f) ⟹ α
⊢ P.wPathCasesOn (P.wPathDestLeft h) (P.wPathDestRight h) = h
state_after: case a.h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α : TypeVec.{u_1} n
a : P.A
f : P.last.B a → P.last.W
h : P.WPath (WType.mk a f) ⟹ α
i : Fin2 n
x : P.WPath (WType.mk a f) i
⊢ P.wPathCasesOn (P.wPathDestLeft h) (P.wPathDestRight h) i x = h i x

tactic: cases x <;> rfl
state_before: case a.h
n : ℕ
P : MvPFunctor.{u} (n + 1)
α : TypeVec.{u_1} n
a : P.A
f : P.last.B a → P.last.W
h : P.WPath (WType.mk a f) ⟹ α
i : Fin2 n
x : P.WPath (WType.mk a f) i
⊢ P.wPathCasesOn (P.wPathDestLeft h) (P.wPathDestRight h) i x = h i x
state_after: no goals
Theorem: Nat.Partition.partition_one_parts
File: Mathlib/Combinatorics/Enumerative/Partition.lean

tactic: have h : p.parts = replicate (card p.parts) 1 := eq_replicate_card.2 fun x hx =>
  ((le_sum_of_mem hx).trans_eq p.parts_sum).antisymm (p.parts_pos hx)
state_before: p : Partition 1
⊢ p.parts = {1}
state_after: p : Partition 1
h : p.parts = replicate (card p.parts) 1
⊢ p.parts = {1}

tactic: have h' : card p.parts = 1 := by simpa using (congrArg sum h.symm).trans p.parts_sum
state_before: p : Partition 1
h : p.parts = replicate (card p.parts) 1
⊢ p.parts = {1}
state_after: p : Partition 1
h : p.parts = replicate (card p.parts) 1
h' : card p.parts = 1
⊢ p.parts = {1}

tactic: rw [h, h', replicate_one]
state_before: p : Partition 1
h : p.parts = replicate (card p.parts) 1
h' : card p.parts = 1
⊢ p.parts = {1}
state_after: no goals

tactic: simpa using (congrArg sum h.symm).trans p.parts_sum
state_before: p : Partition 1
h : p.parts = replicate (card p.parts) 1
⊢ card p.parts = 1
state_after: no goals
Theorem: WType.leftInverse_list
File: Mathlib/Data/W/Constructions.lean

tactic: simp only [toList, ofList, mk.injEq, heq_eq_eq, true_and]
state_before: γ : Type u
f : Listβ γ Listα.nil → WType (Listβ γ)
⊢ ofList γ (toList γ (mk Listα.nil f)) = mk Listα.nil f
state_after: γ : Type u
f : Listβ γ Listα.nil → WType (Listβ γ)
⊢ PEmpty.elim = f

tactic: ext x
state_before: γ : Type u
f : Listβ γ Listα.nil → WType (Listβ γ)
⊢ PEmpty.elim = f
state_after: case h
γ : Type u
f : Listβ γ Listα.nil → WType (Listβ γ)
x : PEmpty.{u + 1}
⊢ x.elim = f x

tactic: cases x
state_before: case h
γ : Type u
f : Listβ γ Listα.nil → WType (Listβ γ)
x : PEmpty.{u + 1}
⊢ x.elim = f x
state_after: no goals

tactic: simp only [ofList, leftInverse_list (f PUnit.unit), mk.injEq, heq_eq_eq, true_and]
state_before: γ : Type u
x : γ
f : Listβ γ (Listα.cons x) → WType (Listβ γ)
⊢ ofList γ (toList γ (mk (Listα.cons x) f)) = mk (Listα.cons x) f
state_after: γ : Type u
x : γ
f : Listβ γ (Listα.cons x) → WType (Listβ γ)
⊢ (fun x => f PUnit.unit) = f

tactic: rfl
state_before: γ : Type u
x : γ
f : Listβ γ (Listα.cons x) → WType (Listβ γ)
⊢ (fun x => f PUnit.unit) = f
state_after: no goals
Theorem: ProbabilityTheory.iIndepSet_iff_iIndep
File: Mathlib/Probability/Independence/Basic.lean

tactic: simp only [iIndepSet, iIndep, kernel.iIndepSet]
state_before: Ω : Type u_1
ι : Type u_2
β : Type u_3
γ : Type u_4
κ : ι → Type u_5
π : ι → Set (Set Ω)
m : ι → MeasurableSpace Ω
x✝ : MeasurableSpace Ω
μ✝ : Measure Ω
S : Finset ι
s✝ s : ι → Set Ω
μ : Measure Ω
⊢ iIndepSet s μ ↔ iIndep (fun i => generateFrom {s i}) μ
state_after: no goals
Theorem: Subgroup.codisjoint_subgroupOf_sup
File: Mathlib/Algebra/Group/Subgroup/Basic.lean

tactic: rw [codisjoint_iff, sup_subgroupOf_eq, subgroupOf_self]
state_before: G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ Codisjoint (H.subgroupOf (H ⊔ K)) (K.subgroupOf (H ⊔ K))
state_after: case hH
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ H ≤ H ⊔ K

case hK
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ K ≤ H ⊔ K

tactic: exacts [le_sup_left, le_sup_right]
state_before: case hH
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ H ≤ H ⊔ K

case hK
G : Type u_1
G' : Type u_2
G'' : Type u_3
inst✝⁴ : Group G
inst✝³ : Group G'
inst✝² : Group G''
A : Type u_4
inst✝¹ : AddGroup A
N : Type u_5
inst✝ : Group N
f : G →* N
H K : Subgroup G
⊢ K ≤ H ⊔ K
state_after: no goals
Theorem: CategoryTheory.Limits.pullbackIsoUnopPushout_inv_snd
File: Mathlib/CategoryTheory/Limits/Opposites.lean

tactic: simp [unop_id (X := { unop := Y })]
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
J : Type u₂
inst✝² : Category.{v₂, u₂} J
X✝ : Type v₂
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
inst✝¹ : HasPullback f g
inst✝ : HasPushout f.op g.op
⊢ (PushoutCocone.unop (colimit.cocone (span f.op g.op))).π.app WalkingCospan.right = pushout.inr.unop
state_after: no goals
Theorem: Ideal.span_singleton_mul_eq_span_singleton_mul
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp only [le_antisymm_iff, span_singleton_mul_le_span_singleton_mul, eq_comm]
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L : Ideal R
x y : R
I J : Ideal R
⊢ span {x} * I = span {y} * J ↔ (∀ zI ∈ I, ∃ zJ ∈ J, x * zI = y * zJ) ∧ ∀ zJ ∈ J, ∃ zI ∈ I, x * zI = y * zJ
state_after: no goals
Theorem: Finset.prod_lt_one
File: Mathlib/Algebra/Order/BigOperators/Group/Finset.lean

tactic: rw [prod_const_one]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
G : Type u_6
k : Type u_7
R : Type u_8
inst✝ : OrderedCancelCommMonoid M
f g : ι → M
s t : Finset ι
h : ∀ i ∈ s, f i < 1
hs : s.Nonempty
⊢ ∏ i ∈ s, 1 ≤ 1
state_after: no goals
Theorem: Complex.eventually_eq_of_isLocalMax_norm
File: Mathlib/Analysis/Complex/AbsMax.lean

tactic: rcases nhds_basis_closedBall.eventually_iff.1 (hd.and hc) with ⟨r, hr₀, hr⟩
state_before: E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℂ E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℂ F
inst✝ : StrictConvexSpace ℝ F
f : E → F
c : E
hd : ∀ᶠ (z : E) in 𝓝 c, DifferentiableAt ℂ f z
hc : IsLocalMax (norm ∘ f) c
⊢ ∀ᶠ (y : E) in 𝓝 c, f y = f c
state_after: case intro.intro
E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℂ E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℂ F
inst✝ : StrictConvexSpace ℝ F
f : E → F
c : E
hd : ∀ᶠ (z : E) in 𝓝 c, DifferentiableAt ℂ f z
hc : IsLocalMax (norm ∘ f) c
r : ℝ
hr₀ : 0 < r
hr : ∀ ⦃x : E⦄, x ∈ closedBall c r → DifferentiableAt ℂ f x ∧ (norm ∘ f) x ≤ (norm ∘ f) c
⊢ ∀ᶠ (y : E) in 𝓝 c, f y = f c

tactic: exact nhds_basis_closedBall.eventually_iff.2
  ⟨r, hr₀, eqOn_closedBall_of_isMaxOn_norm (DifferentiableOn.diffContOnCl fun x hx =>
      (hr <| closure_ball_subset_closedBall hx).1.differentiableWithinAt) fun x hx =>
    (hr <| ball_subset_closedBall hx).2⟩
state_before: case intro.intro
E : Type u
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℂ E
F : Type v
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℂ F
inst✝ : StrictConvexSpace ℝ F
f : E → F
c : E
hd : ∀ᶠ (z : E) in 𝓝 c, DifferentiableAt ℂ f z
hc : IsLocalMax (norm ∘ f) c
r : ℝ
hr₀ : 0 < r
hr : ∀ ⦃x : E⦄, x ∈ closedBall c r → DifferentiableAt ℂ f x ∧ (norm ∘ f) x ≤ (norm ∘ f) c
⊢ ∀ᶠ (y : E) in 𝓝 c, f y = f c
state_after: no goals
Theorem: List.cons_diff_of_not_mem
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: rw [cons_diff, if_neg h]
state_before: α : Type u_1
inst✝¹ : BEq α
inst✝ : LawfulBEq α
a : α
l₂ : List α
h : ¬a ∈ l₂
l₁ : List α
⊢ (a :: l₁).diff l₂ = a :: l₁.diff l₂
state_after: no goals
Theorem: Fin.coe_succ_lt_iff_lt
File: Mathlib/Data/Fin/Basic.lean

tactic: simp only [coe_eq_castSucc, castSucc_lt_castSucc_iff]
state_before: n✝ m n : ℕ
j k : Fin n
⊢ ↑↑j < ↑↑k ↔ j < k
state_after: no goals
Theorem: List.argmax_eq_none
File: Mathlib/Data/List/MinMax.lean

tactic: simp [argmax]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder β
inst✝ : DecidableRel fun x x_1 => x < x_1
f : α → β
l : List α
o : Option α
a m : α
⊢ argmax f l = none ↔ l = []
state_after: no goals
Theorem: Nat.ModEq.mul_right'
File: Mathlib/Data/Nat/ModEq.lean

tactic: rw [mul_comm a, mul_comm b, mul_comm n]
state_before: m n a b c✝ d c : ℕ
h : a ≡ b [MOD n]
⊢ a * c ≡ b * c [MOD n * c]
state_after: m n a b c✝ d c : ℕ
h : a ≡ b [MOD n]
⊢ c * a ≡ c * b [MOD c * n]

tactic: exact h.mul_left' c
state_before: m n a b c✝ d c : ℕ
h : a ≡ b [MOD n]
⊢ c * a ≡ c * b [MOD c * n]
state_after: no goals
Theorem: Units.isUnit_units_mul
File: Mathlib/Algebra/Group/Units.lean

tactic: have : IsUnit (↑u⁻¹ * (↑u * a)) := by exists u⁻¹ * v; rw [← hv, Units.val_mul]
state_before: α : Type u
M✝ : Type u_1
N : Type u_2
M : Type u_3
inst✝ : Monoid M
u : Mˣ
a : M
x✝ : IsUnit (↑u * a)
v : Mˣ
hv : ↑v = ↑u * a
⊢ IsUnit a
state_after: α : Type u
M✝ : Type u_1
N : Type u_2
M : Type u_3
inst✝ : Monoid M
u : Mˣ
a : M
x✝ : IsUnit (↑u * a)
v : Mˣ
hv : ↑v = ↑u * a
this : IsUnit (↑u⁻¹ * (↑u * a))
⊢ IsUnit a

tactic: rwa [← mul_assoc, Units.inv_mul, one_mul] at this
state_before: α : Type u
M✝ : Type u_1
N : Type u_2
M : Type u_3
inst✝ : Monoid M
u : Mˣ
a : M
x✝ : IsUnit (↑u * a)
v : Mˣ
hv : ↑v = ↑u * a
this : IsUnit (↑u⁻¹ * (↑u * a))
⊢ IsUnit a
state_after: no goals

tactic: exists u⁻¹ * v
state_before: α : Type u
M✝ : Type u_1
N : Type u_2
M : Type u_3
inst✝ : Monoid M
u : Mˣ
a : M
x✝ : IsUnit (↑u * a)
v : Mˣ
hv : ↑v = ↑u * a
⊢ IsUnit (↑u⁻¹ * (↑u * a))
state_after: α : Type u
M✝ : Type u_1
N : Type u_2
M : Type u_3
inst✝ : Monoid M
u : Mˣ
a : M
x✝ : IsUnit (↑u * a)
v : Mˣ
hv : ↑v = ↑u * a
⊢ ↑(u⁻¹ * v) = ↑u⁻¹ * (↑u * a)

tactic: rw [← hv, Units.val_mul]
state_before: α : Type u
M✝ : Type u_1
N : Type u_2
M : Type u_3
inst✝ : Monoid M
u : Mˣ
a : M
x✝ : IsUnit (↑u * a)
v : Mˣ
hv : ↑v = ↑u * a
⊢ ↑(u⁻¹ * v) = ↑u⁻¹ * (↑u * a)
state_after: no goals
Theorem: essSup_le_of_ae_le
File: Mathlib/MeasureTheory/Function/EssSup.lean

tactic: isBoundedDefault
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
f : α → β
c : β
hf : f ≤ᶠ[ae μ] fun x => c
⊢ IsCoboundedUnder (fun x x_1 => x ≤ x_1) (ae μ) f
state_after: no goals
Theorem: DFinsupp.liftAddHom_apply_single
File: Mathlib/Data/DFinsupp/Basic.lean

tactic: simp
state_before: ι : Type u
γ : Type w
β : ι → Type v
β₁ : ι → Type v₁
β₂ : ι → Type v₂
inst✝² : DecidableEq ι
inst✝¹ : (i : ι) → AddZeroClass (β i)
inst✝ : AddCommMonoid γ
f : (i : ι) → β i →+ γ
i : ι
x : β i
⊢ (liftAddHom f) (single i x) = (f i) x
state_after: no goals
Theorem: HasDerivAt.le_of_lipschitz
File: Mathlib/Analysis/Calculus/Deriv/Basic.lean

tactic: simpa using HasFDerivAt.le_of_lipschitz hf.hasFDerivAt hlip
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 L₁ L₂ : Filter 𝕜
f : 𝕜 → F
f' : F
x₀ : 𝕜
hf : HasDerivAt f f' x₀
C : ℝ≥0
hlip : LipschitzWith C f
⊢ ‖f'‖ ≤ ↑C
state_after: no goals
Theorem: Nat.Primes.summable_rpow
File: Mathlib/NumberTheory/SumPrimeReciprocals.lean

tactic: by_cases h : r < -1
state_before: r : ℝ
⊢ (Summable fun p => ↑↑p ^ r) ↔ r < -1
state_after: case pos
r : ℝ
h : r < -1
⊢ (Summable fun p => ↑↑p ^ r) ↔ r < -1

case neg
r : ℝ
h : ¬r < -1
⊢ (Summable fun p => ↑↑p ^ r) ↔ r < -1

tactic: simp only [h, iff_true]
state_before: case pos
r : ℝ
h : r < -1
⊢ (Summable fun p => ↑↑p ^ r) ↔ r < -1
state_after: case pos
r : ℝ
h : r < -1
⊢ Summable fun p => ↑↑p ^ r

tactic: exact (Real.summable_nat_rpow.mpr h).subtype _
state_before: case pos
r : ℝ
h : r < -1
⊢ Summable fun p => ↑↑p ^ r
state_after: no goals

tactic: simp only [h, iff_false]
state_before: case neg
r : ℝ
h : ¬r < -1
⊢ (Summable fun p => ↑↑p ^ r) ↔ r < -1
state_after: case neg
r : ℝ
h : ¬r < -1
⊢ ¬Summable fun p => ↑↑p ^ r

tactic: refine fun H ↦ Nat.Primes.not_summable_one_div <| H.of_nonneg_of_le (fun _ ↦ by positivity) ?_
state_before: case neg
r : ℝ
h : ¬r < -1
⊢ ¬Summable fun p => ↑↑p ^ r
state_after: case neg
r : ℝ
h : ¬r < -1
H : Summable fun p => ↑↑p ^ r
⊢ ∀ (b : Primes), 1 / ↑↑b ≤ ↑↑b ^ r

tactic: intro p
state_before: case neg
r : ℝ
h : ¬r < -1
H : Summable fun p => ↑↑p ^ r
⊢ ∀ (b : Primes), 1 / ↑↑b ≤ ↑↑b ^ r
state_after: case neg
r : ℝ
h : ¬r < -1
H : Summable fun p => ↑↑p ^ r
p : Primes
⊢ 1 / ↑↑p ≤ ↑↑p ^ r

tactic: rw [one_div, ← Real.rpow_neg_one]
state_before: case neg
r : ℝ
h : ¬r < -1
H : Summable fun p => ↑↑p ^ r
p : Primes
⊢ 1 / ↑↑p ≤ ↑↑p ^ r
state_after: case neg
r : ℝ
h : ¬r < -1
H : Summable fun p => ↑↑p ^ r
p : Primes
⊢ ↑↑p ^ (-1) ≤ ↑↑p ^ r

tactic: exact Real.rpow_le_rpow_of_exponent_le (by exact_mod_cast p.prop.one_lt.le) <| not_lt.mp h
state_before: case neg
r : ℝ
h : ¬r < -1
H : Summable fun p => ↑↑p ^ r
p : Primes
⊢ ↑↑p ^ (-1) ≤ ↑↑p ^ r
state_after: no goals

tactic: positivity
state_before: r : ℝ
h : ¬r < -1
H : Summable fun p => ↑↑p ^ r
x✝ : Primes
⊢ 0 ≤ 1 / ↑↑x✝
state_after: no goals

tactic: exact_mod_cast p.prop.one_lt.le
state_before: r : ℝ
h : ¬r < -1
H : Summable fun p => ↑↑p ^ r
p : Primes
⊢ 1 ≤ ↑↑p
state_after: no goals
Theorem: MvPolynomial.finSuccEquiv_eq
File: Mathlib/Algebra/MvPolynomial/Equiv.lean

tactic: ext i : 2
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
⊢ ↑(finSuccEquiv R n) = eval₂Hom (Polynomial.C.comp C) fun i => Fin.cases Polynomial.X (fun k => Polynomial.C (X k)) i
state_after: case hC.a
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
i : R
⊢ ((↑(finSuccEquiv R n)).comp C) i =
    ((eval₂Hom (Polynomial.C.comp C) fun i => Fin.cases Polynomial.X (fun k => Polynomial.C (X k)) i).comp C) i

case hX.a
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
i : Fin (n + 1)
n✝ : ℕ
⊢ (↑(finSuccEquiv R n) (X i)).coeff n✝ =
    ((eval₂Hom (Polynomial.C.comp C) fun i => Fin.cases Polynomial.X (fun k => Polynomial.C (X k)) i) (X i)).coeff n✝

tactic: simp only [finSuccEquiv, optionEquivLeft_apply, aeval_C, AlgEquiv.coe_trans, RingHom.coe_coe,
  coe_eval₂Hom, comp_apply, renameEquiv_apply, eval₂_C, RingHom.coe_comp, rename_C]
state_before: case hC.a
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
i : R
⊢ ((↑(finSuccEquiv R n)).comp C) i =
    ((eval₂Hom (Polynomial.C.comp C) fun i => Fin.cases Polynomial.X (fun k => Polynomial.C (X k)) i).comp C) i
state_after: case hC.a
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
i : R
⊢ (algebraMap R (MvPolynomial (Fin n) R)[X]) i = Polynomial.C (C i)

tactic: rfl
state_before: case hC.a
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
i : R
⊢ (algebraMap R (MvPolynomial (Fin n) R)[X]) i = Polynomial.C (C i)
state_after: no goals

tactic: refine Fin.cases ?_ ?_ i <;> simp [finSuccEquiv]
state_before: case hX.a
R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
s : σ →₀ ℕ
inst✝ : CommSemiring R
n : ℕ
i : Fin (n + 1)
n✝ : ℕ
⊢ (↑(finSuccEquiv R n) (X i)).coeff n✝ =
    ((eval₂Hom (Polynomial.C.comp C) fun i => Fin.cases Polynomial.X (fun k => Polynomial.C (X k)) i) (X i)).coeff n✝
state_after: no goals
Theorem: ProbabilityTheory.iSup_partitionFiltration_eq_generateFrom_range
File: Mathlib/Probability/Process/PartitionFiltration.lean

tactic: conv_rhs => rw [← generateFrom_iUnion_memPartition t, ← iSup_generateFrom]
state_before: α : Type u_1
m : MeasurableSpace α
t : ℕ → Set α
ht : ∀ (n : ℕ), MeasurableSet (t n)
⊢ ⨆ n, ↑(partitionFiltration ht) n = generateFrom (Set.range t)
state_after: α : Type u_1
m : MeasurableSpace α
t : ℕ → Set α
ht : ∀ (n : ℕ), MeasurableSet (t n)
⊢ ⨆ n, ↑(partitionFiltration ht) n = ⨆ i, generateFrom (memPartition t i)

tactic: rfl
state_before: α : Type u_1
m : MeasurableSpace α
t : ℕ → Set α
ht : ∀ (n : ℕ), MeasurableSet (t n)
⊢ ⨆ n, ↑(partitionFiltration ht) n = ⨆ i, generateFrom (memPartition t i)
state_after: no goals
Theorem: NNReal.isConjExponent_iff_eq_conjExponent
File: Mathlib/Data/Real/ConjExponents.lean

tactic: rw [← isConjExponent_coe, Real.isConjExponent_iff_eq_conjExponent (mod_cast h), ← coe_inj,
  NNReal.coe_div, NNReal.coe_sub h.le, coe_one]
state_before: a b p q : ℝ≥0
h✝ : p.IsConjExponent q
h : 1 < p
⊢ p.IsConjExponent q ↔ q = p / (p - 1)
state_after: no goals
Theorem: Multiset.ndinter_cons_of_not_mem
File: Mathlib/Data/Multiset/FinsetOps.lean

tactic: simp [ndinter, h]
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ : Multiset α
a : α
s t : Multiset α
h : a ∉ t
⊢ (a ::ₘ s).ndinter t = s.ndinter t
state_after: no goals
Theorem: Finset.fold_max_add
File: Mathlib/Data/Finset/Fold.lean

tactic: classical
  induction' s using Finset.induction_on with a s _ ih <;> simp [*, max_add_add_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s✝ : Finset α
a : α
inst✝² : LinearOrder β
c : β
inst✝¹ : Add β
inst✝ : CovariantClass β β (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
n : WithBot β
s : Finset α
⊢ fold max ⊥ (fun x => ↑(f x) + n) s = fold max ⊥ (WithBot.some ∘ f) s + n
state_after: no goals

tactic: induction' s using Finset.induction_on with a s _ ih <;> simp [*, max_add_add_right]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
op : β → β → β
hc : Std.Commutative op
ha : Std.Associative op
f : α → β
b : β
s✝ : Finset α
a : α
inst✝² : LinearOrder β
c : β
inst✝¹ : Add β
inst✝ : CovariantClass β β (Function.swap fun x x_1 => x + x_1) fun x x_1 => x ≤ x_1
n : WithBot β
s : Finset α
⊢ fold max ⊥ (fun x => ↑(f x) + n) s = fold max ⊥ (WithBot.some ∘ f) s + n
state_after: no goals
Theorem: Int.floor_le_neg_one_iff
File: Mathlib/Algebra/Order/Floor.lean

tactic: rw [← zero_sub (1 : ℤ), floor_le_sub_one_iff, cast_zero]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ ⌊a⌋ ≤ -1 ↔ a < 0
state_after: no goals
Theorem: List.enum_append
File: Mathlib/Data/List/Enum.lean

tactic: simp [enum, enumFrom_append]
state_before: α : Type u_1
β : Type u_2
xs ys : List α
⊢ (xs ++ ys).enum = xs.enum ++ enumFrom xs.length ys
state_after: no goals
Theorem: ContinuousLinearMap.hasFDerivAtFilter
File: Mathlib/Analysis/Calculus/FDeriv/Linear.lean

tactic: simp only [e.map_sub, sub_self]
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
x : E
⊢ 0 = e x - e x✝ - e (x - x✝)
state_after: no goals
Theorem: UniformConvexOn.convexOn
File: Mathlib/Analysis/Convex/Strong.lean

tactic: simpa using hf.mono hφ
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℝ E
φ ψ : ℝ → ℝ
s : Set E
a b m : ℝ
x y : E
f g : E → ℝ
hf : UniformConvexOn s φ f
hφ : 0 ≤ φ
⊢ ConvexOn ℝ s f
state_after: no goals
Theorem: FractionalIdeal.dual_zero
File: Mathlib/RingTheory/DedekindDomain/Different.lean

tactic: rw [dual, dif_pos rfl]
state_before: A : Type u_1
K : Type u_2
L : Type u
B : Type u_3
inst✝¹⁹ : CommRing A
inst✝¹⁸ : Field K
inst✝¹⁷ : CommRing B
inst✝¹⁶ : Field L
inst✝¹⁵ : Algebra A K
inst✝¹⁴ : Algebra B L
inst✝¹³ : Algebra A B
inst✝¹² : Algebra K L
inst✝¹¹ : Algebra A L
inst✝¹⁰ : IsScalarTower A K L
inst✝⁹ : IsScalarTower A B L
inst✝⁸ : IsDomain A
inst✝⁷ : IsDomain B
inst✝⁶ : IsFractionRing A K
inst✝⁵ : IsIntegralClosure B A L
inst✝⁴ : IsFractionRing B L
inst✝³ : FiniteDimensional K L
inst✝² : IsSeparable K L
inst✝¹ : IsIntegrallyClosed A
inst✝ : IsDedekindDomain B
I J : FractionalIdeal B⁰ L
hI : I ≠ 0
hJ : J ≠ 0
⊢ dual A K 0 = 0
state_after: no goals