ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: exists_isOpen_singleton_of_isOpen_finite
File: Mathlib/Topology/Separation.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T0Space X
s : Set X
hfin : s.Finite
hne : s.Nonempty
ho : IsOpen s
⊢ ∃ x ∈ s, IsOpen {x}
state_after: case intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T0Space X
s : Finset X
hne : (↑s).Nonempty
ho : IsOpen ↑s
⊢ ∃ x ∈ ↑s, IsOpen {x}
tactic: lift s to Finset X using hfin
state_before: case intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T0Space X
s : Finset X
hne : (↑s).Nonempty
ho : IsOpen ↑s
⊢ ∃ x ∈ ↑s, IsOpen {x}
state_after: case intro.a
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T0Space X
s : Finset X
ihs : ∀ t ⊂ s, (↑t).Nonempty → IsOpen ↑t → ∃ x ∈ ↑t, IsOpen {x}
hne : (↑s).Nonempty
ho : IsOpen ↑s
⊢ ∃ x ∈ ↑s, IsOpen {x}
tactic: induction' s using Finset.strongInductionOn with s ihs
state_before: case intro.a
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T0Space X
s : Finset X
ihs : ∀ t ⊂ s, (↑t).Nonempty → IsOpen ↑t → ∃ x ∈ ↑t, IsOpen {x}
hne : (↑s).Nonempty
ho : IsOpen ↑s
⊢ ∃ x ∈ ↑s, IsOpen {x}
state_after: case intro.a.inl.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T0Space X
s : Finset X
ihs : ∀ t ⊂ s, (↑t).Nonempty → IsOpen ↑t → ∃ x ∈ ↑t, IsOpen {x}
hne : (↑s).Nonempty
ho : IsOpen ↑s
t : Finset X
hts : t ⊂ s
htne : t.Nonempty
hto : IsOpen ↑t
⊢ ∃ x ∈ ↑s, IsOpen {x}

case intro.a.inr
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : T0Space X
s : Finset X
ihs : ∀ t ⊂ s, (↑t).Nonempty → IsOpen ↑t → ∃ x ∈ ↑t, IsOpen {x}
hne : (↑s).Nonempty
ho : IsOpen ↑s
ht : ¬∃ t ⊂ s, t.Nonempty ∧ IsOpen ↑t
⊢ ∃ x ∈ ↑s, IsOpen {x}
tactic: rcases em (∃ t, t ⊂ s ∧ t.Nonempty ∧ IsOpen (t : Set X)) with (⟨t, hts, htne, hto⟩ | ht)
Theorem: ProbabilityTheory.measurable_measure_condCDF
File: Mathlib/Probability/Kernel/Disintegration/CondCdf.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
⊢ Measurable fun a => (condCDF ρ a).measure
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
⊢ ∀ (s : Set ℝ), MeasurableSet s → Measurable fun b => (condCDF ρ b).measure s
tactic: rw [Measure.measurable_measure]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
⊢ ∀ (s : Set ℝ), MeasurableSet s → Measurable fun b => (condCDF ρ b).measure s
state_after: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
s : Set ℝ
hs : MeasurableSet s
⊢ Measurable fun b => (condCDF ρ b).measure s
tactic: refine fun s hs => ?_
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
s : Set ℝ
hs : MeasurableSet s
⊢ Measurable fun b => (condCDF ρ b).measure s
state_after: case refine_1
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
s : Set ℝ
hs : MeasurableSet s
⊢ (fun s => Measurable fun b => (condCDF ρ b).measure s) ∅

case refine_2
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
s : Set ℝ
hs : MeasurableSet s
⊢ ∀ t ∈ range Iic, (fun s => Measurable fun b => (condCDF ρ b).measure s) t

case refine_3
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
s : Set ℝ
hs : MeasurableSet s
⊢ ∀ (t : Set ℝ),
    MeasurableSet t →
      (fun s => Measurable fun b => (condCDF ρ b).measure s) t →
        (fun s => Measurable fun b => (condCDF ρ b).measure s) tᶜ

case refine_4
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
ρ : Measure (α × ℝ)
s : Set ℝ
hs : MeasurableSet s
⊢ ∀ (f : ℕ → Set ℝ),
    Pairwise (Disjoint on f) →
      (∀ (i : ℕ), MeasurableSet (f i)) →
        (∀ (i : ℕ), (fun s => Measurable fun b => (condCDF ρ b).measure s) (f i)) →
          (fun s => Measurable fun b => (condCDF ρ b).measure s) (⋃ i, f i)
tactic: refine MeasurableSpace.induction_on_inter
    (C := fun s => Measurable fun b ↦ StieltjesFunction.measure (condCDF ρ b) s)
    (borel_eq_generateFrom_Iic ℝ) isPiSystem_Iic ?_ ?_ ?_ ?_ hs
Theorem: Batteries.RBNode.reverse_insert
File: .lake/packages/batteries/Batteries/Data/RBMap/WF.lean

Proof steps:
state_before: α : Type u_1
cmp : α → α → Ordering
x : α
inst : OrientedCmp cmp
t : RBNode α
⊢ (insert cmp t x).reverse = insert (flip cmp) t.reverse x
state_after: no goals
tactic: simp [insert] <;> split <;> simp
Theorem: Set.union_pi
File: Mathlib/Data/Set/Prod.lean

Proof steps:
state_before: ι : Type u_1
α : ι → Type u_2
β : ι → Type u_3
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
i : ι
⊢ (s₁ ∪ s₂).pi t = s₁.pi t ∩ s₂.pi t
state_after: no goals
tactic: simp [pi, or_imp, forall_and, setOf_and]
Theorem: Set.indicator_iInter_apply
File: Mathlib/Algebra/Order/Group/Indicator.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
M : Type u_4
inst✝² : CompleteLattice M
inst✝¹ : One M
s✝ t : Set α
f✝ g : α → M
a : α
y : M
inst✝ : Nonempty ι
h1 : ⊥ = 1
s : ι → Set α
f : α → M
x : α
⊢ (⋂ i, s i).mulIndicator f x = ⨅ i, (s i).mulIndicator f x
state_after: case pos
ι : Sort u_1
α : Type u_2
β : Type u_3
M : Type u_4
inst✝² : CompleteLattice M
inst✝¹ : One M
s✝ t : Set α
f✝ g : α → M
a : α
y : M
inst✝ : Nonempty ι
h1 : ⊥ = 1
s : ι → Set α
f : α → M
x : α
hx : x ∈ ⋂ i, s i
⊢ (⋂ i, s i).mulIndicator f x = ⨅ i, (s i).mulIndicator f x

case neg
ι : Sort u_1
α : Type u_2
β : Type u_3
M : Type u_4
inst✝² : CompleteLattice M
inst✝¹ : One M
s✝ t : Set α
f✝ g : α → M
a : α
y : M
inst✝ : Nonempty ι
h1 : ⊥ = 1
s : ι → Set α
f : α → M
x : α
hx : x ∉ ⋂ i, s i
⊢ (⋂ i, s i).mulIndicator f x = ⨅ i, (s i).mulIndicator f x
tactic: by_cases hx : x ∈ ⋂ i, s i
Theorem: finrank_span_set_eq_card
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

Proof steps:
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : Ring R
inst✝⁸ : CommRing S
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : StrongRankCondition R
s : Set M
inst✝ : Fintype ↑s
hs : LinearIndependent (ι := { x // x ∈ s }) R Subtype.val
⊢ Module.rank R ↥(span R s) = ↑s.toFinset.card
state_after: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : Ring R
inst✝⁸ : CommRing S
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : StrongRankCondition R
s : Set M
inst✝ : Fintype ↑s
hs : LinearIndependent (ι := { x // x ∈ s }) R Subtype.val
this : Module.rank R ↥(span R s) = #↑s
⊢ Module.rank R ↥(span R s) = ↑s.toFinset.card
tactic: have : Module.rank R (span R s) = #s := rank_span_set hs
state_before: R S : Type u
M : Type v
M' : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁹ : Ring R
inst✝⁸ : CommRing S
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : StrongRankCondition R
s : Set M
inst✝ : Fintype ↑s
hs : LinearIndependent (ι := { x // x ∈ s }) R Subtype.val
this : Module.rank R ↥(span R s) = #↑s
⊢ Module.rank R ↥(span R s) = ↑s.toFinset.card
state_after: no goals
tactic: rwa [Cardinal.mk_fintype, ← Set.toFinset_card] at this
Theorem: ENNReal.Tendsto.const_mul
File: Mathlib/Topology/Instances/ENNReal.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a b : ℝ≥0∞
hm : Tendsto m f (𝓝 b)
hb : b ≠ 0 ∨ a ≠ ⊤
this : a = 0
⊢ Tendsto (fun b => a * m b) f (𝓝 (a * b))
state_after: no goals
tactic: simp [this, tendsto_const_nhds]
Theorem: Equiv.Perm.viaFintypeEmbedding_apply_not_mem_range
File: Mathlib/Logic/Equiv/Fintype.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : DecidableEq β
e : Perm α
f : α ↪ β
b : β
h : b ∉ Set.range ⇑f
⊢ (e.viaFintypeEmbedding f) b = b
state_after: no goals
tactic: rwa [Equiv.Perm.viaFintypeEmbedding, Equiv.Perm.extendDomain_apply_not_subtype]
Theorem: QuotientGroup.mk'_eq_mk'
File: Mathlib/GroupTheory/QuotientGroup.lean

Proof steps:
state_before: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
x y : G
⊢ x⁻¹ * y ∈ N ↔ ∃ z ∈ N, x * z = y
state_after: no goals
tactic: simp only [← _root_.eq_inv_mul_iff_mul_eq, exists_prop, exists_eq_right]
Theorem: CategoryTheory.OplaxNatTrans.leftUnitor_inv_app
File: Mathlib/CategoryTheory/Bicategory/FunctorBicategory.lean

Proof steps:
state_before: B : Type u₁
inst✝¹ : Bicategory B
C : Type u₂
inst✝ : Bicategory C
F G H I : OplaxFunctor B C
η : F ⟶ G
⊢ ∀ {a b : B} (f : a ⟶ b),
    F.map f ◁ ((fun a => λ_ (η.app a)) b).hom ≫ η.naturality f =
      (𝟙 F ≫ η).naturality f ≫ ((fun a => λ_ (η.app a)) a).hom ▷ G.map f
state_after: no goals
tactic: aesop_cat
Theorem: ENNReal.essSup_piecewise
File: Mathlib/MeasureTheory/Function/EssSup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
g : α → ℝ≥0∞
hs : MeasurableSet s
⊢ essSup (s.piecewise f g) μ = max (essSup f (μ.restrict s)) (essSup g (μ.restrict sᶜ))
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
g : α → ℝ≥0∞
hs : MeasurableSet s
⊢ limsup f (ae μ ⊓ 𝓟 {x | x ∈ s}) ⊔ limsup g (ae μ ⊓ 𝓟 {x | x ∉ s}) =
    max (limsup f (ae μ ⊓ 𝓟 s)) (limsup g (ae μ ⊓ 𝓟 sᶜ))
tactic: simp only [essSup, limsup_piecewise, blimsup_eq_limsup, ae_restrict_eq, hs, hs.compl]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
s : Set α
inst✝ : DecidablePred fun x => x ∈ s
g : α → ℝ≥0∞
hs : MeasurableSet s
⊢ limsup f (ae μ ⊓ 𝓟 {x | x ∈ s}) ⊔ limsup g (ae μ ⊓ 𝓟 {x | x ∉ s}) =
    max (limsup f (ae μ ⊓ 𝓟 s)) (limsup g (ae μ ⊓ 𝓟 sᶜ))
state_after: no goals
tactic: rfl
Theorem: Matroid.Indep.eq_union_image_of_disjointSum
File: Mathlib/Data/Matroid/Sum.lean

Proof steps:
state_before: α : Type u_1
M N : Matroid α
h : Disjoint M.E N.E
I : Set α
hI : (M.disjointSum N h).Indep I
⊢ ∃ IM IN, M.Indep IM ∧ N.Indep IN ∧ Disjoint IM IN ∧ I = IM ∪ IN
state_after: α : Type u_1
M N : Matroid α
h : Disjoint M.E N.E
I : Set α
hI : M.Indep (I ∩ M.E) ∧ N.Indep (I ∩ N.E) ∧ I ⊆ M.E ∪ N.E
⊢ ∃ IM IN, M.Indep IM ∧ N.Indep IN ∧ Disjoint IM IN ∧ I = IM ∪ IN
tactic: rw [disjointSum_indep_iff] at hI
state_before: α : Type u_1
M N : Matroid α
h : Disjoint M.E N.E
I : Set α
hI : M.Indep (I ∩ M.E) ∧ N.Indep (I ∩ N.E) ∧ I ⊆ M.E ∪ N.E
⊢ ∃ IM IN, M.Indep IM ∧ N.Indep IN ∧ Disjoint IM IN ∧ I = IM ∪ IN
state_after: α : Type u_1
M N : Matroid α
h : Disjoint M.E N.E
I : Set α
hI : M.Indep (I ∩ M.E) ∧ N.Indep (I ∩ N.E) ∧ I ⊆ M.E ∪ N.E
⊢ I = I ∩ M.E ∪ I ∩ N.E
tactic: refine ⟨_, _, hI.1, hI.2.1, h.mono inter_subset_right inter_subset_right, ?_⟩
state_before: α : Type u_1
M N : Matroid α
h : Disjoint M.E N.E
I : Set α
hI : M.Indep (I ∩ M.E) ∧ N.Indep (I ∩ N.E) ∧ I ⊆ M.E ∪ N.E
⊢ I = I ∩ M.E ∪ I ∩ N.E
state_after: no goals
tactic: rw [← inter_union_distrib_left, inter_eq_self_of_subset_left hI.2.2]
Theorem: Submonoid.op_closure
File: Mathlib/Algebra/Group/Submonoid/MulOpposite.lean

Proof steps:
state_before: ι : Sort u_1
M : Type u_2
inst✝ : MulOneClass M
s : Set M
⊢ (closure s).op = closure (MulOpposite.unop ⁻¹' s)
state_after: ι : Sort u_1
M : Type u_2
inst✝ : MulOneClass M
s : Set M
⊢ sInf {a | s ⊆ MulOpposite.op ⁻¹' ↑a} = sInf {S | MulOpposite.unop ⁻¹' s ⊆ ↑S}
tactic: simp_rw [closure, op_sInf, Set.preimage_setOf_eq, Submonoid.unop_coe]
state_before: ι : Sort u_1
M : Type u_2
inst✝ : MulOneClass M
s : Set M
⊢ sInf {a | s ⊆ MulOpposite.op ⁻¹' ↑a} = sInf {S | MulOpposite.unop ⁻¹' s ⊆ ↑S}
state_after: case e_a.h
ι : Sort u_1
M : Type u_2
inst✝ : MulOneClass M
s : Set M
a : Submonoid Mᵐᵒᵖ
⊢ a ∈ {a | s ⊆ MulOpposite.op ⁻¹' ↑a} ↔ a ∈ {S | MulOpposite.unop ⁻¹' s ⊆ ↑S}
tactic: congr with a
state_before: case e_a.h
ι : Sort u_1
M : Type u_2
inst✝ : MulOneClass M
s : Set M
a : Submonoid Mᵐᵒᵖ
⊢ a ∈ {a | s ⊆ MulOpposite.op ⁻¹' ↑a} ↔ a ∈ {S | MulOpposite.unop ⁻¹' s ⊆ ↑S}
state_after: no goals
tactic: exact MulOpposite.unop_surjective.forall
Theorem: Matrix.transposeAlgEquiv_symm_apply
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝⁴ : CommSemiring R
inst✝³ : CommSemiring α
inst✝² : Fintype m
inst✝¹ : DecidableEq m
inst✝ : Algebra R α
r : R
⊢ { toFun := fun M => MulOpposite.op Mᵀ, invFun := __src✝¹.invFun, left_inv := ⋯, right_inv := ⋯ }.toFun
      ((algebraMap R (Matrix m m α)) r) =
    (algebraMap R (Matrix m m α)ᵐᵒᵖ) r
state_after: no goals
tactic: simp only [algebraMap_eq_diagonal, diagonal_transpose, MulOpposite.algebraMap_apply]
Theorem: Order.not_isPredLimit_iff_exists_covBy
File: Mathlib/Order/SuccPred/Limit.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LT α
a✝ a : α
⊢ ¬IsPredLimit a ↔ ∃ b, a ⋖ b
state_after: no goals
tactic: simp [IsPredLimit]
Theorem: MeasureTheory.Measure.toSphere_apply_aux
File: Mathlib/MeasureTheory/Constructions/HaarToSphere.lean

Proof steps:
state_before: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
μ : Measure E
s : Set ↑(sphere 0 1)
r : ↑(Ioi 0)
⊢ μ (Subtype.val '' (⇑(homeomorphUnitSphereProd E) ⁻¹' s ×ˢ Iio r)) = μ (Ioo 0 ↑r • Subtype.val '' s)
state_after: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
μ : Measure E
s : Set ↑(sphere 0 1)
r : ↑(Ioi 0)
⊢ μ ((fun x => ↑((homeomorphUnitSphereProd E).symm x)) '' s ×ˢ Iio r) = μ ((fun x => SMul.smul ↑x.2 ↑x.1) '' s ×ˢ Iio r)
tactic: rw [← image2_smul, image2_image_right, ← Homeomorph.image_symm, image_image,
    ← image_subtype_val_Ioi_Iio, image2_image_left, image2_swap, ← image_prod]
state_before: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : FiniteDimensional ℝ E
inst✝¹ : MeasurableSpace E
inst✝ : BorelSpace E
μ : Measure E
s : Set ↑(sphere 0 1)
r : ↑(Ioi 0)
⊢ μ ((fun x => ↑((homeomorphUnitSphereProd E).symm x)) '' s ×ˢ Iio r) = μ ((fun x => SMul.smul ↑x.2 ↑x.1) '' s ×ˢ Iio r)
state_after: no goals
tactic: rfl
Theorem: norm_add_sq_eq_norm_sq_add_norm_sq_iff_real_inner_eq_zero
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
⊢ ‖x + y‖ * ‖x + y‖ = ‖x‖ * ‖x‖ + ‖y‖ * ‖y‖ ↔ ⟪x, y⟫_ℝ = 0
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
⊢ 2 = 0 ∨ re ⟪x, y⟫_ℝ = 0 ↔ ⟪x, y⟫_ℝ = 0
tactic: rw [@norm_add_mul_self ℝ, add_right_cancel_iff, add_right_eq_self, mul_eq_zero]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x y : F
⊢ 2 = 0 ∨ re ⟪x, y⟫_ℝ = 0 ↔ ⟪x, y⟫_ℝ = 0
state_after: no goals
tactic: norm_num
Theorem: CategoryTheory.Bicategory.leftUnitor_inv_whiskerRight
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ inv ((λ_ f).inv ▷ g) = inv ((λ_ (f ≫ g)).inv ≫ (α_ (𝟙 a) f g).inv)
state_after: no goals
tactic: simp
Theorem: Set.Ioc_union_Ioc_right
File: Mathlib/Order/Interval/Set/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a b ∪ Ioc a c = Ioc a (max b c)
state_after: no goals
tactic: rw [Ioc_union_Ioc, min_self] <;> exact (min_le_left _ _).trans (le_max_left _ _)
Theorem: Fintype.eval_image_piFinset_const
File: Mathlib/Data/Fintype/Pi.lean

Proof steps:
state_before: α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
β : Type u_4
inst✝ : DecidableEq β
t : Finset β
a : α
⊢ image (fun f => f a) (piFinset fun _i => t) = t
state_after: case inl
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
β : Type u_4
inst✝ : DecidableEq β
a : α
⊢ image (fun f => f a) (piFinset fun _i => ∅) = ∅

case inr
α : Type u_1
inst✝² : DecidableEq α
inst✝¹ : Fintype α
γ : α → Type u_2
δ : α → Type u_3
s : (a : α) → Finset (γ a)
β : Type u_4
inst✝ : DecidableEq β
t : Finset β
a : α
ht : t.Nonempty
⊢ image (fun f => f a) (piFinset fun _i => t) = t
tactic: obtain rfl | ht := t.eq_empty_or_nonempty
Theorem: Filter.Tendsto.atTop_mul_atBot
File: Mathlib/Order/Filter/AtTopBot.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : OrderedRing α
l : Filter β
f g : β → α
hf : Tendsto f l atTop
hg : Tendsto g l atBot
⊢ Tendsto (fun x => f x * g x) l atBot
state_after: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝ : OrderedRing α
l : Filter β
f g : β → α
hf : Tendsto f l atTop
hg : Tendsto g l atBot
this : Tendsto (fun x => f x * (Neg.neg ∘ g) x) l atTop
⊢ Tendsto (fun x => f x * g x) l atBot
tactic: have := hf.atTop_mul_atTop <| tendsto_neg_atBot_atTop.comp hg
Theorem: CategoryTheory.Abelian.epi_fst_of_factor_thru_epi_mono_factorization
File: Mathlib/CategoryTheory/Abelian/Basic.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : Abelian C
inst✝² : HasPullbacks C
W X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
g₁ : Y ⟶ W
inst✝¹ : Epi g₁
g₂ : W ⟶ Z
inst✝ : Mono g₂
hg : g₁ ≫ g₂ = g
f' : X ⟶ W
hf : f' ≫ g₂ = f
t : PullbackCone f g
ht : IsLimit t
⊢ Epi t.fst
state_after: no goals
tactic: apply epi_fst_of_isLimit _ _ (PullbackCone.isLimitOfFactors f g g₂ f' g₁ hf hg t ht)
Theorem: Ordinal.lift_isLimit
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{v}
⊢ lift.{u, v} o = 0 ↔ o = 0
state_after: no goals
tactic: simpa only [lift_zero] using @lift_inj o 0
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{v}
H : ∀ a < lift.{u, v} o, succ a < lift.{u, v} o
a : Ordinal.{v}
h : a < o
⊢ lift.{u, v} (succ a) < lift.{u, v} o
state_after: no goals
tactic: simpa only [lift_succ] using H _ (lift_lt.2 h)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{v}
H : ∀ a < o, succ a < o
a : Ordinal.{max u v}
h : a < lift.{u, v} o
⊢ succ a < lift.{u, v} o
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{v}
H : ∀ a < o, succ a < o
a' : Ordinal.{v}
h : lift.{u, v} a' < lift.{u, v} o
⊢ succ (lift.{u, v} a') < lift.{u, v} o
tactic: obtain ⟨a', rfl⟩ := lift_down h.le
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{v}
H : ∀ a < o, succ a < o
a' : Ordinal.{v}
h : lift.{u, v} a' < lift.{u, v} o
⊢ succ (lift.{u, v} a') < lift.{u, v} o
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{v}
H : ∀ a < o, succ a < o
a' : Ordinal.{v}
h : lift.{u, v} a' < lift.{u, v} o
⊢ succ a' < o
tactic: rw [← lift_succ, lift_lt]
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{v}
H : ∀ a < o, succ a < o
a' : Ordinal.{v}
h : lift.{u, v} a' < lift.{u, v} o
⊢ succ a' < o
state_after: no goals
tactic: exact H a' (lift_lt.1 h)
Theorem: Finset.noncommSum_toFinset
File: Mathlib/Data/Finset/NoncommProd.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
l : List α
f : α → β
comm : (↑l.toFinset).Pairwise fun a b => Commute (f a) (f b)
hl : l.Nodup
⊢ l.toFinset.noncommProd f comm = (List.map f l).prod
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
l : List α
f : α → β
comm : (↑l.toFinset).Pairwise fun a b => Commute (f a) (f b)
hl : l.dedup = l
⊢ l.toFinset.noncommProd f comm = (List.map f l).prod
tactic: rw [← List.dedup_eq_self] at hl
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
f✝ : α → β → β
op : α → α → α
inst✝² : Monoid β
inst✝¹ : Monoid γ
inst✝ : DecidableEq α
l : List α
f : α → β
comm : (↑l.toFinset).Pairwise fun a b => Commute (f a) (f b)
hl : l.dedup = l
⊢ l.toFinset.noncommProd f comm = (List.map f l).prod
state_after: no goals
tactic: simp [noncommProd, hl]
Theorem: HomologicalComplex.eqToHom_comp_d
File: Mathlib/Algebra/Homology/HomologicalComplex.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i i' j : ι
rij : c.Rel i j
rij' : c.Rel i' j
⊢ eqToHom ⋯ ≫ C.d i' j = C.d i j
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j : ι
rij rij' : c.Rel i j
⊢ eqToHom ⋯ ≫ C.d i j = C.d i j
tactic: obtain rfl := c.prev_eq rij rij'
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : HasZeroMorphisms V
c : ComplexShape ι
C : HomologicalComplex V c
i j : ι
rij rij' : c.Rel i j
⊢ eqToHom ⋯ ≫ C.d i j = C.d i j
state_after: no goals
tactic: simp only [eqToHom_refl, id_comp]
Theorem: HurwitzZeta.hasSum_int_cosZeta
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
⊢ HasSum (fun n => cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2) (cosZeta (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
⊢ HasSum (fun n => cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2) (completedCosZeta (↑a) s / s.Gammaℝ)
tactic: rw [cosZeta, Function.update_noteq (ne_zero_of_one_lt_re hs)]
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
⊢ HasSum (fun n => cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2) (completedCosZeta (↑a) s / s.Gammaℝ)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℤ
⊢ cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2 = s.Gammaℝ * cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2 / s.Gammaℝ
tactic: refine ((hasSum_int_completedCosZeta a hs).div_const (Gammaℝ s)).congr_fun fun n ↦ ?_
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℤ
⊢ cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2 = s.Gammaℝ * cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2 / s.Gammaℝ
state_after: no goals
tactic: rw [mul_div_assoc _ (cexp _), div_right_comm _ (2 : ℂ),
    mul_div_cancel_left₀ _ (Gammaℝ_ne_zero_of_re_pos (zero_lt_one.trans hs))]
Theorem: Irrational.of_sub_int
File: Mathlib/Data/Real/Irrational.lean

Proof steps:
state_before: q : ℚ
x y : ℝ
m : ℤ
h : Irrational (x - ↑m)
⊢ Irrational (x - ↑↑m)
state_after: no goals
tactic: rwa [Rat.cast_intCast]