ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: unitary_iff_isStarNormal_and_spectrum_subset_circle
File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unitary.lean

Proof steps:
state_before: A : Type u_1
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : Algebra ℂ A
inst✝¹ : StarModule ℂ A
inst✝ : ContinuousFunctionalCalculus ℂ IsStarNormal
u : A
⊢ u ∈ unitary A ↔ IsStarNormal u ∧ spectrum ℂ u ⊆ ↑circle
state_after: case refine_1
A : Type u_1
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : Algebra ℂ A
inst✝¹ : StarModule ℂ A
inst✝ : ContinuousFunctionalCalculus ℂ IsStarNormal
u : A
hu : u ∈ unitary A
⊢ IsStarNormal u ∧ spectrum ℂ u ⊆ ↑circle

case refine_2
A : Type u_1
inst✝⁵ : TopologicalSpace A
inst✝⁴ : Ring A
inst✝³ : StarRing A
inst✝² : Algebra ℂ A
inst✝¹ : StarModule ℂ A
inst✝ : ContinuousFunctionalCalculus ℂ IsStarNormal
u : A
⊢ IsStarNormal u ∧ spectrum ℂ u ⊆ ↑circle → u ∈ unitary A
tactic: refine ⟨fun hu ↦ ?_, ?_⟩
Theorem: ofAdd_multiset_prod
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✝ : AddCommMonoid α
s : Multiset α
⊢ ofAdd s.sum = (Multiset.map (⇑ofAdd) s).prod
state_after: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝ : AddCommMonoid α
s : Multiset α
⊢ s.sum = s.prod
tactic: simp [ofAdd]
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✝ : AddCommMonoid α
s : Multiset α
⊢ s.sum = s.prod
state_after: no goals
tactic: rfl
Theorem: locallyConnectedSpace_iff_connected_subsets
File: Mathlib/Topology/Connected/LocallyConnected.lean

Proof steps:
state_before: α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
⊢ LocallyConnectedSpace α ↔ ∀ (x : α), ∀ U ∈ 𝓝 x, ∃ V ∈ 𝓝 x, IsPreconnected V ∧ V ⊆ U
state_after: case mp
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
⊢ LocallyConnectedSpace α → ∀ (x : α), ∀ U ∈ 𝓝 x, ∃ V ∈ 𝓝 x, IsPreconnected V ∧ V ⊆ U

case mpr
α : Type u
β : Type v
ι : Type u_1
π : ι → Type u_2
inst✝ : TopologicalSpace α
s t u v : Set α
⊢ (∀ (x : α), ∀ U ∈ 𝓝 x, ∃ V ∈ 𝓝 x, IsPreconnected V ∧ V ⊆ U) → LocallyConnectedSpace α
tactic: constructor
Theorem: inv_smul_smul
File: Mathlib/Algebra/Group/Action/Defs.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
G : Type u_3
H : Type u_4
A : Type u_5
B : Type u_6
α : Type u_7
β : Type u_8
γ : Type u_9
δ : Type u_10
inst✝³ : Monoid M
inst✝² : MulAction M α
inst✝¹ : Group G
inst✝ : MulAction G α
g✝ : G
a✝ b : α
g : G
a : α
⊢ g⁻¹ • g • a = a
state_after: no goals
tactic: rw [smul_smul, mul_left_inv, one_smul]
Theorem: StieltjesFunction.measure_const
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

Proof steps:
state_before: f : StieltjesFunction
c x✝² x✝¹ : ℝ
x✝ : x✝² < x✝¹
⊢ (StieltjesFunction.const c).measure (Ioc x✝² x✝¹) = 0 (Ioc x✝² x✝¹)
state_after: no goals
tactic: simp
Theorem: TopologicalSpace.isTopologicalBasis_of_subbasis_of_inter
File: Mathlib/Topology/Bases.lean

Proof steps:
state_before: α : Type u
β : Type u_1
t : TopologicalSpace α
B : Set (Set α)
s : Set α
r : Set (Set α)
hsg : t = generateFrom r
hsi : ∀ ⦃s : Set α⦄, s ∈ r → ∀ ⦃t : Set α⦄, t ∈ r → s ∩ t ∈ r
⊢ t = generateFrom (insert univ r)
state_after: no goals
tactic: simpa using hsg
Theorem: Multiset.toEnumFinset_mono
File: Mathlib/Data/Multiset/Fintype.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : m₁ ≤ m₂
⊢ m₁.toEnumFinset ⊆ m₂.toEnumFinset
state_after: α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : m₁ ≤ m₂
p : α × ℕ
⊢ p ∈ m₁.toEnumFinset → p ∈ m₂.toEnumFinset
tactic: intro p
state_before: α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : m₁ ≤ m₂
p : α × ℕ
⊢ p ∈ m₁.toEnumFinset → p ∈ m₂.toEnumFinset
state_after: α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : m₁ ≤ m₂
p : α × ℕ
⊢ p.2 < count p.1 m₁ → p.2 < count p.1 m₂
tactic: simp only [Multiset.mem_toEnumFinset]
state_before: α : Type u_1
inst✝ : DecidableEq α
m m₁ m₂ : Multiset α
h : m₁ ≤ m₂
p : α × ℕ
⊢ p.2 < count p.1 m₁ → p.2 < count p.1 m₂
state_after: no goals
tactic: exact gt_of_ge_of_gt (Multiset.le_iff_count.mp h p.1)
Theorem: Nat.psub_add
File: Mathlib/Data/Nat/PSub.lean

Proof steps:
state_before: m n k : ℕ
⊢ m.psub (n + k) = do
    let __do_lift ← m.psub n
    __do_lift.psub k
state_after: no goals
tactic: induction k with
    | zero => simp only [zero_eq, add_zero, psub_zero, Option.bind_eq_bind, Option.bind_some]
    | succ n ih => simp only [ih, add_succ, psub_succ, bind_assoc]
Theorem: isClosed_of_closure_subset
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
h : closure s ⊆ s
⊢ IsClosed s
state_after: 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
h : closure s ⊆ s
⊢ IsClosed (closure s)
tactic: rw [subset_closure.antisymm h]
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
h : closure s ⊆ s
⊢ IsClosed (closure s)
state_after: no goals
tactic: exact isClosed_closure
Theorem: Multiset.count_attach
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
inst✝ : DecidableEq α
s : Multiset α
a x✝¹ : { x // x ∈ s }
x✝ : x✝¹ ∈ s.attach
⊢ (a = x✝¹) = (↑a = ↑x✝¹)
state_after: no goals
tactic: simp [Subtype.ext_iff]
Theorem: ContinuousLinearMap.toLinear_compLeftContinuousCompact
File: Mathlib/Topology/ContinuousFunction/Compact.lean

Proof steps:
state_before: X : Type u_1
𝕜 : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁶ : TopologicalSpace X
inst✝⁵ : CompactSpace X
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedAddCommGroup β
inst✝² : NormedSpace 𝕜 β
inst✝¹ : NormedAddCommGroup γ
inst✝ : NormedSpace 𝕜 γ
g : β →L[𝕜] γ
⊢ ↑(ContinuousLinearMap.compLeftContinuousCompact X g) = ContinuousLinearMap.compLeftContinuous 𝕜 X g
state_after: case h.h
X : Type u_1
𝕜 : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁶ : TopologicalSpace X
inst✝⁵ : CompactSpace X
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedAddCommGroup β
inst✝² : NormedSpace 𝕜 β
inst✝¹ : NormedAddCommGroup γ
inst✝ : NormedSpace 𝕜 γ
g : β →L[𝕜] γ
f : C(X, β)
a✝ : X
⊢ (↑(ContinuousLinearMap.compLeftContinuousCompact X g) f) a✝ = ((ContinuousLinearMap.compLeftContinuous 𝕜 X g) f) a✝
tactic: ext f
state_before: case h.h
X : Type u_1
𝕜 : Type u_2
β : Type u_3
γ : Type u_4
inst✝⁶ : TopologicalSpace X
inst✝⁵ : CompactSpace X
inst✝⁴ : NontriviallyNormedField 𝕜
inst✝³ : NormedAddCommGroup β
inst✝² : NormedSpace 𝕜 β
inst✝¹ : NormedAddCommGroup γ
inst✝ : NormedSpace 𝕜 γ
g : β →L[𝕜] γ
f : C(X, β)
a✝ : X
⊢ (↑(ContinuousLinearMap.compLeftContinuousCompact X g) f) a✝ = ((ContinuousLinearMap.compLeftContinuous 𝕜 X g) f) a✝
state_after: no goals
tactic: rfl
Theorem: Cardinal.mk_surjective_eq_arrow_of_lift_le
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

Proof steps:
state_before: α β : Type u
β' : Type v
inst✝ : Infinite α
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
⊢ Nonempty (α ≃ α ⊕ β')
state_after: α β : Type u
β' : Type v
inst✝ : Infinite α
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
⊢ lift.{max u v, u} #α = lift.{max v u, u} #α + lift.{u, v} #β'
tactic: simp_rw [← lift_mk_eq', mk_sum, lift_add, lift_lift]
state_before: α β : Type u
β' : Type v
inst✝ : Infinite α
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
⊢ lift.{max u v, u} #α = lift.{max v u, u} #α + lift.{u, v} #β'
state_after: α β : Type u
β' : Type v
inst✝ : Infinite α
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
⊢ lift.{v, u} #α + lift.{u, v} #β' = lift.{v, u} #α
tactic: rw [lift_umax.{u,v}, eq_comm]
state_before: α β : Type u
β' : Type v
inst✝ : Infinite α
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
⊢ lift.{v, u} #α + lift.{u, v} #β' = lift.{v, u} #α
state_after: no goals
tactic: exact add_eq_left (aleph0_le_lift.mpr <| aleph0_le_mk α) lle
state_before: α β : Type u
β' : Type v
inst✝ : Infinite α
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
e : α ≃ α ⊕ β'
f g : α → β'
h : (fun f => ⟨fun a => Sum.elim f id (e a), ⋯⟩) f = (fun f => ⟨fun a => Sum.elim f id (e a), ⋯⟩) g
a : α
⊢ f a = g a
state_after: no goals
tactic: simpa only [e.apply_symm_apply] using congr_fun (Subtype.ext_iff.mp h) (e.symm <| .inl a)
Theorem: List.map_surjective_iff
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β
h : Surjective (map f)
x : β
⊢ ∃ a, f a = x
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β
h : Surjective (map f)
x : β
y : α
hxy : map f [y] = [x]
⊢ ∃ a, f a = x
tactic: let ⟨[y], hxy⟩ := h [x]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
f : α → β
h : Surjective (map f)
x : β
y : α
hxy : map f [y] = [x]
⊢ ∃ a, f a = x
state_after: no goals
tactic: exact ⟨_, List.singleton_injective hxy⟩
Theorem: CategoryTheory.Limits.Types.colimit_sound'
File: Mathlib/CategoryTheory/Limits/Types.lean

Proof steps:
state_before: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j j' : J
x : F.obj j
x' : F.obj j'
j'' : J
f : j ⟶ j''
f' : j' ⟶ j''
w : F.map f x = F.map f' x'
⊢ colimit.ι F j x = colimit.ι F j' x'
state_after: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j j' : J
x : F.obj j
x' : F.obj j'
j'' : J
f : j ⟶ j''
f' : j' ⟶ j''
w : F.map f x = F.map f' x'
⊢ (F.map f ≫ colimit.ι F j'') x = (F.map f' ≫ colimit.ι F j'') x'
tactic: rw [← colimit.w _ f, ← colimit.w _ f']
state_before: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j j' : J
x : F.obj j
x' : F.obj j'
j'' : J
f : j ⟶ j''
f' : j' ⟶ j''
w : F.map f x = F.map f' x'
⊢ (F.map f ≫ colimit.ι F j'') x = (F.map f' ≫ colimit.ι F j'') x'
state_after: no goals
tactic: rw [types_comp_apply, types_comp_apply, w]
Theorem: ENNReal.toReal_mul_top
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ (a * ⊤).toReal = 0
state_after: no goals
tactic: rw [toReal_mul, top_toReal, mul_zero]
Theorem: CategoryTheory.Monad.ForgetCreatesLimits.conePoint_A
File: Mathlib/CategoryTheory/Monad/Limits.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
j : J
⊢ (T.η.app c.pt ≫ t.lift (newCone D c)) ≫ c.π.app j = 𝟙 c.pt ≫ c.π.app j
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
j : J
⊢ c.π.app j ≫ 𝟙 (D.obj j).A = 𝟙 c.pt ≫ c.π.app j
tactic: rw [Category.assoc, t.fac, newCone_π_app, ← T.η.naturality_assoc, Functor.id_map,
        (D.obj j).unit]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
j : J
⊢ c.π.app j ≫ 𝟙 (D.obj j).A = 𝟙 c.pt ≫ c.π.app j
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
j : J
⊢ (T.μ.app c.pt ≫ t.lift (newCone D c)) ≫ c.π.app j = (T.map (t.lift (newCone D c)) ≫ t.lift (newCone D c)) ≫ c.π.app j
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
j : J
⊢ (T.toFunctor ⋙ T.toFunctor).map (c.π.app j) ≫ T.map (D.obj j).a ≫ (D.obj j).a =
    T.map (T.map (c.π.app j)) ≫ T.map (D.obj j).a ≫ (D.obj j).a
tactic: rw [Category.assoc, Category.assoc, t.fac (newCone D c), newCone_π_app, ←
        Functor.map_comp_assoc, t.fac (newCone D c), newCone_π_app, ← T.μ.naturality_assoc,
        (D.obj j).assoc, Functor.map_comp, Category.assoc]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
T : Monad C
J : Type u
inst✝ : Category.{v, u} J
D : J ⥤ T.Algebra
c : Cone (D ⋙ T.forget)
t : IsLimit c
j : J
⊢ (T.toFunctor ⋙ T.toFunctor).map (c.π.app j) ≫ T.map (D.obj j).a ≫ (D.obj j).a =
    T.map (T.map (c.π.app j)) ≫ T.map (D.obj j).a ≫ (D.obj j).a
state_after: no goals
tactic: rfl
Theorem: Prod.mk_wcovBy_mk_iff
File: Mathlib/Order/Cover.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ (a₁, b₁) ⩿ (a₂, b₂) ↔ a₁ ⩿ a₂ ∧ b₁ = b₂ ∨ b₁ ⩿ b₂ ∧ a₁ = a₂
state_after: case refine_1
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
h : (a₁, b₁) ⩿ (a₂, b₂)
⊢ a₁ ⩿ a₂ ∧ b₁ = b₂ ∨ b₁ ⩿ b₂ ∧ a₁ = a₂

case refine_2
α : Type u_1
β : Type u_2
inst✝¹ : PartialOrder α
inst✝ : PartialOrder β
a a₁ a₂ : α
b b₁ b₂ : β
x y : α × β
⊢ a₁ ⩿ a₂ ∧ b₁ = b₂ ∨ b₁ ⩿ b₂ ∧ a₁ = a₂ → (a₁, b₁) ⩿ (a₂, b₂)
tactic: refine ⟨fun h => ?_, ?_⟩
Theorem: List.get?_ofFn
File: Mathlib/Data/List/OfFn.lean

Proof steps:
state_before: α : Type u
n : ℕ
f : Fin n → α
i : ℕ
⊢ (ofFn f).get? i = ofFnNthVal f i
state_after: no goals
tactic: simp
Theorem: CoxeterSystem.length_inv
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ cs.length w⁻¹ = cs.length w
state_after: case h₁
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ cs.length w⁻¹ ≤ cs.length w

case h₂
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
⊢ cs.length w ≤ cs.length w⁻¹
tactic: apply Nat.le_antisymm
Theorem: SimpleGraph.le_egirth
File: Mathlib/Combinatorics/SimpleGraph/Girth.lean

Proof steps:
state_before: α : Type u_1
G : SimpleGraph α
n : ℕ∞
⊢ n ≤ G.egirth ↔ ∀ (a : α) (w : G.Walk a a), w.IsCycle → n ≤ ↑w.length
state_after: no goals
tactic: simp [egirth]
Theorem: MvPolynomial.coeff_modMonomial_of_not_le
File: Mathlib/Algebra/MvPolynomial/Division.lean

Proof steps:
state_before: σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
s' s : σ →₀ ℕ
x : MvPolynomial σ R
h : ¬s ≤ s'
⊢ ¬∃ d, s' = s + d
state_after: case intro
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
s : σ →₀ ℕ
x : MvPolynomial σ R
d : σ →₀ ℕ
h : ¬s ≤ s + d
⊢ False
tactic: rintro ⟨d, rfl⟩
state_before: case intro
σ : Type u_1
R : Type u_2
inst✝ : CommSemiring R
s : σ →₀ ℕ
x : MvPolynomial σ R
d : σ →₀ ℕ
h : ¬s ≤ s + d
⊢ False
state_after: no goals
tactic: exact h le_self_add
Theorem: Complex.log_ofReal_re
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

Proof steps:
state_before: x : ℝ
⊢ (log ↑x).re = Real.log x
state_after: no goals
tactic: simp [log_re]
Theorem: mem_uniform_prod
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
t₁ : UniformSpace α
t₂ : UniformSpace β
a : Set (α × α)
b : Set (β × β)
ha : a ∈ 𝓤 α
hb : b ∈ 𝓤 β
⊢ {p | (p.1.1, p.2.1) ∈ a ∧ (p.1.2, p.2.2) ∈ b} ∈ 𝓤 (α × β)
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
t₁ : UniformSpace α
t₂ : UniformSpace β
a : Set (α × α)
b : Set (β × β)
ha : a ∈ 𝓤 α
hb : b ∈ 𝓤 β
⊢ {p | (p.1.1, p.2.1) ∈ a ∧ (p.1.2, p.2.2) ∈ b} ∈
    comap (fun p => (p.1.1, p.2.1)) (𝓤 α) ⊓ comap (fun p => (p.1.2, p.2.2)) (𝓤 β)
tactic: rw [uniformity_prod]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
t₁ : UniformSpace α
t₂ : UniformSpace β
a : Set (α × α)
b : Set (β × β)
ha : a ∈ 𝓤 α
hb : b ∈ 𝓤 β
⊢ {p | (p.1.1, p.2.1) ∈ a ∧ (p.1.2, p.2.2) ∈ b} ∈
    comap (fun p => (p.1.1, p.2.1)) (𝓤 α) ⊓ comap (fun p => (p.1.2, p.2.2)) (𝓤 β)
state_after: no goals
tactic: exact inter_mem_inf (preimage_mem_comap ha) (preimage_mem_comap hb)
Theorem: Batteries.AssocList.length_replace
File: .lake/packages/batteries/Batteries/Data/AssocList.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
b : β✝
l : AssocList α β✝
inst✝ : BEq α
a : α
⊢ (replace a b l).length = l.length
state_after: case nil
α : Type u_1
β✝ : Type u_2
b : β✝
inst✝ : BEq α
a : α
⊢ (replace a b nil).length = nil.length

case cons
α : Type u_1
β✝ : Type u_2
b : β✝
inst✝ : BEq α
a key✝ : α
value✝ : β✝
tail✝ : AssocList α β✝
tail_ih✝ : (replace a b tail✝).length = tail✝.length
⊢ (replace a b (cons key✝ value✝ tail✝)).length = (cons key✝ value✝ tail✝).length
tactic: induction l
Theorem: _private.Mathlib.Data.Complex.Exponential.0.Real.add_one_le_exp_of_nonneg
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x✝ y x : ℝ
hx : 0 ≤ x
⊢ x + 1 ≤ rexp x
state_after: case inl
x y : ℝ
hx : 0 ≤ 0
⊢ 0 + 1 ≤ rexp 0

case inr
x✝ y x : ℝ
hx : 0 ≤ x
h : 0 < x
⊢ x + 1 ≤ rexp x
tactic: rcases eq_or_lt_of_le hx with (rfl | h)
state_before: case inr
x✝ y x : ℝ
hx : 0 ≤ x
h : 0 < x
⊢ x + 1 ≤ rexp x
state_after: no goals
tactic: exact (add_one_lt_exp_of_pos h).le
Theorem: Nat.primeFactorsList_sublist_of_dvd
File: Mathlib/Data/Nat/Factors.lean

Proof steps:
state_before: n k : ℕ
h : n ∣ k
h' : k ≠ 0
⊢ n.primeFactorsList <+ k.primeFactorsList
state_after: case intro
n a : ℕ
h' : n * a ≠ 0
⊢ n.primeFactorsList <+ (n * a).primeFactorsList
tactic: obtain ⟨a, rfl⟩ := h
state_before: case intro
n a : ℕ
h' : n * a ≠ 0
⊢ n.primeFactorsList <+ (n * a).primeFactorsList
state_after: no goals
tactic: exact primeFactorsList_sublist_right (right_ne_zero_of_mul h')
Theorem: Set.covBy_iff_exists_insert
File: Mathlib/Order/Cover.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s t : Set α
a : α
⊢ (∃ a ∉ s, insert a s = t) → s ⋖ t
state_after: case intro.intro
α : Type u_1
β : Type u_2
s : Set α
a✝ a : α
ha : a ∉ s
⊢ s ⋖ insert a s
tactic: rintro ⟨a, ha, rfl⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
s : Set α
a✝ a : α
ha : a ∉ s
⊢ s ⋖ insert a s
state_after: no goals
tactic: exact covBy_insert ha
Theorem: Finset.Ico_erase_left
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a✝ b✝ c : α
inst✝ : DecidableEq α
a b : α
⊢ (Ico a b).erase a = Ioo a b
state_after: no goals
tactic: simp [← coe_inj]
Theorem: LowerSet.mem_iSup_iff
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
S : Set (LowerSet α)
s t : LowerSet α
a : α
f : ι → LowerSet α
⊢ a ∈ ⨆ i, f i ↔ ∃ i, a ∈ f i
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
S : Set (LowerSet α)
s t : LowerSet α
a : α
f : ι → LowerSet α
⊢ a ∈ ⋃ i, ↑(f i) ↔ ∃ i, a ∈ f i
tactic: rw [← SetLike.mem_coe, coe_iSup]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : LE α
S : Set (LowerSet α)
s t : LowerSet α
a : α
f : ι → LowerSet α
⊢ a ∈ ⋃ i, ↑(f i) ↔ ∃ i, a ∈ f i
state_after: no goals
tactic: exact mem_iUnion
Theorem: AdjoinRoot.powerBasis_dim
File: Mathlib/RingTheory/AdjoinRoot.lean

Proof steps:
state_before: R : Type u
S : Type v
K : Type w
inst✝¹ : CommRing R
g : R[X]
inst✝ : Field K
f : K[X]
hf : f ≠ 0
⊢ ∀ (i : Fin f.natDegree), (powerBasisAux hf) i = root f ^ ↑i
state_after: no goals
tactic: simp [powerBasisAux]
Theorem: CategoryTheory.NatTrans.naturality_apply
File: Mathlib/CategoryTheory/ConcreteCategory/Basic.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝² : Category.{u_3, u_1} C
inst✝¹ : Category.{u_4, u_2} D
inst✝ : ConcreteCategory D
F G : C ⥤ D
φ : F ⟶ G
X Y : C
f : X ⟶ Y
x : (forget D).obj (F.obj X)
⊢ (φ.app Y) ((F.map f) x) = (G.map f) ((φ.app X) x)
state_after: no goals
tactic: simpa only [Functor.map_comp] using congr_fun ((forget D).congr_map (φ.naturality f)) x
Theorem: Finset.smulAntidiagonal_min_smul_min
File: Mathlib/Data/Finset/SMulAntidiagonal.lean

Proof steps:
state_before: G : Type u_1
P : Type u_2
inst✝³ : LinearOrder G
inst✝² : LinearOrder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
s : Set G
t : Set P
hs : s.IsWF
ht : t.IsWF
hns : s.Nonempty
hnt : t.Nonempty
⊢ SMulAntidiagonal ⋯ ⋯ (hs.min hns • ht.min hnt) = {(hs.min hns, ht.min hnt)}
state_after: case a.mk
G : Type u_1
P : Type u_2
inst✝³ : LinearOrder G
inst✝² : LinearOrder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
s : Set G
t : Set P
hs : s.IsWF
ht : t.IsWF
hns : s.Nonempty
hnt : t.Nonempty
a : G
b : P
⊢ (a, b) ∈ SMulAntidiagonal ⋯ ⋯ (hs.min hns • ht.min hnt) ↔ (a, b) ∈ {(hs.min hns, ht.min hnt)}
tactic: ext ⟨a, b⟩
state_before: case a.mk
G : Type u_1
P : Type u_2
inst✝³ : LinearOrder G
inst✝² : LinearOrder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
s : Set G
t : Set P
hs : s.IsWF
ht : t.IsWF
hns : s.Nonempty
hnt : t.Nonempty
a : G
b : P
⊢ (a, b) ∈ SMulAntidiagonal ⋯ ⋯ (hs.min hns • ht.min hnt) ↔ (a, b) ∈ {(hs.min hns, ht.min hnt)}
state_after: case a.mk
G : Type u_1
P : Type u_2
inst✝³ : LinearOrder G
inst✝² : LinearOrder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
s : Set G
t : Set P
hs : s.IsWF
ht : t.IsWF
hns : s.Nonempty
hnt : t.Nonempty
a : G
b : P
⊢ a ∈ s ∧ b ∈ t ∧ a • b = hs.min hns • ht.min hnt ↔ a = hs.min hns ∧ b = ht.min hnt
tactic: simp only [mem_smulAntidiagonal, mem_singleton, Prod.ext_iff]
state_before: case a.mk
G : Type u_1
P : Type u_2
inst✝³ : LinearOrder G
inst✝² : LinearOrder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
s : Set G
t : Set P
hs : s.IsWF
ht : t.IsWF
hns : s.Nonempty
hnt : t.Nonempty
a : G
b : P
⊢ a ∈ s ∧ b ∈ t ∧ a • b = hs.min hns • ht.min hnt ↔ a = hs.min hns ∧ b = ht.min hnt
state_after: case a.mk.mp
G : Type u_1
P : Type u_2
inst✝³ : LinearOrder G
inst✝² : LinearOrder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
s : Set G
t : Set P
hs : s.IsWF
ht : t.IsWF
hns : s.Nonempty
hnt : t.Nonempty
a : G
b : P
⊢ a ∈ s ∧ b ∈ t ∧ a • b = hs.min hns • ht.min hnt → a = hs.min hns ∧ b = ht.min hnt

case a.mk.mpr
G : Type u_1
P : Type u_2
inst✝³ : LinearOrder G
inst✝² : LinearOrder P
inst✝¹ : SMul G P
inst✝ : IsOrderedCancelSMul G P
s : Set G
t : Set P
hs : s.IsWF
ht : t.IsWF
hns : s.Nonempty
hnt : t.Nonempty
a : G
b : P
⊢ a = hs.min hns ∧ b = ht.min hnt → a ∈ s ∧ b ∈ t ∧ a • b = hs.min hns • ht.min hnt
tactic: constructor
Theorem: Nat.minFac_two
File: Mathlib/Data/Nat/Prime/Defs.lean

Proof steps:
state_before: n : ℕ
⊢ minFac 2 = 2
state_after: no goals
tactic: simp [minFac, minFacAux]
Theorem: monotone_stabilizes_iff_noetherian
File: Mathlib/RingTheory/Noetherian.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
P : Type u_3
N : Type w
inst✝⁶ : Semiring R
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
⊢ (∀ (f : ℕ →o Submodule R M), ∃ n, ∀ (m : ℕ), n ≤ m → f n = f m) ↔ IsNoetherian R M
state_after: no goals
tactic: rw [isNoetherian_iff_wellFounded, WellFounded.monotone_chain_condition]
Theorem: _private.Mathlib.Data.Complex.Exponential.0.Complex.cos_add_aux
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y a b c d : ℂ
⊢ (a + b) * (c + d) - (b - a) * (d - c) * -1 = 2 * (a * c + b * d)
state_after: no goals
tactic: ring
Theorem: Submodule.LinearDisjoint.rank_le_one_of_commute_of_flat_of_self
File: Mathlib/LinearAlgebra/LinearDisjoint.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
inst✝¹ : Algebra R S
M N : Submodule R S
H✝ : M.LinearDisjoint N
H : M.LinearDisjoint M
inst✝ : Module.Flat R ↥M
hc : ∀ (m n : ↥M), Commute ↑m ↑n
⊢ Module.rank R ↥M ≤ 1
state_after: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
inst✝¹ : Algebra R S
M N : Submodule R S
H✝ : M.LinearDisjoint N
H : M.LinearDisjoint M
inst✝ : Module.Flat R ↥M
hc : ∀ (m n : ↥(M ⊓ M)), Commute ↑m ↑n
⊢ Module.rank R ↥(M ⊓ M) ≤ 1
tactic: rw [← inf_of_le_left (le_refl M)] at hc ⊢
state_before: R : Type u
S : Type v
inst✝³ : CommRing R
inst✝² : Ring S
inst✝¹ : Algebra R S
M N : Submodule R S
H✝ : M.LinearDisjoint N
H : M.LinearDisjoint M
inst✝ : Module.Flat R ↥M
hc : ∀ (m n : ↥(M ⊓ M)), Commute ↑m ↑n
⊢ Module.rank R ↥(M ⊓ M) ≤ 1
state_after: no goals
tactic: exact H.rank_inf_le_one_of_commute_of_flat_left hc