1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.OuterMeasure.trim_eq_iInf
File: Mathlib/MeasureTheory/OuterMeasure/Induced.lean

tactic: simp (config := { singlePass := true }) only [iInf_comm]
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m : OuterMeasure α
s : Set α
⊢ m.trim s = ⨅ t, ⨅ (_ : s ⊆ t), ⨅ (_ : MeasurableSet t), m t
state_after: α : Type u_1
inst✝ : MeasurableSpace α
m : OuterMeasure α
s : Set α
⊢ m.trim s = ⨅ t, ⨅ (_ : MeasurableSet t), ⨅ (_ : s ⊆ t), m t

tactic: exact
  inducedOuterMeasure_eq_iInf MeasurableSet.iUnion (fun f _ => measure_iUnion_le f)
    (fun _ _ _ _ h => measure_mono h) s
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m : OuterMeasure α
s : Set α
⊢ m.trim s = ⨅ t, ⨅ (_ : MeasurableSet t), ⨅ (_ : s ⊆ t), m t
state_after: no goals
Theorem: List.isRotated_next_eq
File: Mathlib/Data/List/Cycle.lean

tactic: obtain ⟨k, hk, rfl⟩ := get_of_mem hx
state_before: α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x✝ : α
l l' : List α
h : l ~r l'
hn : l.Nodup
x : α
hx : x ∈ l
⊢ l.next x hx = l'.next x ⋯
state_after: case intro.refl
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l l' : List α
h : l ~r l'
hn : l.Nodup
k : Fin l.length
hx : l.get k ∈ l
⊢ l.next (l.get k) hx = l'.next (l.get k) ⋯

tactic: obtain ⟨n, rfl⟩ := id h
state_before: case intro.refl
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l l' : List α
h : l ~r l'
hn : l.Nodup
k : Fin l.length
hx : l.get k ∈ l
⊢ l.next (l.get k) hx = l'.next (l.get k) ⋯
state_after: case intro.refl.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hn : l.Nodup
k : Fin l.length
hx : l.get k ∈ l
n : ℕ
h : l ~r l.rotate n
⊢ l.next (l.get k) hx = (l.rotate n).next (l.get k) ⋯

tactic: rw [next_get _ hn]
state_before: case intro.refl.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hn : l.Nodup
k : Fin l.length
hx : l.get k ∈ l
n : ℕ
h : l ~r l.rotate n
⊢ l.next (l.get k) hx = (l.rotate n).next (l.get k) ⋯
state_after: case intro.refl.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hn : l.Nodup
k : Fin l.length
hx : l.get k ∈ l
n : ℕ
h : l ~r l.rotate n
⊢ l.get ⟨(↑k + 1) % l.length, ⋯⟩ = (l.rotate n).next (l.get k) ⋯

tactic: simp_rw [get_eq_get_rotate _ n k]
state_before: case intro.refl.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hn : l.Nodup
k : Fin l.length
hx : l.get k ∈ l
n : ℕ
h : l ~r l.rotate n
⊢ l.get ⟨(↑k + 1) % l.length, ⋯⟩ = (l.rotate n).next (l.get k) ⋯
state_after: case intro.refl.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hn : l.Nodup
k : Fin l.length
hx : l.get k ∈ l
n : ℕ
h : l ~r l.rotate n
⊢ l.get ⟨(↑k + 1) % l.length, ⋯⟩ = (l.rotate n).next ((l.rotate n).get ⟨(l.length - n % l.length + ↑k) % l.length, ⋯⟩) ⋯

tactic: rw [next_get _ (h.nodup_iff.mp hn), get_eq_get_rotate _ n]
state_before: case intro.refl.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hn : l.Nodup
k : Fin l.length
hx : l.get k ∈ l
n : ℕ
h : l ~r l.rotate n
⊢ l.get ⟨(↑k + 1) % l.length, ⋯⟩ = (l.rotate n).next ((l.rotate n).get ⟨(l.length - n % l.length + ↑k) % l.length, ⋯⟩) ⋯
state_after: case intro.refl.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hn : l.Nodup
k : Fin l.length
hx : l.get k ∈ l
n : ℕ
h : l ~r l.rotate n
⊢ (l.rotate n).get ⟨(l.length - n % l.length + ↑⟨(↑k + 1) % l.length, ⋯⟩) % l.length, ⋯⟩ =
    (l.rotate n).get ⟨(↑⟨(l.length - n % l.length + ↑k) % l.length, ⋯⟩ + 1) % (l.rotate n).length, ⋯⟩

tactic: simp [add_assoc]
state_before: case intro.refl.intro
α : Type u_1
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hn : l.Nodup
k : Fin l.length
hx : l.get k ∈ l
n : ℕ
h : l ~r l.rotate n
⊢ (l.rotate n).get ⟨(l.length - n % l.length + ↑⟨(↑k + 1) % l.length, ⋯⟩) % l.length, ⋯⟩ =
    (l.rotate n).get ⟨(↑⟨(l.length - n % l.length + ↑k) % l.length, ⋯⟩ + 1) % (l.rotate n).length, ⋯⟩
state_after: no goals
Theorem: Traversable.naturality'
File: Mathlib/Control/Traversable/Lemmas.lean

tactic: simp [sequence, naturality, traverse_map]
state_before: t : Type u → Type u
inst✝⁵ : Traversable t
inst✝⁴ : LawfulTraversable t
F G : Type u → Type u
inst✝³ : Applicative F
inst✝² : LawfulApplicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α β γ : Type u
g : α → F β
h : β → G γ
f : β → γ
x✝ : t β
η : ApplicativeTransformation F G
x : t (F α)
⊢ (fun {α} => η.app α) (sequence x) = sequence ((fun {α} => η.app α) <$> x)
state_after: no goals
Theorem: Function.Surjective.wellFounded_iff
File: Mathlib/Order/RelIso/Basic.lean

tactic: simpa only [o, surjInv_eq hf] using h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
u : δ → δ → Prop
f : α → β
hf : Surjective f
o : ∀ {a b : α}, r a b ↔ s (f a) (f b)
a✝ b✝ : β
h : s a✝ b✝
⊢ r (surjInv hf a✝) (surjInv hf b✝)
state_after: no goals
Theorem: CategoryTheory.Limits.pullbackSymmetry_hom_of_mono_eq
File: Mathlib/CategoryTheory/Limits/Shapes/Pullbacks.lean

tactic: ext
state_before: C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (pullbackSymmetry f f).hom = 𝟙 (pullback f f)
state_after: case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (pullbackSymmetry f f).hom ≫ pullback.fst = 𝟙 (pullback f f) ≫ pullback.fst

case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (pullbackSymmetry f f).hom ≫ pullback.snd = 𝟙 (pullback f f) ≫ pullback.snd

tactic: simp [fst_eq_snd_of_mono_eq]
state_before: case h₀
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (pullbackSymmetry f f).hom ≫ pullback.fst = 𝟙 (pullback f f) ≫ pullback.fst
state_after: no goals

tactic: simp [fst_eq_snd_of_mono_eq]
state_before: case h₁
C : Type u
inst✝² : Category.{v, u} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
W X Y Z : C
f : X ⟶ Y
inst✝ : Mono f
⊢ (pullbackSymmetry f f).hom ≫ pullback.snd = 𝟙 (pullback f f) ≫ pullback.snd
state_after: no goals
Theorem: CategoryTheory.Limits.colimitHomIsoLimitYoneda_hom_comp_π
File: Mathlib/CategoryTheory/Limits/IndYoneda.lean

tactic: simp only [colimitHomIsoLimitYoneda, Iso.trans_hom, Iso.app_hom, Category.assoc]
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
I : Type v₁
inst✝² : Category.{v₂, v₁} I
F : I ⥤ C
inst✝¹ : HasColimit F
inst✝ : HasLimitsOfShape Iᵒᵖ (Type u₂)
A : C
i : I
⊢ (colimitHomIsoLimitYoneda F A).hom ≫ limit.π (F.op ⋙ yoneda.obj A) { unop := i } =
    (coyoneda.map (colimit.ι F i).op).app A
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
I : Type v₁
inst✝² : Category.{v₂, v₁} I
F : I ⥤ C
inst✝¹ : HasColimit F
inst✝ : HasLimitsOfShape Iᵒᵖ (Type u₂)
A : C
i : I
⊢ (coyonedaOpColimitIsoLimitCoyoneda F).hom.app A ≫
      (limitObjIsoLimitCompEvaluation (F.op ⋙ coyoneda) A).hom ≫ limit.π (F.op ⋙ yoneda.obj A) { unop := i } =
    (coyoneda.map (colimit.ι F i).op).app A

tactic: erw [limitObjIsoLimitCompEvaluation_hom_π]
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
I : Type v₁
inst✝² : Category.{v₂, v₁} I
F : I ⥤ C
inst✝¹ : HasColimit F
inst✝ : HasLimitsOfShape Iᵒᵖ (Type u₂)
A : C
i : I
⊢ (coyonedaOpColimitIsoLimitCoyoneda F).hom.app A ≫
      (limitObjIsoLimitCompEvaluation (F.op ⋙ coyoneda) A).hom ≫ limit.π (F.op ⋙ yoneda.obj A) { unop := i } =
    (coyoneda.map (colimit.ι F i).op).app A
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
I : Type v₁
inst✝² : Category.{v₂, v₁} I
F : I ⥤ C
inst✝¹ : HasColimit F
inst✝ : HasLimitsOfShape Iᵒᵖ (Type u₂)
A : C
i : I
⊢ (coyonedaOpColimitIsoLimitCoyoneda F).hom.app A ≫ (limit.π (F.op ⋙ coyoneda) { unop := i }).app A =
    (coyoneda.map (colimit.ι F i).op).app A

tactic: change ((coyonedaOpColimitIsoLimitCoyoneda F).hom ≫ _).app A = _
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
I : Type v₁
inst✝² : Category.{v₂, v₁} I
F : I ⥤ C
inst✝¹ : HasColimit F
inst✝ : HasLimitsOfShape Iᵒᵖ (Type u₂)
A : C
i : I
⊢ (coyonedaOpColimitIsoLimitCoyoneda F).hom.app A ≫ (limit.π (F.op ⋙ coyoneda) { unop := i }).app A =
    (coyoneda.map (colimit.ι F i).op).app A
state_after: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
I : Type v₁
inst✝² : Category.{v₂, v₁} I
F : I ⥤ C
inst✝¹ : HasColimit F
inst✝ : HasLimitsOfShape Iᵒᵖ (Type u₂)
A : C
i : I
⊢ ((coyonedaOpColimitIsoLimitCoyoneda F).hom ≫ limit.π (F.op ⋙ coyoneda) { unop := i }).app A =
    (coyoneda.map (colimit.ι F i).op).app A

tactic: rw [coyonedaOpColimitIsoLimitCoyoneda_hom_comp_π]
state_before: C : Type u₁
inst✝³ : Category.{u₂, u₁} C
I : Type v₁
inst✝² : Category.{v₂, v₁} I
F : I ⥤ C
inst✝¹ : HasColimit F
inst✝ : HasLimitsOfShape Iᵒᵖ (Type u₂)
A : C
i : I
⊢ ((coyonedaOpColimitIsoLimitCoyoneda F).hom ≫ limit.π (F.op ⋙ coyoneda) { unop := i }).app A =
    (coyoneda.map (colimit.ι F i).op).app A
state_after: no goals
Theorem: MeasureTheory.exp_llr_of_ac'
File: Mathlib/MeasureTheory/Measure/LogLikelihoodRatio.lean

tactic: filter_upwards [exp_llr μ ν, Measure.rnDeriv_pos' hμν] with x hx hx_pos
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : ν ≪ μ
⊢ (fun x => rexp (llr μ ν x)) =ᶠ[ae ν] fun x => (μ.rnDeriv ν x).toReal
state_after: case h
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : ν ≪ μ
x : α
hx : rexp (llr μ ν x) = if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal
hx_pos : 0 < μ.rnDeriv ν x
⊢ rexp (llr μ ν x) = (μ.rnDeriv ν x).toReal

tactic: rwa [if_neg hx_pos.ne'] at hx
state_before: case h
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝¹ : SigmaFinite μ
inst✝ : SigmaFinite ν
hμν : ν ≪ μ
x : α
hx : rexp (llr μ ν x) = if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal
hx_pos : 0 < μ.rnDeriv ν x
⊢ rexp (llr μ ν x) = (μ.rnDeriv ν x).toReal
state_after: no goals
Theorem: Semiring.toNonUnitalSemiring_injective
File: Mathlib/Algebra/Ring/Ext.lean

tactic: intro _ _ h
state_before: R : Type u
⊢ Function.Injective (@toNonUnitalSemiring R)
state_after: R : Type u
a₁✝ a₂✝ : Semiring R
h : toNonUnitalSemiring = toNonUnitalSemiring
⊢ a₁✝ = a₂✝

tactic: ext x y
state_before: R : Type u
a₁✝ a₂✝ : Semiring R
h : toNonUnitalSemiring = toNonUnitalSemiring
⊢ a₁✝ = a₂✝
state_after: case h_add.h.h
R : Type u
a₁✝ a₂✝ : Semiring R
h : toNonUnitalSemiring = toNonUnitalSemiring
x y : R
⊢ x + y = x + y

case h_mul.h.h
R : Type u
a₁✝ a₂✝ : Semiring R
h : toNonUnitalSemiring = toNonUnitalSemiring
x y : R
⊢ x * y = x * y
Theorem: Hyperreal.infinitesimal_pos_iff_infinitePos_inv
File: Mathlib/Data/Real/Hyperreal.lean

tactic: rw [inv_inv]
state_before: x : ℝ*
⊢ x⁻¹⁻¹.Infinitesimal ∧ 0 < x⁻¹⁻¹ ↔ x.Infinitesimal ∧ 0 < x
state_after: no goals
Theorem: insert_mem_nhdsWithin_of_subset_insert
File: Mathlib/Topology/Separation.lean

tactic: rcases eq_or_ne x y with (rfl | h)
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s t : Set X
hu : t ⊆ insert y s
⊢ insert x s ∈ 𝓝[t] x
state_after: case inl
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x : X
s t : Set X
hu : t ⊆ insert x s
⊢ insert x s ∈ 𝓝[t] x

case inr
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s t : Set X
hu : t ⊆ insert y s
h : x ≠ y
⊢ insert x s ∈ 𝓝[t] x

tactic: refine nhdsWithin_mono x hu ?_
state_before: case inr
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s t : Set X
hu : t ⊆ insert y s
h : x ≠ y
⊢ insert x s ∈ 𝓝[t] x
state_after: case inr
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s t : Set X
hu : t ⊆ insert y s
h : x ≠ y
⊢ insert x s ∈ 𝓝[insert y s] x

tactic: rw [nhdsWithin_insert_of_ne h]
state_before: case inr
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s t : Set X
hu : t ⊆ insert y s
h : x ≠ y
⊢ insert x s ∈ 𝓝[insert y s] x
state_after: case inr
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s t : Set X
hu : t ⊆ insert y s
h : x ≠ y
⊢ insert x s ∈ 𝓝[s] x

tactic: exact mem_of_superset self_mem_nhdsWithin (subset_insert x s)
state_before: case inr
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x y : X
s t : Set X
hu : t ⊆ insert y s
h : x ≠ y
⊢ insert x s ∈ 𝓝[s] x
state_after: no goals

tactic: exact mem_of_superset self_mem_nhdsWithin hu
state_before: case inl
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T1Space X
x : X
s t : Set X
hu : t ⊆ insert x s
⊢ insert x s ∈ 𝓝[t] x
state_after: no goals
Theorem: Real.summable_one_div_int_add_rpow
File: Mathlib/Analysis/PSeries.lean

tactic: simp_rw [summable_int_iff_summable_nat_and_neg, ← abs_neg (↑(-_ : ℤ) + a), neg_add,
  Int.cast_neg, neg_neg, Int.cast_natCast, summable_one_div_nat_add_rpow, and_self]
state_before: a s : ℝ
⊢ (Summable fun n => 1 / |↑n + a| ^ s) ↔ 1 < s
state_after: no goals
Theorem: Configuration.ProjectivePlane.two_lt_pointCount
File: Mathlib/Combinatorics/Configuration.lean

tactic: simpa only [pointCount_eq P l, Nat.succ_lt_succ_iff] using one_lt_order P L
state_before: P : Type u_1
L : Type u_2
inst✝³ : Membership P L
inst✝² : ProjectivePlane P L
inst✝¹ : Finite P
inst✝ : Finite L
l : L
⊢ 2 < pointCount P l
state_after: no goals
Theorem: gronwallBound_ε0_δ0
File: Mathlib/Analysis/ODE/Gronwall.lean

tactic: simp only [gronwallBound_ε0, zero_mul]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
K x : ℝ
⊢ gronwallBound 0 K 0 x = 0
state_after: no goals
Theorem: Ordinal.range_enumOrd
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: rw [range_eq_iff]
state_before: S : Set Ordinal.{u}
hS : Unbounded (fun x x_1 => x < x_1) S
⊢ range (enumOrd S) = S
state_after: S : Set Ordinal.{u}
hS : Unbounded (fun x x_1 => x < x_1) S
⊢ (∀ (a : Ordinal.{u}), enumOrd S a ∈ S) ∧ ∀ b ∈ S, ∃ a, enumOrd S a = b

tactic: exact ⟨enumOrd_mem hS, enumOrd_surjective hS⟩
state_before: S : Set Ordinal.{u}
hS : Unbounded (fun x x_1 => x < x_1) S
⊢ (∀ (a : Ordinal.{u}), enumOrd S a ∈ S) ∧ ∀ b ∈ S, ∃ a, enumOrd S a = b
state_after: no goals
Theorem: hasSum_zeta_two
File: Mathlib/NumberTheory/ZetaValues.lean

tactic: convert hasSum_zeta_nat one_ne_zero using 1
state_before: ⊢ HasSum (fun n => 1 / ↑n ^ 2) (π ^ 2 / 6)
state_after: case h.e'_6

⊢ π ^ 2 / 6 = (-1) ^ (1 + 1) * 2 ^ (2 * 1 - 1) * π ^ (2 * 1) * ↑(bernoulli (2 * 1)) / ↑(2 * 1)!

tactic: rw [mul_one]
state_before: case h.e'_6

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

⊢ π ^ 2 / 6 = (-1) ^ (1 + 1) * 2 ^ (2 - 1) * π ^ 2 * ↑(bernoulli 2) / ↑2!

tactic: rw [bernoulli_eq_bernoulli'_of_ne_one (by decide : 2 ≠ 1), bernoulli'_two]
state_before: case h.e'_6

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

⊢ π ^ 2 / 6 = (-1) ^ (1 + 1) * 2 ^ (2 - 1) * π ^ 2 * ↑(1 / 6) / ↑2!

tactic: norm_num [Nat.factorial]
state_before: case h.e'_6

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

⊢ π ^ 2 / 6 = 2 * π ^ 2 * (1 / 6) / 2

tactic: field_simp
state_before: case h.e'_6

⊢ π ^ 2 / 6 = 2 * π ^ 2 * (1 / 6) / 2
state_after: case h.e'_6

⊢ π ^ 2 * (6 * 2) = 2 * π ^ 2 * 6

tactic: ring
state_before: case h.e'_6

⊢ π ^ 2 * (6 * 2) = 2 * π ^ 2 * 6
state_after: no goals

tactic: decide
state_before: ⊢ 2 ≠ 1
state_after: no goals
Theorem: Polynomial.Monic.nextCoeff_pow
File: Mathlib/Algebra/Polynomial/Monic.lean

tactic: induction n with
| zero => rw [pow_zero, zero_smul, ← map_one (f := C), nextCoeff_C_eq_zero]
| succ n ih => rw [pow_succ, (hp.pow n).nextCoeff_mul hp, ih, succ_nsmul]
state_before: R : Type u
S : Type v
a b : R
m n✝ : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
n : ℕ
⊢ (p ^ n).nextCoeff = n • p.nextCoeff
state_after: no goals

tactic: rw [pow_zero, zero_smul, ← map_one (f := C), nextCoeff_C_eq_zero]
state_before: case zero
R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
⊢ (p ^ 0).nextCoeff = 0 • p.nextCoeff
state_after: no goals

tactic: rw [pow_succ, (hp.pow n).nextCoeff_mul hp, ih, succ_nsmul]
state_before: case succ
R : Type u
S : Type v
a b : R
m n✝ : ℕ
ι : Type y
inst✝ : Semiring R
p q r : R[X]
hp : p.Monic
n : ℕ
ih : (p ^ n).nextCoeff = n • p.nextCoeff
⊢ (p ^ (n + 1)).nextCoeff = (n + 1) • p.nextCoeff
state_after: no goals
Theorem: IsArtinianRing.primeSpectrum_finite
File: Mathlib/RingTheory/Artinian.lean

tactic: set Spec := {I : Ideal R | I.IsPrime}
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsArtinianRing R
⊢ {I | I.IsPrime}.Finite
state_after: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsArtinianRing R
Spec : Set (Ideal R) := {I | I.IsPrime}
⊢ Spec.Finite

tactic: refine Set.finite_def.2 ⟨s, fun p ↦ ?_⟩
state_before: case intro.intro.intro
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsArtinianRing R
Spec : Set (Ideal R) := {I | I.IsPrime}
s : Finset ↑Spec
H : ∀ I ∈ range fun x => x.inf Subtype.val, ¬I < (fun x => x.inf Subtype.val) s
⊢ Spec.Finite
state_after: case intro.intro.intro
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsArtinianRing R
Spec : Set (Ideal R) := {I | I.IsPrime}
s : Finset ↑Spec
H : ∀ I ∈ range fun x => x.inf Subtype.val, ¬I < (fun x => x.inf Subtype.val) s
p : ↑Spec
⊢ p ∈ s

tactic: classical
obtain ⟨q, hq1, hq2⟩ := p.2.inf_le'.mp <| inf_eq_right.mp <|
  inf_le_right.eq_of_not_lt (H (p ⊓ s.inf Subtype.val) ⟨insert p s, by simp⟩)
rwa [← Subtype.ext <| (@isMaximal_of_isPrime _ _ _ _ q.2).eq_of_le p.2.1 hq2]
state_before: case intro.intro.intro
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsArtinianRing R
Spec : Set (Ideal R) := {I | I.IsPrime}
s : Finset ↑Spec
H : ∀ I ∈ range fun x => x.inf Subtype.val, ¬I < (fun x => x.inf Subtype.val) s
p : ↑Spec
⊢ p ∈ s
state_after: no goals

tactic: simp
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsArtinianRing R
Spec : Set (Ideal R) := {I | I.IsPrime}
⊢ (fun x => x.inf Subtype.val) ∅ = ⊤
state_after: no goals

tactic: obtain ⟨q, hq1, hq2⟩ := p.2.inf_le'.mp <| inf_eq_right.mp <|
  inf_le_right.eq_of_not_lt (H (p ⊓ s.inf Subtype.val) ⟨insert p s, by simp⟩)
state_before: case intro.intro.intro
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsArtinianRing R
Spec : Set (Ideal R) := {I | I.IsPrime}
s : Finset ↑Spec
H : ∀ I ∈ range fun x => x.inf Subtype.val, ¬I < (fun x => x.inf Subtype.val) s
p : ↑Spec
⊢ p ∈ s
state_after: case intro.intro.intro.intro.intro
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsArtinianRing R
Spec : Set (Ideal R) := {I | I.IsPrime}
s : Finset ↑Spec
H : ∀ I ∈ range fun x => x.inf Subtype.val, ¬I < (fun x => x.inf Subtype.val) s
p q : ↑Spec
hq1 : q ∈ s
hq2 : ↑q ≤ ↑p
⊢ p ∈ s

tactic: rwa [← Subtype.ext <| (@isMaximal_of_isPrime _ _ _ _ q.2).eq_of_le p.2.1 hq2]
state_before: case intro.intro.intro.intro.intro
R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsArtinianRing R
Spec : Set (Ideal R) := {I | I.IsPrime}
s : Finset ↑Spec
H : ∀ I ∈ range fun x => x.inf Subtype.val, ¬I < (fun x => x.inf Subtype.val) s
p q : ↑Spec
hq1 : q ∈ s
hq2 : ↑q ≤ ↑p
⊢ p ∈ s
state_after: no goals

tactic: simp
state_before: R : Type u_1
inst✝¹ : CommRing R
inst✝ : IsArtinianRing R
Spec : Set (Ideal R) := {I | I.IsPrime}
s : Finset ↑Spec
H : ∀ I ∈ range fun x => x.inf Subtype.val, ¬I < (fun x => x.inf Subtype.val) s
p : ↑Spec
⊢ (fun x => x.inf Subtype.val) (insert p s) = ↑p ⊓ s.inf Subtype.val
state_after: no goals
Theorem: GeneralizedContinuedFraction.exists_int_eq_of_part_denom
File: Mathlib/Algebra/ContinuedFractions/Computation/Approximations.lean

tactic: obtain ⟨gp, nth_s_eq, gp_b_eq_b_n⟩ : ∃ gp, (of v).s.get? n = some gp ∧ gp.b = b :=
  exists_s_b_of_part_denom nth_part_denom_eq
state_before: K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
b : K
nth_part_denom_eq : (of v).partialDenominators.get? n = some b
⊢ ∃ z, b = ↑z
state_after: case intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
b : K
nth_part_denom_eq : (of v).partialDenominators.get? n = some b
gp : Pair K
nth_s_eq : (of v).s.get? n = some gp
gp_b_eq_b_n : gp.b = b
⊢ ∃ z, b = ↑z

tactic: have : ∃ z : ℤ, gp.b = (z : K) := (of_part_num_eq_one_and_exists_int_part_denom_eq nth_s_eq).right
state_before: case intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
b : K
nth_part_denom_eq : (of v).partialDenominators.get? n = some b
gp : Pair K
nth_s_eq : (of v).s.get? n = some gp
gp_b_eq_b_n : gp.b = b
⊢ ∃ z, b = ↑z
state_after: case intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
b : K
nth_part_denom_eq : (of v).partialDenominators.get? n = some b
gp : Pair K
nth_s_eq : (of v).s.get? n = some gp
gp_b_eq_b_n : gp.b = b
this : ∃ z, gp.b = ↑z
⊢ ∃ z, b = ↑z

tactic: rwa [gp_b_eq_b_n] at this
state_before: case intro.intro
K : Type u_1
v : K
n : ℕ
inst✝¹ : LinearOrderedField K
inst✝ : FloorRing K
b : K
nth_part_denom_eq : (of v).partialDenominators.get? n = some b
gp : Pair K
nth_s_eq : (of v).s.get? n = some gp
gp_b_eq_b_n : gp.b = b
this : ∃ z, gp.b = ↑z
⊢ ∃ z, b = ↑z
state_after: no goals
Theorem: separatedNhds_iff_disjoint
File: Mathlib/Topology/Separation.lean

tactic: simp only [(hasBasis_nhdsSet s).disjoint_iff (hasBasis_nhdsSet t), SeparatedNhds, exists_prop, ←
  exists_and_left, and_assoc, and_comm, and_left_comm]
state_before: X : Type u_1
Y : Type u_2
inst✝ : TopologicalSpace X
s t : Set X
⊢ SeparatedNhds s t ↔ Disjoint (𝓝ˢ s) (𝓝ˢ t)
state_after: no goals
Theorem: Finpartition.energy_nonneg
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Energy.lean

tactic: exact div_nonneg (Finset.sum_nonneg fun _ _ => sq_nonneg _) <| sq_nonneg _
state_before: α : Type u_1
inst✝¹ : DecidableEq α
s : Finset α
P : Finpartition s
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
⊢ 0 ≤ P.energy G
state_after: no goals
Theorem: Batteries.UnionFind.rankMax_push
File: .lake/packages/batteries/Batteries/Data/UnionFind/Lemmas.lean

tactic: simp [rankMax]
state_before: m : UnionFind
⊢ m.push.rankMax = m.rankMax
state_after: no goals
Theorem: List.iterate_add
File: Mathlib/Data/List/Iterate.lean

tactic: induction m generalizing a with
| zero => simp
| succ n ih => rw [iterate, add_right_comm, iterate, ih, Nat.iterate, cons_append]
state_before: α : Type u_1
f : α → α
a : α
m n : ℕ
⊢ iterate f a (m + n) = iterate f a m ++ iterate f (f^[m] a) n
state_after: no goals

tactic: simp
state_before: case zero
α : Type u_1
f : α → α
n : ℕ
a : α
⊢ iterate f a (0 + n) = iterate f a 0 ++ iterate f (f^[0] a) n
state_after: no goals

tactic: rw [iterate, add_right_comm, iterate, ih, Nat.iterate, cons_append]
state_before: case succ
α : Type u_1
f : α → α
n✝ n : ℕ
ih : ∀ (a : α), iterate f a (n + n✝) = iterate f a n ++ iterate f (f^[n] a) n✝
a : α
⊢ iterate f a (n + 1 + n✝) = iterate f a (n + 1) ++ iterate f (f^[n + 1] a) n✝
state_after: no goals
Theorem: Sum.eq_left_iff_getLeft_eq
File: Mathlib/Data/Sum/Basic.lean

tactic: cases x <;> simp
state_before: α : Type u
α' : Type w
β : Type v
β' : Type x
γ : Type u_1
δ : Type u_2
x y : α ⊕ β
a : α
⊢ x = inl a ↔ ∃ h, x.getLeft h = a
state_after: no goals
Theorem: Finsupp.erase_update_of_ne
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rw [erase_eq_update_zero, erase_eq_update_zero, update_comm _ ha]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
f : α →₀ M
a a' : α
ha : a ≠ a'
b : M
⊢ erase a (f.update a' b) = (erase a f).update a' b
state_after: no goals
Theorem: ProbabilityTheory.kernel.compProd_fst_condKernelUnitBorel
File: Mathlib/Probability/Kernel/Disintegration/Basic.lean

tactic: rw [condKernelUnitBorel,
  compProd_fst_borelMarkovFromReal _ _ (compProd_fst_condKernelUnitReal _)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
Ω : Type u_4
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
inst✝⁴ : CountablyGenerated γ
inst✝³ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
κ : ↥(kernel Unit (α × Ω))
inst✝ : IsFiniteKernel κ
⊢ fst κ ⊗ₖ condKernelUnitBorel κ = κ
state_after: no goals