ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Finpartition.IsEquipartition.card_small_parts_eq_mod
File: Mathlib/Order/Partition/Equipartition.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
⊢ (filter (fun p => p.card = s.card / P.parts.card) P.parts).card = P.parts.card - s.card % P.parts.card
state_after: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
⊢ (filter (fun p => p.card = s.card / P.parts.card) P.parts).card =
    (filter (fun p => p.card = s.card / P.parts.card + 1) P.parts).card +
        (filter (fun a => ¬a.card = s.card / P.parts.card + 1) P.parts).card -
      s.card % P.parts.card
tactic: conv_rhs =>
    arg 1
    rw [← filter_card_add_filter_neg_card_eq_card (p := fun p ↦ p.card = s.card / P.parts.card + 1)]
state_before: α : Type u_1
inst✝ : DecidableEq α
s t : Finset α
P : Finpartition s
hP : P.IsEquipartition
⊢ (filter (fun p => p.card = s.card / P.parts.card) P.parts).card =
    (filter (fun p => p.card = s.card / P.parts.card + 1) P.parts).card +
        (filter (fun a => ¬a.card = s.card / P.parts.card + 1) P.parts).card -
      s.card % P.parts.card
state_after: no goals
tactic: rw [hP.card_large_parts_eq_mod, add_tsub_cancel_left, hP.filter_ne_average_add_one_eq_average]
Theorem: Matrix.rank_submatrix
File: Mathlib/Data/Matrix/Rank.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
R : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommRing R
inst✝ : Fintype m
A : Matrix m m R
e₁ e₂ : n ≃ m
⊢ (A.submatrix ⇑e₁ ⇑e₂).rank = A.rank
state_after: no goals
tactic: simpa only [reindex_apply] using rank_reindex e₁.symm e₂.symm A
Theorem: NormedAddCommGroup.tendsto_nhds_zero
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
f : α → E
l : Filter α
⊢ (∀ ε > 0, ∀ᶠ (x : α) in l, dist (f x) 1 < ε) ↔ ∀ ε > 0, ∀ᶠ (x : α) in l, ‖f x‖ < ε
state_after: no goals
tactic: simp only [dist_one_right]
Theorem: CategoryTheory.Functor.homologySequence_exact₂
File: Mathlib/CategoryTheory/Triangulated/HomologicalFunctor.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
A : Type u_3
inst✝¹⁶ : Category.{u_5, u_1} C
inst✝¹⁵ : HasZeroObject C
inst✝¹⁴ : HasShift C ℤ
inst✝¹³ : Preadditive C
inst✝¹² : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝¹¹ : Pretriangulated C
inst✝¹⁰ : Category.{?u.57069, u_2} D
inst✝⁹ : HasZeroObject D
inst✝⁸ : HasShift D ℤ
inst✝⁷ : Preadditive D
inst✝⁶ : ∀ (n : ℤ), (shiftFunctor D n).Additive
inst✝⁵ : Pretriangulated D
inst✝⁴ : Category.{u_4, u_3} A
inst✝³ : Abelian A
F : C ⥤ A
inst✝² inst✝¹ : F.IsHomological
inst✝ : F.ShiftSequence ℤ
T T' : Triangle C
hT : T ∈ distinguishedTriangles
hT' : T' ∈ distinguishedTriangles
φ : T ⟶ T'
n₀ n₁ : ℤ
h : n₀ + 1 = n₁
⊢ (ShortComplex.mk ((F.shift n₀).map T.mor₁) ((F.shift n₀).map T.mor₂) ⋯).Exact
state_after: C : Type u_1
D : Type u_2
A : Type u_3
inst✝¹⁶ : Category.{u_5, u_1} C
inst✝¹⁵ : HasZeroObject C
inst✝¹⁴ : HasShift C ℤ
inst✝¹³ : Preadditive C
inst✝¹² : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝¹¹ : Pretriangulated C
inst✝¹⁰ : Category.{?u.57069, u_2} D
inst✝⁹ : HasZeroObject D
inst✝⁸ : HasShift D ℤ
inst✝⁷ : Preadditive D
inst✝⁶ : ∀ (n : ℤ), (shiftFunctor D n).Additive
inst✝⁵ : Pretriangulated D
inst✝⁴ : Category.{u_4, u_3} A
inst✝³ : Abelian A
F : C ⥤ A
inst✝² inst✝¹ : F.IsHomological
inst✝ : F.ShiftSequence ℤ
T T' : Triangle C
hT : T ∈ distinguishedTriangles
hT' : T' ∈ distinguishedTriangles
φ : T ⟶ T'
n₀ n₁ : ℤ
h : n₀ + 1 = n₁
⊢ (shortComplexOfDistTriangle ((shiftFunctor (Triangle C) n₀).obj T) ⋯).map F ≅
    ShortComplex.mk ((F.shift n₀).map T.mor₁) ((F.shift n₀).map T.mor₂) ⋯
tactic: refine ShortComplex.exact_of_iso ?_ (F.map_distinguished_exact _
    (Triangle.shift_distinguished _ hT n₀))
state_before: C : Type u_1
D : Type u_2
A : Type u_3
inst✝¹⁶ : Category.{u_5, u_1} C
inst✝¹⁵ : HasZeroObject C
inst✝¹⁴ : HasShift C ℤ
inst✝¹³ : Preadditive C
inst✝¹² : ∀ (n : ℤ), (shiftFunctor C n).Additive
inst✝¹¹ : Pretriangulated C
inst✝¹⁰ : Category.{?u.57069, u_2} D
inst✝⁹ : HasZeroObject D
inst✝⁸ : HasShift D ℤ
inst✝⁷ : Preadditive D
inst✝⁶ : ∀ (n : ℤ), (shiftFunctor D n).Additive
inst✝⁵ : Pretriangulated D
inst✝⁴ : Category.{u_4, u_3} A
inst✝³ : Abelian A
F : C ⥤ A
inst✝² inst✝¹ : F.IsHomological
inst✝ : F.ShiftSequence ℤ
T T' : Triangle C
hT : T ∈ distinguishedTriangles
hT' : T' ∈ distinguishedTriangles
φ : T ⟶ T'
n₀ n₁ : ℤ
h : n₀ + 1 = n₁
⊢ (shortComplexOfDistTriangle ((shiftFunctor (Triangle C) n₀).obj T) ⋯).map F ≅
    ShortComplex.mk ((F.shift n₀).map T.mor₁) ((F.shift n₀).map T.mor₂) ⋯
state_after: no goals
tactic: exact ShortComplex.isoMk ((F.isoShift n₀).app _)
    (n₀.negOnePow • ((F.isoShift n₀).app _)) ((F.isoShift n₀).app _) (by simp) (by simp)
Theorem: Fin.min_val
File: Mathlib/Data/Fin/Basic.lean

Proof steps:
state_before: n m : ℕ
a : Fin n
⊢ min (↑a) n = ↑a
state_after: no goals
tactic: simp
Theorem: Uniform.continuousAt_iff'_right
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : TopologicalSpace β
f : β → α
b : β
⊢ ContinuousAt f b ↔ Tendsto (fun x => (f b, f x)) (𝓝 b) (𝓤 α)
state_after: no goals
tactic: rw [ContinuousAt, tendsto_nhds_right]
Theorem: VitaliFamily.FineSubfamilyOn.measure_le_tsum_of_absolutelyContinuous
File: Mathlib/MeasureTheory/Covering/VitaliFamily.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : v.FineSubfamilyOn f s
inst✝ : SecondCountableTopology α
ρ : Measure α
hρ : ρ ≪ μ
⊢ s ⊆ (s \ ⋃ p ∈ h.index, h.covering p) ∪ ⋃ p ∈ h.index, h.covering p
state_after: no goals
tactic: simp only [subset_union_left, diff_union_self]
state_before: α : Type u_1
inst✝¹ : MetricSpace α
m0 : MeasurableSpace α
μ : Measure α
v : VitaliFamily μ
f : α → Set (Set α)
s : Set α
h : v.FineSubfamilyOn f s
inst✝ : SecondCountableTopology α
ρ : Measure α
hρ : ρ ≪ μ
⊢ ρ (s \ ⋃ p ∈ h.index, h.covering p) + ρ (⋃ p ∈ h.index, h.covering p) = ∑' (p : ↑h.index), ρ (h.covering ↑p)
state_after: no goals
tactic: rw [hρ h.measure_diff_biUnion, zero_add,
        measure_biUnion h.index_countable h.covering_disjoint fun x hx => h.measurableSet_u hx]
Theorem: Stream'.WSeq.get?_mem
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
a : α
n : ℕ
⊢ some a ∈ s.get? n → a ∈ s
state_after: α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
⊢ ∀ {s : WSeq α}, some a ∈ s.get? n → a ∈ s
tactic: revert s
state_before: α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
⊢ ∀ {s : WSeq α}, some a ∈ s.get? n → a ∈ s
state_after: case zero
α : Type u
β : Type v
γ : Type w
a : α
s : WSeq α
h : some a ∈ s.get? 0
⊢ a ∈ s

case succ
α : Type u
β : Type v
γ : Type w
a : α
n : ℕ
IH : ∀ {s : WSeq α}, some a ∈ s.get? n → a ∈ s
s : WSeq α
h : some a ∈ s.get? (n + 1)
⊢ a ∈ s
tactic: induction' n with n IH <;> intro s h
Theorem: Finset.map_subtype_embedding_Ioo
File: Mathlib/Order/Interval/Finset/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
⊢ map (Embedding.subtype p) (Ioo a b) = Ioo ↑a ↑b
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Ioo ↑a ↑b)) = Ioo ↑a ↑b
tactic: rw [subtype_Ioo_eq]
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Ioo ↑a ↑b)) = Ioo ↑a ↑b
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : x ∈ Ioo ↑a ↑b
⊢ p x
tactic: refine Finset.subtype_map_of_mem fun x hx => ?_
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : x ∈ Ioo ↑a ↑b
⊢ p x
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : ↑a < x ∧ x < ↑b
⊢ p x
tactic: rw [mem_Ioo] at hx
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrder α
a b : Subtype p
hp : ∀ ⦃a b x : α⦄, a ≤ x → x ≤ b → p a → p b → p x
x : α
hx : ↑a < x ∧ x < ↑b
⊢ p x
state_after: no goals
tactic: exact hp hx.1.le hx.2.le a.prop b.prop
Theorem: Action.rightDual_ρ
File: Mathlib/RepresentationTheory/Action/Monoidal.lean

Proof steps:
state_before: V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : RightRigidCategory V
h : ↑H
⊢ Xᘁ.ρ h = X.ρ h⁻¹ᘁ
state_after: V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : RightRigidCategory V
h : ↑H
⊢ Xᘁ.ρ h = X.ρ (inv h)ᘁ

case x
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : RightRigidCategory V
h : ↑H
⊢ SingleObj H.1

case y
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : RightRigidCategory V
h : ↑H
⊢ SingleObj H.1
tactic: rw [← SingleObj.inv_as_inv]
state_before: V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : RightRigidCategory V
h : ↑H
⊢ Xᘁ.ρ h = X.ρ (inv h)ᘁ

case x
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : RightRigidCategory V
h : ↑H
⊢ SingleObj H.1

case y
V : Type (u + 1)
inst✝² : LargeCategory V
G : MonCat
inst✝¹ : MonoidalCategory V
H : Grp
X : Action V ((forget₂ Grp MonCat).obj H)
inst✝ : RightRigidCategory V
h : ↑H
⊢ SingleObj H.1
state_after: no goals
tactic: rfl
Theorem: Function.Semiconj.symm_adjoint
File: Mathlib/Order/SemiconjSup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
fa : α ≃o α
fb : β ↪o β
g : α → β
h : Semiconj g ⇑fa ⇑fb
g' : β → α
hg' : IsOrderRightAdjoint g g'
⊢ Semiconj g' ⇑fb ⇑fa
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
fa : α ≃o α
fb : β ↪o β
g : α → β
h : Semiconj g ⇑fa ⇑fb
g' : β → α
hg' : IsOrderRightAdjoint g g'
y : β
⊢ IsLUB {x | g x ≤ fb y} (fa (g' y))
tactic: refine fun y => (hg' _).unique ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
fa : α ≃o α
fb : β ↪o β
g : α → β
h : Semiconj g ⇑fa ⇑fb
g' : β → α
hg' : IsOrderRightAdjoint g g'
y : β
⊢ IsLUB {x | g x ≤ fb y} (fa (g' y))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
fa : α ≃o α
fb : β ↪o β
g : α → β
h : Semiconj g ⇑fa ⇑fb
g' : β → α
hg' : IsOrderRightAdjoint g g'
y : β
⊢ IsLUB (⇑fa '' {a | g (fa a) ≤ fb y}) (fa (g' y))
tactic: rw [← fa.surjective.image_preimage { x | g x ≤ fb y }, preimage_setOf_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : PartialOrder α
inst✝ : Preorder β
fa : α ≃o α
fb : β ↪o β
g : α → β
h : Semiconj g ⇑fa ⇑fb
g' : β → α
hg' : IsOrderRightAdjoint g g'
y : β
⊢ IsLUB (⇑fa '' {a | g (fa a) ≤ fb y}) (fa (g' y))
state_after: no goals
tactic: simp only [h.eq, fb.le_iff_le, fa.leftOrdContinuous (hg' _)]
Theorem: Real.Angle.toReal_eq_pi_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ : Angle
⊢ θ.toReal = π ↔ θ = ↑π
state_after: no goals
tactic: rw [← toReal_inj, toReal_pi]
Theorem: UniformOnFun.isClosed_setOf_continuous_of_le
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
t : TopologicalSpace α
h : t ≤ ⨆ s ∈ 𝔖, TopologicalSpace.coinduced Subtype.val inferInstance
u : Set α
hu : ∀ s ∈ 𝔖, IsOpen (Subtype.val ⁻¹' u)
⊢ IsOpen u
state_after: no goals
tactic: simpa only [isOpen_iSup_iff, isOpen_coinduced]
Theorem: Prod.noncompactSpace_iff
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
⊢ NoncompactSpace (X × Y) ↔ NoncompactSpace X ∧ Nonempty Y ∨ Nonempty X ∧ NoncompactSpace Y
state_after: no goals
tactic: simp [← Filter.cocompact_neBot_iff, ← Filter.coprod_cocompact, Filter.coprod_neBot_iff]
Theorem: IsAdjoinRoot.ofEquiv_map_apply
File: Mathlib/RingTheory/IsAdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
e : S ≃ₐ[R] T
⊢ RingHom.ker ((↑↑e).comp h.map) = Ideal.span {f}
state_after: no goals
tactic: rw [← RingHom.comap_ker, RingHom.ker_coe_equiv, ← RingHom.ker_eq_comap_bot, h.ker_map]
state_before: R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
e : S ≃ₐ[R] T
⊢ algebraMap R T = ((↑↑e).comp h.map).comp C
state_after: case a
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
e : S ≃ₐ[R] T
x✝ : R
⊢ (algebraMap R T) x✝ = (((↑↑e).comp h.map).comp C) x✝
tactic: ext
state_before: case a
R : Type u
S : Type v
inst✝⁴ : CommRing R
inst✝³ : CommRing S
inst✝² : Algebra R S
f : R[X]
T : Type u_1
inst✝¹ : CommRing T
inst✝ : Algebra R T
h : IsAdjoinRoot S f
e : S ≃ₐ[R] T
x✝ : R
⊢ (algebraMap R T) x✝ = (((↑↑e).comp h.map).comp C) x✝
state_after: no goals
tactic: simp only [AlgEquiv.commutes, RingHom.comp_apply, AlgEquiv.coe_ringEquiv,
      RingEquiv.coe_toRingHom, ← h.algebraMap_apply]
Theorem: CategoryTheory.MorphismProperty.comp_eq_top_iff
File: Mathlib/CategoryTheory/MorphismProperty/Factorization.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
W₁ W₂ : MorphismProperty C
⊢ W₁.comp W₂ = ⊤ ↔ W₁.HasFactorization W₂
state_after: case mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
W₁ W₂ : MorphismProperty C
⊢ W₁.comp W₂ = ⊤ → W₁.HasFactorization W₂

case mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
W₁ W₂ : MorphismProperty C
⊢ W₁.HasFactorization W₂ → W₁.comp W₂ = ⊤
tactic: constructor
Theorem: isClosed_iff_clusterPt
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
⊢ closure s ⊆ s ↔ ∀ (a : X), ClusterPt a (𝓟 s) → a ∈ s
state_after: no goals
tactic: simp only [subset_def, mem_closure_iff_clusterPt]
Theorem: AffineSubspace.sOppSide_iff_exists_left
File: Mathlib/Analysis/Convex/Side.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
h : p₁ ∈ s
⊢ s.SOppSide x y ↔ x ∉ s ∧ y ∉ s ∧ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
h : p₁ ∈ s
⊢ x ∉ s → (y ∉ s ∧ (x ∈ s ∨ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)) ↔ y ∉ s ∧ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y))
tactic: rw [SOppSide, and_comm, wOppSide_iff_exists_left h, and_assoc, and_congr_right_iff]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
h : p₁ ∈ s
⊢ x ∉ s → (y ∉ s ∧ (x ∈ s ∨ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)) ↔ y ∉ s ∧ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y))
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
h : p₁ ∈ s
hx : x ∉ s
⊢ y ∉ s ∧ (x ∈ s ∨ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)) ↔ y ∉ s ∧ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)
tactic: intro hx
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : LinearOrderedField R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y p₁ : P
h : p₁ ∈ s
hx : x ∉ s
⊢ y ∉ s ∧ (x ∈ s ∨ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)) ↔ y ∉ s ∧ ∃ p₂ ∈ s, SameRay R (x -ᵥ p₁) (p₂ -ᵥ y)
state_after: no goals
tactic: rw [or_iff_right hx]
Theorem: NNRat.toNNRat_coe_nat
File: Mathlib/Data/NNRat/Defs.lean

Proof steps:
state_before: α : Type u_1
p q : ℚ≥0
n : ℕ
⊢ ↑(↑n).toNNRat = ↑↑n
state_after: α : Type u_1
p q : ℚ≥0
n : ℕ
⊢ ↑n = ↑↑n
tactic: simp only [Nat.cast_nonneg, Rat.coe_toNNRat]
state_before: α : Type u_1
p q : ℚ≥0
n : ℕ
⊢ ↑n = ↑↑n
state_after: no goals
tactic: rfl
Theorem: Finset.not_mem_sigmaLift_of_ne_right
File: Mathlib/Data/Finset/Sigma.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : Sigma α
b : Sigma β
x : Sigma γ
h : b.fst ≠ x.fst
⊢ x ∉ sigmaLift f a b
state_after: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : Sigma α
b : Sigma β
x : Sigma γ
h : b.fst ≠ x.fst
⊢ ¬∃ (ha : a.fst = x.fst) (hb : b.fst = x.fst), x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd)
tactic: rw [mem_sigmaLift]
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
γ : ι → Type u_4
inst✝ : DecidableEq ι
f : ⦃i : ι⦄ → α i → β i → Finset (γ i)
a : Sigma α
b : Sigma β
x : Sigma γ
h : b.fst ≠ x.fst
⊢ ¬∃ (ha : a.fst = x.fst) (hb : b.fst = x.fst), x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd)
state_after: no goals
tactic: exact fun H => h H.snd.fst
Theorem: Nat.not_bddAbove_setOf_prime
File: Mathlib/Data/Nat/Prime/Basic.lean

Proof steps:
state_before: n : ℕ
⊢ ¬BddAbove {p | Prime p}
state_after: n : ℕ
⊢ ∀ (x : ℕ), ∃ y ∈ {p | Prime p}, x < y
tactic: rw [not_bddAbove_iff]
state_before: n : ℕ
⊢ ∀ (x : ℕ), ∃ y ∈ {p | Prime p}, x < y
state_after: n✝ n : ℕ
⊢ ∃ y ∈ {p | Prime p}, n < y
tactic: intro n
state_before: n✝ n : ℕ
⊢ ∃ y ∈ {p | Prime p}, n < y
state_after: case intro.intro
n✝ n p : ℕ
hi : n.succ ≤ p
hp : Prime p
⊢ ∃ y ∈ {p | Prime p}, n < y
tactic: obtain ⟨p, hi, hp⟩ := exists_infinite_primes n.succ
state_before: case intro.intro
n✝ n p : ℕ
hi : n.succ ≤ p
hp : Prime p
⊢ ∃ y ∈ {p | Prime p}, n < y
state_after: no goals
tactic: exact ⟨p, hp, hi⟩
Theorem: Fin.cons_zero
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
⊢ cons x p 0 = x
state_after: no goals
tactic: simp [cons]
Theorem: List.lt_iff_lex_lt
File: Mathlib/Data/List/Lex.lean

Proof steps:
state_before: α : Type u
inst✝ : LinearOrder α
l l' : List α
⊢ l.lt l' ↔ Lex (fun x x_1 => x < x_1) l l'
state_after: case mp
α : Type u
inst✝ : LinearOrder α
l l' : List α
h : l.lt l'
⊢ Lex (fun x x_1 => x < x_1) l l'

case mpr
α : Type u
inst✝ : LinearOrder α
l l' : List α
h : Lex (fun x x_1 => x < x_1) l l'
⊢ l.lt l'
tactic: constructor <;>
  intro h
Theorem: IsArtinianRing.primeSpectrum_finite
File: Mathlib/RingTheory/Artinian.lean

Proof steps:
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: set Spec := {I : Ideal R | I.IsPrime}
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: 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
p : ↑Spec
⊢ p ∈ s
state_after: no goals
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]
Theorem: Finset.mul_prod_erase
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 : α → β
inst✝¹ : CommMonoid β
inst✝ : DecidableEq α
s : Finset α
f : α → β
a : α
h : a ∈ s
⊢ f a * ∏ x ∈ s.erase a, f x = ∏ x ∈ s, f x
state_after: no goals
tactic: rw [← prod_insert (not_mem_erase a s), insert_erase h]
Theorem: linear_isometry_complex
File: Mathlib/Analysis/Complex/Isometry.lean

Proof steps:
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
⊢ ∃ a, f = rotation a ∨ f = conjLIE.trans (rotation a)
state_after: f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
⊢ ∃ a, f = rotation a ∨ f = conjLIE.trans (rotation a)
tactic: let a : circle := ⟨f 1, by rw [mem_circle_iff_abs, ← Complex.norm_eq_abs, f.norm_map, norm_one]⟩
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
⊢ ∃ a, f = rotation a ∨ f = conjLIE.trans (rotation a)
state_after: case h
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
⊢ f = rotation a ∨ f = conjLIE.trans (rotation a)
tactic: use a
state_before: case h
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
⊢ f = rotation a ∨ f = conjLIE.trans (rotation a)
state_after: case h
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
this : (f.trans (rotation a).symm) 1 = 1
⊢ f = rotation a ∨ f = conjLIE.trans (rotation a)
tactic: have : (f.trans (rotation a).symm) 1 = 1 := by simpa using rotation_apply a⁻¹ (f 1)
state_before: case h
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
this : (f.trans (rotation a).symm) 1 = 1
⊢ f = rotation a ∨ f = conjLIE.trans (rotation a)
state_after: case h.refine_1
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
this : (f.trans (rotation a).symm) 1 = 1
h₁ : f.trans (rotation a).symm = LinearIsometryEquiv.refl ℝ ℂ
⊢ f = rotation a

case h.refine_2
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
this : (f.trans (rotation a).symm) 1 = 1
h₂ : f.trans (rotation a).symm = conjLIE
⊢ f = conjLIE.trans (rotation a)
tactic: refine (linear_isometry_complex_aux this).imp (fun h₁ => ?_) fun h₂ => ?_