ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ideal.IsPrime.exists_mem_prime_of_ne_bot
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
R : Type u_2
inst✝² : CommSemiring R
inst✝¹ : IsDomain R
inst✝ : UniqueFactorizationMonoid R
I : Ideal R
hI₂ : I.IsPrime
hI : I ≠ ⊥
⊢ ∃ x ∈ I, Prime x
state_after: no goals
tactic: classical
  obtain ⟨a : R, ha₁ : a ∈ I, ha₂ : a ≠ 0⟩ := Submodule.exists_mem_ne_zero_of_ne_bot hI
  replace ha₁ : (factors a).prod ∈ I := by
    obtain ⟨u : Rˣ, hu : (factors a).prod * u = a⟩ := factors_prod ha₂
    rwa [← hu, mul_unit_mem_iff_mem _ u.isUnit] at ha₁
  obtain ⟨p : R, hp₁ : p ∈ factors a, hp₂ : p ∈ I⟩ :=
    (hI₂.multiset_prod_mem_iff_exists_mem <| factors a).1 ha₁
  exact ⟨p, hp₂, prime_of_factor p hp₁⟩
Theorem: sub_add_eq_sub_sub_swap
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : DivisionMonoid α
a b c d : α
⊢ a / (b * c) = a / c / b
state_after: no goals
tactic: simp only [mul_assoc, mul_inv_rev, div_eq_mul_inv]
Theorem: IsSquare.zpow
File: Mathlib/Algebra/Group/Even.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionMonoid α
a : α
n : ℤ
⊢ IsSquare a → IsSquare (a ^ n)
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionMonoid α
n : ℤ
a : α
⊢ IsSquare ((a * a) ^ n)
tactic: rintro ⟨a, rfl⟩
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝ : DivisionMonoid α
n : ℤ
a : α
⊢ IsSquare ((a * a) ^ n)
state_after: no goals
tactic: exact ⟨a ^ n, (Commute.refl _).mul_zpow _⟩
Theorem: Filter.frequently_prod_and
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
p : α → Prop
q : β → Prop
⊢ (∃ᶠ (x : α × β) in f ×ˢ g, p x.1 ∧ q x.2) ↔ (∃ᶠ (a : α) in f, p a) ∧ ∃ᶠ (b : β) in g, q b
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
p : α → Prop
q : β → Prop
⊢ (f ×ˢ g ⊓ 𝓟 {x | p x.1 ∧ q x.2}).NeBot ↔ (f ×ˢ g ⊓ 𝓟 ({a | p a} ×ˢ {b | q b})).NeBot
tactic: simp only [frequently_iff_neBot, ← prod_neBot, ← prod_inf_prod, prod_principal_principal]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
p : α → Prop
q : β → Prop
⊢ (f ×ˢ g ⊓ 𝓟 {x | p x.1 ∧ q x.2}).NeBot ↔ (f ×ˢ g ⊓ 𝓟 ({a | p a} ×ˢ {b | q b})).NeBot
state_after: no goals
tactic: rfl
Theorem: CliffordAlgebra.changeForm_one
File: Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean

Proof steps:
state_before: R : Type u1
inst✝² : CommRing R
M : Type u2
inst✝¹ : AddCommGroup M
inst✝ : Module R M
Q Q' Q'' : QuadraticForm R M
B B' : BilinForm R M
h : BilinMap.toQuadraticMap B = Q' - Q
h' : BilinMap.toQuadraticMap B' = Q'' - Q'
⊢ (changeForm h) 1 = 1
state_after: no goals
tactic: simpa using changeForm_algebraMap h (1 : R)
Theorem: Real.integrable_of_summable_norm_Icc
File: Mathlib/MeasureTheory/Measure/Lebesgue/Integral.lean

Proof steps:
state_before: E : Type u_1
inst✝ : NormedAddCommGroup E
f : C(ℝ, E)
hf : Summable fun n => ‖ContinuousMap.restrict (Icc 0 1) (f.comp (ContinuousMap.addRight ↑n))‖
⊢ Integrable (⇑f) volume
state_after: case refine_1
E : Type u_1
inst✝ : NormedAddCommGroup E
f : C(ℝ, E)
hf : Summable fun n => ‖ContinuousMap.restrict (Icc 0 1) (f.comp (ContinuousMap.addRight ↑n))‖
n : ℤ
⊢ ‖ContinuousMap.restrict (↑{ carrier := Icc (↑n) (↑n + 1), isCompact' := ⋯ }) f‖ *
      (volume ↑{ carrier := Icc (↑n) (↑n + 1), isCompact' := ⋯ }).toReal ≤
    ‖ContinuousMap.restrict (Icc 0 1) (f.comp (ContinuousMap.addRight ↑n))‖

case refine_2
E : Type u_1
inst✝ : NormedAddCommGroup E
f : C(ℝ, E)
hf : Summable fun n => ‖ContinuousMap.restrict (Icc 0 1) (f.comp (ContinuousMap.addRight ↑n))‖
⊢ ⋃ i, ↑{ carrier := Icc (↑i) (↑i + 1), isCompact' := ⋯ } = univ
tactic: refine integrable_of_summable_norm_restrict (.of_nonneg_of_le
    (fun n : ℤ => mul_nonneg (norm_nonneg
      (f.restrict (⟨Icc (n : ℝ) ((n : ℝ) + 1), isCompact_Icc⟩ : Compacts ℝ)))
        ENNReal.toReal_nonneg) (fun n => ?_) hf) ?_
Theorem: ENNReal.zero_rpow_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: y : ℝ
h : y < 0
⊢ 0 ^ y = ⊤
state_after: y : ℝ
h : y < 0
⊢ some 0 ^ y = ⊤
tactic: rw [← ENNReal.coe_zero, ← ENNReal.some_eq_coe]
state_before: y : ℝ
h : y < 0
⊢ (if 0 = 0 ∧ y < 0 then ⊤ else ↑(NNReal.rpow 0 y)) = ⊤
state_after: no goals
tactic: simp [h, ne_of_gt h]
Theorem: Homotopy.map_nullHomotopicMap
File: Mathlib/Algebra/Homology/Homotopy.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
W : Type u_2
inst✝² : Category.{?u.129316, u_2} W
inst✝¹ : Preadditive W
G : V ⥤ W
inst✝ : G.Additive
hom : (i j : ι) → C.X i ⟶ D.X j
i j : ι
⊢ ((G.mapHomologicalComplex c).obj C).X i ⟶ ((G.mapHomologicalComplex c).obj D).X j
state_after: no goals
tactic: exact G.map (hom i j)
state_before: ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i : ι
W : Type u_2
inst✝² : Category.{u_3, u_2} W
inst✝¹ : Preadditive W
G : V ⥤ W
inst✝ : G.Additive
hom : (i j : ι) → C.X i ⟶ D.X j
⊢ (G.mapHomologicalComplex c).map (nullHomotopicMap hom) = nullHomotopicMap fun i j => G.map (hom i j)
state_after: case h
ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
W : Type u_2
inst✝² : Category.{u_3, u_2} W
inst✝¹ : Preadditive W
G : V ⥤ W
inst✝ : G.Additive
hom : (i j : ι) → C.X i ⟶ D.X j
i : ι
⊢ ((G.mapHomologicalComplex c).map (nullHomotopicMap hom)).f i = (nullHomotopicMap fun i j => G.map (hom i j)).f i
tactic: ext i
state_before: case h
ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
W : Type u_2
inst✝² : Category.{u_3, u_2} W
inst✝¹ : Preadditive W
G : V ⥤ W
inst✝ : G.Additive
hom : (i j : ι) → C.X i ⟶ D.X j
i : ι
⊢ ((G.mapHomologicalComplex c).map (nullHomotopicMap hom)).f i = (nullHomotopicMap fun i j => G.map (hom i j)).f i
state_after: case h
ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
W : Type u_2
inst✝² : Category.{u_3, u_2} W
inst✝¹ : Preadditive W
G : V ⥤ W
inst✝ : G.Additive
hom : (i j : ι) → C.X i ⟶ D.X j
i : ι
⊢ G.map (C.d i (c.next i) ≫ hom (c.next i) i + hom i (c.prev i) ≫ D.d (c.prev i) i) =
    G.map (C.d i (c.next i)) ≫ G.map (hom (c.next i) i) + G.map (hom i (c.prev i)) ≫ G.map (D.d (c.prev i) i)
tactic: dsimp [nullHomotopicMap, dNext, prevD]
state_before: case h
ι : Type u_1
V : Type u
inst✝⁴ : Category.{v, u} V
inst✝³ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i✝ : ι
W : Type u_2
inst✝² : Category.{u_3, u_2} W
inst✝¹ : Preadditive W
G : V ⥤ W
inst✝ : G.Additive
hom : (i j : ι) → C.X i ⟶ D.X j
i : ι
⊢ G.map (C.d i (c.next i) ≫ hom (c.next i) i + hom i (c.prev i) ≫ D.d (c.prev i) i) =
    G.map (C.d i (c.next i)) ≫ G.map (hom (c.next i) i) + G.map (hom i (c.prev i)) ≫ G.map (D.d (c.prev i) i)
state_after: no goals
tactic: simp only [G.map_comp, Functor.map_add]
Theorem: ModelWithCorners.boundary_eq_complement_interior
File: Mathlib/Geometry/Manifold/InteriorBoundary.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
H : Type u_3
inst✝² : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace H M
⊢ I.boundary M = (I.interior M)ᶜ
state_after: 𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
H : Type u_3
inst✝² : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace H M
⊢ I.interior M ⊓ I.boundary M = ⊥
tactic: apply (compl_unique ?_ I.interior_union_boundary_eq_univ).symm
state_before: 𝕜 : Type u_1
inst✝⁵ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace 𝕜 E
H : Type u_3
inst✝² : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
M : Type u_4
inst✝¹ : TopologicalSpace M
inst✝ : ChartedSpace H M
⊢ I.interior M ⊓ I.boundary M = ⊥
state_after: no goals
tactic: exact disjoint_iff_inter_eq_empty.mp (I.disjoint_interior_boundary)
Theorem: ZeroAtInftyContinuousMap.ContinuousMap.liftZeroAtInfty_symm_apply
File: Mathlib/Topology/ContinuousFunction/ZeroAtInfty.lean

Proof steps:
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : C(α, β)
⊢ Tendsto { toFun := ⇑f, continuous_toFun := ⋯ }.toFun (cocompact α) (𝓝 0)
state_after: no goals
tactic: simp
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : C(α, β)
⊢ (fun f => ↑f) ((fun f => { toFun := ⇑f, continuous_toFun := ⋯, zero_at_infty' := ⋯ }) f) = f
state_after: case h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : C(α, β)
a✝ : α
⊢ ((fun f => ↑f) ((fun f => { toFun := ⇑f, continuous_toFun := ⋯, zero_at_infty' := ⋯ }) f)) a✝ = f a✝
tactic: ext
state_before: case h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : C(α, β)
a✝ : α
⊢ ((fun f => ↑f) ((fun f => { toFun := ⇑f, continuous_toFun := ⋯, zero_at_infty' := ⋯ }) f)) a✝ = f a✝
state_after: no goals
tactic: rfl
state_before: F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : α →C₀ β
⊢ (fun f => { toFun := ⇑f, continuous_toFun := ⋯, zero_at_infty' := ⋯ }) ((fun f => ↑f) f) = f
state_after: case h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : α →C₀ β
x✝ : α
⊢ ((fun f => { toFun := ⇑f, continuous_toFun := ⋯, zero_at_infty' := ⋯ }) ((fun f => ↑f) f)) x✝ = f x✝
tactic: ext
state_before: case h
F : Type u_1
α : Type u
β : Type v
γ : Type w
inst✝⁵ : TopologicalSpace α
inst✝⁴ : TopologicalSpace β
inst✝³ : Zero β
inst✝² : FunLike F α β
inst✝¹ : ZeroAtInftyContinuousMapClass F α β
inst✝ : CompactSpace α
f : α →C₀ β
x✝ : α
⊢ ((fun f => { toFun := ⇑f, continuous_toFun := ⋯, zero_at_infty' := ⋯ }) ((fun f => ↑f) f)) x✝ = f x✝
state_after: no goals
tactic: rfl
Theorem: MeasureTheory.diracProba_comp_diracProbaEquiv_symm_eq_val
File: Mathlib/MeasureTheory/Measure/DiracProba.lean

Proof steps:
state_before: X : Type u_1
inst✝³ : MeasurableSpace X
inst✝² : TopologicalSpace X
inst✝¹ : OpensMeasurableSpace X
inst✝ : T0Space X
⊢ diracProba ∘ ⇑diracProbaEquiv.symm = fun μ => ↑μ
state_after: case h
X : Type u_1
inst✝³ : MeasurableSpace X
inst✝² : TopologicalSpace X
inst✝¹ : OpensMeasurableSpace X
inst✝ : T0Space X
μ : ↑(range diracProba)
⊢ (diracProba ∘ ⇑diracProbaEquiv.symm) μ = ↑μ
tactic: funext μ
state_before: case h
X : Type u_1
inst✝³ : MeasurableSpace X
inst✝² : TopologicalSpace X
inst✝¹ : OpensMeasurableSpace X
inst✝ : T0Space X
μ : ↑(range diracProba)
⊢ (diracProba ∘ ⇑diracProbaEquiv.symm) μ = ↑μ
state_after: no goals
tactic: simp [diracProbaEquiv]
Theorem: MeasureTheory.Measure.restrict_toMeasurable_of_sFinite
File: Mathlib/MeasureTheory/Measure/Typeclasses.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
ι : Type u_4
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
μ ν ν₁ ν₂ : Measure α
s✝ t✝ : Set α
inst✝ : SFinite μ
s t : Set α
ht : MeasurableSet t
⊢ (μ.restrict (toMeasurable μ s)) t = (μ.restrict s) t
state_after: no goals
tactic: rw [restrict_apply ht, inter_comm t, measure_toMeasurable_inter_of_sFinite ht,
      restrict_apply ht, inter_comm t]
Theorem: Equiv.embeddingCongr_apply_trans
File: Mathlib/Logic/Embedding/Basic.lean

Proof steps:
state_before: α₁ : Sort u_1
β₁ : Sort u_2
γ₁ : Sort u_3
α₂ : Sort u_4
β₂ : Sort u_5
γ₂ : Sort u_6
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
ec : γ₁ ≃ γ₂
f : α₁ ↪ β₁
g : β₁ ↪ γ₁
⊢ (ea.embeddingCongr ec) (f.trans g) = ((ea.embeddingCongr eb) f).trans ((eb.embeddingCongr ec) g)
state_after: case h
α₁ : Sort u_1
β₁ : Sort u_2
γ₁ : Sort u_3
α₂ : Sort u_4
β₂ : Sort u_5
γ₂ : Sort u_6
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
ec : γ₁ ≃ γ₂
f : α₁ ↪ β₁
g : β₁ ↪ γ₁
x✝ : α₂
⊢ ((ea.embeddingCongr ec) (f.trans g)) x✝ = (((ea.embeddingCongr eb) f).trans ((eb.embeddingCongr ec) g)) x✝
tactic: ext
state_before: case h
α₁ : Sort u_1
β₁ : Sort u_2
γ₁ : Sort u_3
α₂ : Sort u_4
β₂ : Sort u_5
γ₂ : Sort u_6
ea : α₁ ≃ α₂
eb : β₁ ≃ β₂
ec : γ₁ ≃ γ₂
f : α₁ ↪ β₁
g : β₁ ↪ γ₁
x✝ : α₂
⊢ ((ea.embeddingCongr ec) (f.trans g)) x✝ = (((ea.embeddingCongr eb) f).trans ((eb.embeddingCongr ec) g)) x✝
state_after: no goals
tactic: simp
Theorem: mem_uniformity_of_uniformContinuous_invariant
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
s : Set (β × β)
f : α → α → β
hf : UniformContinuous fun p => f p.1 p.2
hs : s ∈ 𝓤 β
⊢ ∃ u ∈ 𝓤 α, ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
s : Set (β × β)
f : α → α → β
hf : Tendsto ((fun x => (f x.1.1 x.1.2, f x.2.1 x.2.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 α) (𝓤 β)
hs : s ∈ 𝓤 β
⊢ ∃ u ∈ 𝓤 α, ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s
tactic: rw [UniformContinuous, uniformity_prod_eq_prod, tendsto_map'_iff] at hf
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
s : Set (β × β)
f : α → α → β
hf : Tendsto ((fun x => (f x.1.1 x.1.2, f x.2.1 x.2.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 α) (𝓤 β)
hs : s ∈ 𝓤 β
⊢ ∃ u ∈ 𝓤 α, ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s
state_after: case intro.intro.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
s : Set (β × β)
f : α → α → β
hf : Tendsto ((fun x => (f x.1.1 x.1.2, f x.2.1 x.2.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 α) (𝓤 β)
hs : s ∈ 𝓤 β
u : Set (α × α)
hu : u ∈ 𝓤 α
v : Set (α × α)
hv : v ∈ 𝓤 α
huvt : u ×ˢ v ⊆ ((fun x => (f x.1.1 x.1.2, f x.2.1 x.2.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) ⁻¹' s
⊢ ∃ u ∈ 𝓤 α, ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s
tactic: rcases mem_prod_iff.1 (mem_map.1 <| hf hs) with ⟨u, hu, v, hv, huvt⟩
state_before: case intro.intro.intro.intro
α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝¹ : UniformSpace α
inst✝ : UniformSpace β
s : Set (β × β)
f : α → α → β
hf : Tendsto ((fun x => (f x.1.1 x.1.2, f x.2.1 x.2.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 α) (𝓤 β)
hs : s ∈ 𝓤 β
u : Set (α × α)
hu : u ∈ 𝓤 α
v : Set (α × α)
hv : v ∈ 𝓤 α
huvt : u ×ˢ v ⊆ ((fun x => (f x.1.1 x.1.2, f x.2.1 x.2.2)) ∘ fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) ⁻¹' s
⊢ ∃ u ∈ 𝓤 α, ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s
state_after: no goals
tactic: exact ⟨u, hu, fun a b c hab => @huvt ((_, _), (_, _)) ⟨hab, refl_mem_uniformity hv⟩⟩
Theorem: PowerSeries.coeff_def
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
s : Unit →₀ ℕ
n : ℕ
h : s () = n
⊢ coeff R n = MvPowerSeries.coeff R s
state_after: no goals
tactic: erw [coeff, ← h, ← Finsupp.unique_single s]
Theorem: eVariationOn.nonempty_monotone_mem
File: Mathlib/Analysis/BoundedVariation.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
s : Set α
hs : s.Nonempty
⊢ Nonempty { u // Monotone u ∧ ∀ (i : ℕ), u i ∈ s }
state_after: case intro
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
s : Set α
x : α
hx : x ∈ s
⊢ Nonempty { u // Monotone u ∧ ∀ (i : ℕ), u i ∈ s }
tactic: obtain ⟨x, hx⟩ := hs
state_before: case intro
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
s : Set α
x : α
hx : x ∈ s
⊢ Nonempty { u // Monotone u ∧ ∀ (i : ℕ), u i ∈ s }
state_after: no goals
tactic: exact ⟨⟨fun _ => x, fun i j _ => le_rfl, fun _ => hx⟩⟩
Theorem: NonUnitalSubring.coe_sSup_of_directedOn
File: Mathlib/RingTheory/NonUnitalSubring/Basic.lean

Proof steps:
state_before: F : Type w
R : Type u
S✝ : Type v
T : Type u_1
inst✝⁴ : NonUnitalNonAssocRing R
inst✝³ : NonUnitalNonAssocRing S✝
inst✝² : NonUnitalNonAssocRing T
inst✝¹ : FunLike F R S✝
inst✝ : NonUnitalRingHomClass F R S✝
g : S✝ →ₙ+* T
f : R →ₙ+* S✝
S : Set (NonUnitalSubring R)
Sne : S.Nonempty
hS : DirectedOn (fun x x_1 => x ≤ x_1) S
x : R
⊢ x ∈ ↑(sSup S) ↔ x ∈ ⋃ s ∈ S, ↑s
state_after: no goals
tactic: simp [mem_sSup_of_directedOn Sne hS]
Theorem: MeasureTheory.AEStronglyMeasurable.integral_prod_right'
File: Mathlib/MeasureTheory/Constructions/Prod/Integral.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MeasurableSpace α'
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace β'
inst✝³ : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝² : NormedAddCommGroup E
inst✝¹ : SFinite ν
inst✝ : NormedSpace ℝ E
f : α × β → E
hf : AEStronglyMeasurable f (μ.prod ν)
⊢ (fun x => ∫ (y : β), f (x, y) ∂ν) =ᶠ[ae μ] fun x => ∫ (y : β), AEStronglyMeasurable.mk f hf (x, y) ∂ν
state_after: no goals
tactic: filter_upwards [ae_ae_of_ae_prod hf.ae_eq_mk] with _ hx using integral_congr_ae hx
Theorem: CategoryTheory.MonoidalOpposite.unmopBraidedFunctor_μ
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝⁸ : Category.{v₁, u₁} C
inst✝⁷ : MonoidalCategory C
inst✝⁶ : BraidedCategory C
D : Type u₂
inst✝⁵ : Category.{v₂, u₂} D
inst✝⁴ : MonoidalCategory D
inst✝³ : BraidedCategory D
E : Type u₃
inst✝² : Category.{v₃, u₃} E
inst✝¹ : MonoidalCategory E
inst✝ : BraidedCategory E
X Y Z : Cᴹᵒᵖ
⊢ (fun X Y => (β_ X.unmop Y.unmop).hom) X Y ▷ __spread✝⁻⁰.obj Z ≫
      (fun X Y => (β_ X.unmop Y.unmop).hom) (X ⊗ Y) Z ≫ __spread✝⁻⁰.map (α_ X Y Z).hom =
    (α_ (__spread✝⁻⁰.obj X) (__spread✝⁻⁰.obj Y) (__spread✝⁻⁰.obj Z)).hom ≫
      __spread✝⁻⁰.obj X ◁ (fun X Y => (β_ X.unmop Y.unmop).hom) Y Z ≫ (fun X Y => (β_ X.unmop Y.unmop).hom) X (Y ⊗ Z)
state_after: no goals
tactic: simp [← yang_baxter_assoc]
Theorem: List.reduceOption_singleton
File: Mathlib/Data/List/ReduceOption.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
x : Option α
⊢ [x].reduceOption = x.toList
state_after: no goals
tactic: cases x <;> rfl
Theorem: IsSMulRegular.pow
File: Mathlib/Algebra/Regular/SMul.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
n : ℕ
ra : IsSMulRegular M a
⊢ IsSMulRegular M (a ^ n)
state_after: case zero
R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
ra : IsSMulRegular M a
⊢ IsSMulRegular M (a ^ 0)

case succ
R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
ra : IsSMulRegular M a
n : ℕ
hn : IsSMulRegular M (a ^ n)
⊢ IsSMulRegular M (a ^ (n + 1))
tactic: induction' n with n hn
Theorem: HahnSeries.orderTop_single_le
File: Mathlib/RingTheory/HahnSeries/Basic.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
⊢ ↑a ≤ ((single a) r).orderTop
state_after: case pos
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
hr : r = 0
⊢ ↑a ≤ ((single a) r).orderTop

case neg
Γ : Type u_1
R : Type u_2
inst✝¹ : PartialOrder Γ
inst✝ : Zero R
a b : Γ
r : R
hr : ¬r = 0
⊢ ↑a ≤ ((single a) r).orderTop
tactic: by_cases hr : r = 0
Theorem: IsGδ.inter
File: Mathlib/Topology/GDelta.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
s t : Set X
hs : IsGδ s
ht : IsGδ t
⊢ IsGδ (s ∩ t)
state_after: X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
s t : Set X
hs : IsGδ s
ht : IsGδ t
⊢ IsGδ (⋂ b, bif b then s else t)
tactic: rw [inter_eq_iInter]
state_before: X : Type u_1
Y : Type u_2
ι : Type u_3
ι' : Sort u_4
inst✝ : TopologicalSpace X
s t : Set X
hs : IsGδ s
ht : IsGδ t
⊢ IsGδ (⋂ b, bif b then s else t)
state_after: no goals
tactic: exact .iInter (Bool.forall_bool.2 ⟨ht, hs⟩)
Theorem: TopCat.coinduced_of_isColimit
File: Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean

Proof steps:
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
c : Cocone F
hc : IsColimit c
⊢ c.pt.str = ⨆ j, coinduced (⇑(c.ι.app j)) (F.obj j).str
state_after: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
c : Cocone F
hc : IsColimit c
homeo : ↑c.pt ≃ₜ ↑(colimitCocone F).pt := homeoOfIso (hc.coconePointUniqueUpToIso (colimitCoconeIsColimit F))
⊢ c.pt.str = ⨆ j, coinduced (⇑(c.ι.app j)) (F.obj j).str
tactic: let homeo := homeoOfIso (hc.coconePointUniqueUpToIso (colimitCoconeIsColimit F))
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
c : Cocone F
hc : IsColimit c
homeo : ↑c.pt ≃ₜ ↑(colimitCocone F).pt := homeoOfIso (hc.coconePointUniqueUpToIso (colimitCoconeIsColimit F))
⊢ c.pt.str = ⨆ j, coinduced (⇑(c.ι.app j)) (F.obj j).str
state_after: case a.h.a
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
c : Cocone F
hc : IsColimit c
homeo : ↑c.pt ≃ₜ ↑(colimitCocone F).pt := homeoOfIso (hc.coconePointUniqueUpToIso (colimitCoconeIsColimit F))
x✝ : Set ↑c.pt
⊢ IsOpen x✝ ↔ IsOpen x✝
tactic: ext
state_before: case a.h.a
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
c : Cocone F
hc : IsColimit c
homeo : ↑c.pt ≃ₜ ↑(colimitCocone F).pt := homeoOfIso (hc.coconePointUniqueUpToIso (colimitCoconeIsColimit F))
x✝ : Set ↑c.pt
⊢ IsOpen x✝ ↔ IsOpen x✝
state_after: case a.h.a
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
c : Cocone F
hc : IsColimit c
homeo : ↑c.pt ≃ₜ ↑(colimitCocone F).pt := homeoOfIso (hc.coconePointUniqueUpToIso (colimitCoconeIsColimit F))
x✝ : Set ↑c.pt
⊢ IsOpen (⇑homeo.symm ⁻¹' x✝) ↔ ∀ (i : J), IsOpen x✝
tactic: refine homeo.symm.isOpen_preimage.symm.trans (Iff.trans ?_ isOpen_iSup_iff.symm)
state_before: case a.h.a
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TopCat
c : Cocone F
hc : IsColimit c
homeo : ↑c.pt ≃ₜ ↑(colimitCocone F).pt := homeoOfIso (hc.coconePointUniqueUpToIso (colimitCoconeIsColimit F))
x✝ : Set ↑c.pt
⊢ IsOpen (⇑homeo.symm ⁻¹' x✝) ↔ ∀ (i : J), IsOpen x✝
state_after: no goals
tactic: exact isOpen_iSup_iff
Theorem: NumberField.mixedEmbedding.convexBodySum_volume
File: Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
⊢ volume (convexBodySum K B) = ↑(convexBodySumFactor K) * ENNReal.ofReal B ^ finrank ℚ K
state_after: case inl
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
hB : B ≤ 0
⊢ volume (convexBodySum K B) = ↑(convexBodySumFactor K) * ENNReal.ofReal B ^ finrank ℚ K

case inr
K : Type u_1
inst✝¹ : Field K
inst✝ : NumberField K
B : ℝ
hB : 0 < B
⊢ volume (convexBodySum K B) = ↑(convexBodySumFactor K) * ENNReal.ofReal B ^ finrank ℚ K
tactic: obtain hB | hB := le_or_lt B 0