ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Functor.pi_ext
File: Mathlib/CategoryTheory/Pi/Basic.lean

Proof steps:
state_before: I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category.{v₁, u₁} (C i)
D : I → Type u₂
inst✝¹ : (i : I) → Category.{v₂, u₂} (D i)
A : Type u₃
inst✝ : Category.{v₃, u₃} A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ f = f'
state_after: case h_map
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category.{v₁, u₁} (C i)
D : I → Type u₂
inst✝¹ : (i : I) → Category.{v₂, u₂} (D i)
A : Type u₃
inst✝ : Category.{v₃, u₃} A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ autoParam (∀ (X Y : A) (f_1 : X ⟶ Y), f.map f_1 = eqToHom ⋯ ≫ f'.map f_1 ≫ eqToHom ⋯) _auto✝

case h_obj
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category.{v₁, u₁} (C i)
D : I → Type u₂
inst✝¹ : (i : I) → Category.{v₂, u₂} (D i)
A : Type u₃
inst✝ : Category.{v₃, u₃} A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ ∀ (X : A), f.obj X = f'.obj X
tactic: apply Functor.ext
state_before: case h_map
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category.{v₁, u₁} (C i)
D : I → Type u₂
inst✝¹ : (i : I) → Category.{v₂, u₂} (D i)
A : Type u₃
inst✝ : Category.{v₃, u₃} A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ autoParam (∀ (X Y : A) (f_1 : X ⟶ Y), f.map f_1 = eqToHom ⋯ ≫ f'.map f_1 ≫ eqToHom ⋯) _auto✝

case h_obj
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category.{v₁, u₁} (C i)
D : I → Type u₂
inst✝¹ : (i : I) → Category.{v₂, u₂} (D i)
A : Type u₃
inst✝ : Category.{v₃, u₃} A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ ∀ (X : A), f.obj X = f'.obj X
state_after: case h_obj
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category.{v₁, u₁} (C i)
D : I → Type u₂
inst✝¹ : (i : I) → Category.{v₂, u₂} (D i)
A : Type u₃
inst✝ : Category.{v₃, u₃} A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ ∀ (X : A), f.obj X = f'.obj X

case h_map
I : Type w₀
J : Type w₁
C : I → Type u₁
inst✝² : (i : I) → Category.{v₁, u₁} (C i)
D : I → Type u₂
inst✝¹ : (i : I) → Category.{v₂, u₂} (D i)
A : Type u₃
inst✝ : Category.{v₃, u₃} A
f f' : A ⥤ ((i : I) → C i)
h : ∀ (i : I), f ⋙ Pi.eval C i = f' ⋙ Pi.eval C i
⊢ autoParam (∀ (X Y : A) (f_1 : X ⟶ Y), f.map f_1 = eqToHom ⋯ ≫ f'.map f_1 ≫ eqToHom ⋯) _auto✝
tactic: rotate_left
Theorem: mem_nhds_subtype_iff_nhdsWithin
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝¹ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝ : (i : ι) → TopologicalSpace (π i)
s : Set α
a : ↑s
t : Set ↑s
⊢ t ∈ 𝓝 a ↔ Subtype.val '' t ∈ 𝓝[s] ↑a
state_after: no goals
tactic: rw [← map_nhds_subtype_val, image_mem_map_iff Subtype.val_injective]
Theorem: specializes_pi
File: Mathlib/Topology/Inseparable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s : Set X
f✝ g✝ : X → Y
f g : (i : ι) → π i
⊢ f ⤳ g ↔ ∀ (i : ι), f i ⤳ g i
state_after: no goals
tactic: simp only [Specializes, nhds_pi, pi_le_pi]
Theorem: FirstOrder.Language.Equiv.self_comp_symm
File: Mathlib/ModelTheory/Basic.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
f : M ≃[L] N
⊢ f.comp f.symm = refl L N
state_after: case h
L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
f : M ≃[L] N
x✝ : N
⊢ (f.comp f.symm) x✝ = (refl L N) x✝
tactic: ext
state_before: case h
L : Language
L' : Language
M : Type w
N : Type w'
inst✝³ : L.Structure M
inst✝² : L.Structure N
P : Type u_1
inst✝¹ : L.Structure P
Q : Type u_2
inst✝ : L.Structure Q
f : M ≃[L] N
x✝ : N
⊢ (f.comp f.symm) x✝ = (refl L N) x✝
state_after: no goals
tactic: rw [comp_apply, apply_symm_apply, refl_apply]
Theorem: FDRep.forget₂_ρ
File: Mathlib/RepresentationTheory/FDRep.lean

Proof steps:
state_before: k G : Type u
inst✝¹ : Field k
inst✝ : Monoid G
V : FDRep k G
⊢ ((forget₂ (FDRep k G) (Rep k G)).obj V).ρ = V.ρ
state_after: case h.h
k G : Type u
inst✝¹ : Field k
inst✝ : Monoid G
V : FDRep k G
g : G
v : CoeSort.coe ((forget₂ (FDRep k G) (Rep k G)).obj V)
⊢ (((forget₂ (FDRep k G) (Rep k G)).obj V).ρ g) v = (V.ρ g) v
tactic: ext g v
state_before: case h.h
k G : Type u
inst✝¹ : Field k
inst✝ : Monoid G
V : FDRep k G
g : G
v : CoeSort.coe ((forget₂ (FDRep k G) (Rep k G)).obj V)
⊢ (((forget₂ (FDRep k G) (Rep k G)).obj V).ρ g) v = (V.ρ g) v
state_after: no goals
tactic: rfl
Theorem: FiniteField.isSquare_iff
File: Mathlib/FieldTheory/Finite/Basic.lean

Proof steps:
state_before: K : Type u_1
R : Type u_2
F : Type u_3
inst✝¹ : Field F
inst✝ : Fintype F
hF : ringChar F ≠ 2
a : F
ha : a ≠ 0
⊢ IsSquare a ↔ a ^ (Fintype.card F / 2) = 1
state_after: K : Type u_1
R : Type u_2
F : Type u_3
inst✝¹ : Field F
inst✝ : Fintype F
hF : ringChar F ≠ 2
a : F
ha : a ≠ 0
⊢ IsSquare (Units.mk0 a ha) ↔ IsSquare a
tactic: apply
    (iff_congr _ (by simp [Units.ext_iff])).mp (FiniteField.unit_isSquare_iff hF (Units.mk0 a ha))
state_before: K : Type u_1
R : Type u_2
F : Type u_3
inst✝¹ : Field F
inst✝ : Fintype F
hF : ringChar F ≠ 2
a : F
ha : a ≠ 0
⊢ IsSquare (Units.mk0 a ha) ↔ IsSquare a
state_after: K : Type u_1
R : Type u_2
F : Type u_3
inst✝¹ : Field F
inst✝ : Fintype F
hF : ringChar F ≠ 2
a : F
ha : a ≠ 0
⊢ (∃ r, a = ↑r * ↑r) ↔ ∃ r, a = r * r
tactic: simp only [IsSquare, Units.ext_iff, Units.val_mk0, Units.val_mul]
state_before: K : Type u_1
R : Type u_2
F : Type u_3
inst✝¹ : Field F
inst✝ : Fintype F
hF : ringChar F ≠ 2
a : F
ha : a ≠ 0
⊢ (∃ r, a = ↑r * ↑r) ↔ ∃ r, a = r * r
state_after: case mp
K : Type u_1
R : Type u_2
F : Type u_3
inst✝¹ : Field F
inst✝ : Fintype F
hF : ringChar F ≠ 2
a : F
ha : a ≠ 0
⊢ (∃ r, a = ↑r * ↑r) → ∃ r, a = r * r

case mpr
K : Type u_1
R : Type u_2
F : Type u_3
inst✝¹ : Field F
inst✝ : Fintype F
hF : ringChar F ≠ 2
a : F
ha : a ≠ 0
⊢ (∃ r, a = r * r) → ∃ r, a = ↑r * ↑r
tactic: constructor
Theorem: AlgebraicGeometry.StructureSheaf.toPushforwardStalk_comp
File: Mathlib/AlgebraicGeometry/Spec.lean

Proof steps:
state_before: R S : CommRingCat
f : R ⟶ S
p : PrimeSpectrum ↑R
⊢ f ≫ toPushforwardStalk f p =
    toStalk (↑R) p ≫ (TopCat.Presheaf.stalkFunctor CommRingCat p).map (Spec.sheafedSpaceMap f).c
state_after: R S : CommRingCat
f : R ⟶ S
p : PrimeSpectrum ↑R
⊢ f ≫ toPushforwardStalk f p =
    (toOpen ↑R ⊤ ≫ (structureSheaf ↑R).presheaf.germ ⟨p, True.intro⟩) ≫
      (TopCat.Presheaf.stalkFunctor CommRingCat p).map (Spec.sheafedSpaceMap f).c
tactic: rw [StructureSheaf.toStalk]
state_before: R S : CommRingCat
f : R ⟶ S
p : PrimeSpectrum ↑R
⊢ f ≫ toPushforwardStalk f p =
    (toOpen ↑R ⊤ ≫ (structureSheaf ↑R).presheaf.germ ⟨p, True.intro⟩) ≫
      (TopCat.Presheaf.stalkFunctor CommRingCat p).map (Spec.sheafedSpaceMap f).c
state_after: R S : CommRingCat
f : R ⟶ S
p : PrimeSpectrum ↑R
⊢ f ≫ toPushforwardStalk f p =
    toOpen ↑R ⊤ ≫
      (structureSheaf ↑R).presheaf.germ ⟨p, True.intro⟩ ≫
        (TopCat.Presheaf.stalkFunctor CommRingCat p).map (Spec.sheafedSpaceMap f).c
tactic: erw [Category.assoc]
state_before: R S : CommRingCat
f : R ⟶ S
p : PrimeSpectrum ↑R
⊢ f ≫ toPushforwardStalk f p =
    toOpen ↑R ⊤ ≫
      (structureSheaf ↑R).presheaf.germ ⟨p, True.intro⟩ ≫
        (TopCat.Presheaf.stalkFunctor CommRingCat p).map (Spec.sheafedSpaceMap f).c
state_after: R S : CommRingCat
f : R ⟶ S
p : PrimeSpectrum ↑R
⊢ f ≫ toPushforwardStalk f p =
    toOpen ↑R ⊤ ≫
      (Spec.sheafedSpaceMap f).c.app (op ⊤) ≫
        ((TopCat.Presheaf.pushforward CommRingCat (Spec.sheafedSpaceMap f).base).obj
              (Spec.sheafedSpaceObj S).presheaf).germ
          ⟨p, True.intro⟩
tactic: rw [TopCat.Presheaf.stalkFunctor_map_germ]
state_before: R S : CommRingCat
f : R ⟶ S
p : PrimeSpectrum ↑R
⊢ f ≫ toPushforwardStalk f p =
    toOpen ↑R ⊤ ≫
      (Spec.sheafedSpaceMap f).c.app (op ⊤) ≫
        ((TopCat.Presheaf.pushforward CommRingCat (Spec.sheafedSpaceMap f).base).obj
              (Spec.sheafedSpaceObj S).presheaf).germ
          ⟨p, True.intro⟩
state_after: no goals
tactic: exact Spec_Γ_naturality_assoc f _
Theorem: orthogonalProjection_eq_linear_proj
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
x : E
⊢ (orthogonalProjection K) x = (K.linearProjOfIsCompl Kᗮ ⋯) x
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
x : E
this : IsCompl K Kᗮ
⊢ (orthogonalProjection K) x = (K.linearProjOfIsCompl Kᗮ ⋯) x
tactic: have : IsCompl K Kᗮ := Submodule.isCompl_orthogonal_of_completeSpace
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
x : E
this : IsCompl K Kᗮ
⊢ (orthogonalProjection K) x = (K.linearProjOfIsCompl Kᗮ ⋯) x
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
x : E
this : IsCompl K Kᗮ
⊢ (orthogonalProjection K) (↑((K.linearProjOfIsCompl Kᗮ this) x) + ↑((Kᗮ.linearProjOfIsCompl K ⋯) x)) =
    (K.linearProjOfIsCompl Kᗮ ⋯) x
tactic: conv_lhs => rw [← Submodule.linear_proj_add_linearProjOfIsCompl_eq_self this x]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁵ : _root_.RCLike 𝕜
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedAddCommGroup F
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
inst✝ : HasOrthogonalProjection K
x : E
this : IsCompl K Kᗮ
⊢ (orthogonalProjection K) (↑((K.linearProjOfIsCompl Kᗮ this) x) + ↑((Kᗮ.linearProjOfIsCompl K ⋯) x)) =
    (K.linearProjOfIsCompl Kᗮ ⋯) x
state_after: no goals
tactic: rw [map_add, orthogonalProjection_mem_subspace_eq_self,
    orthogonalProjection_mem_subspace_orthogonalComplement_eq_zero (Submodule.coe_mem _), add_zero]
Theorem: partialFunToPointed_obj
File: Mathlib/CategoryTheory/Category/PartialFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
⊢ PartialFun ⥤ Pointed
state_after: no goals
tactic: classical
  exact
    { obj := fun X => ⟨Option X, none⟩
      map := fun f => ⟨Option.elim' none fun a => (f a).toOption, rfl⟩
      map_id := fun X => Pointed.Hom.ext _ _ <| funext fun o => Option.recOn o rfl fun a => (by
        dsimp [CategoryStruct.id]
        convert Part.some_toOption a)
      map_comp := fun f g => Pointed.Hom.ext _ _ <| funext fun o => Option.recOn o rfl fun a => by
        dsimp [CategoryStruct.comp]
        rw [Part.bind_toOption g (f a), Option.elim'_eq_elim] }
Theorem: CategoryTheory.SingleObj.differenceFunctor_map
File: Mathlib/CategoryTheory/SingleObj.lean

Proof steps:
state_before: M G : Type u
inst✝³ : Monoid M
inst✝² : Group G
N : Type v
inst✝¹ : Monoid N
C : Type v
inst✝ : Category.{w, v} C
f : C → G
⊢ ∀ (X : C),
    { obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.map (𝟙 X) =
      𝟙 ({ obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.obj X)
state_after: M G : Type u
inst✝³ : Monoid M
inst✝² : Group G
N : Type v
inst✝¹ : Monoid N
C : Type v
inst✝ : Category.{w, v} C
f : C → G
X✝ : C
⊢ { obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.map (𝟙 X✝) =
    𝟙 ({ obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.obj X✝)
tactic: intro
state_before: M G : Type u
inst✝³ : Monoid M
inst✝² : Group G
N : Type v
inst✝¹ : Monoid N
C : Type v
inst✝ : Category.{w, v} C
f : C → G
X✝ : C
⊢ { obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.map (𝟙 X✝) =
    𝟙 ({ obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.obj X✝)
state_after: no goals
tactic: simp only [SingleObj.id_as_one, mul_right_inv]
state_before: M G : Type u
inst✝³ : Monoid M
inst✝² : Group G
N : Type v
inst✝¹ : Monoid N
C : Type v
inst✝ : Category.{w, v} C
f : C → G
⊢ ∀ {X Y Z : C} (f_1 : X ⟶ Y) (g : Y ⟶ Z),
    { obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.map (f_1 ≫ g) =
      { obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.map f_1 ≫
        { obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.map g
state_after: M G : Type u
inst✝³ : Monoid M
inst✝² : Group G
N : Type v
inst✝¹ : Monoid N
C : Type v
inst✝ : Category.{w, v} C
f : C → G
X✝ Y✝ Z✝ : C
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
⊢ { obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.map (f✝ ≫ g✝) =
    { obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.map f✝ ≫
      { obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.map g✝
tactic: intros
state_before: M G : Type u
inst✝³ : Monoid M
inst✝² : Group G
N : Type v
inst✝¹ : Monoid N
C : Type v
inst✝ : Category.{w, v} C
f : C → G
X✝ Y✝ Z✝ : C
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
⊢ { obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.map (f✝ ≫ g✝) =
    { obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.map f✝ ≫
      { obj := fun x => (), map := fun {x y} x_1 => f y * (f x)⁻¹ }.map g✝
state_after: M G : Type u
inst✝³ : Monoid M
inst✝² : Group G
N : Type v
inst✝¹ : Monoid N
C : Type v
inst✝ : Category.{w, v} C
f : C → G
X✝ Y✝ Z✝ : C
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
⊢ f Z✝ * (f X✝)⁻¹ = (f Y✝ * (f X✝)⁻¹) ≫ (f Z✝ * (f Y✝)⁻¹)
tactic: dsimp
state_before: M G : Type u
inst✝³ : Monoid M
inst✝² : Group G
N : Type v
inst✝¹ : Monoid N
C : Type v
inst✝ : Category.{w, v} C
f : C → G
X✝ Y✝ Z✝ : C
f✝ : X✝ ⟶ Y✝
g✝ : Y✝ ⟶ Z✝
⊢ f Z✝ * (f X✝)⁻¹ = (f Y✝ * (f X✝)⁻¹) ≫ (f Z✝ * (f Y✝)⁻¹)
state_after: no goals
tactic: rw [SingleObj.comp_as_mul, ← mul_assoc, mul_left_inj, mul_assoc, inv_mul_self, mul_one]
Theorem: UniformSpace.toCore_toTopologicalSpace
File: Mathlib/Topology/UniformSpace/Basic.lean

Proof steps:
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
u : UniformSpace α
a : α
⊢ 𝓝 a = 𝓝 a
state_after: no goals
tactic: rw [u.nhds_eq_comap_uniformity, u.toCore.nhds_toTopologicalSpace]
Theorem: List.inits_reverse
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ l.reverse.inits = (map reverse l.tails).reverse
state_after: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ l.reverse.inits = (map reverse (map reverse l.reverse.inits).reverse).reverse
tactic: rw [tails_eq_inits l]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m n : ℕ
l : List α
⊢ l.reverse.inits = (map reverse (map reverse l.reverse.inits).reverse).reverse
state_after: no goals
tactic: simp [reverse_involutive.comp_self, ← map_reverse]
Theorem: Finset.Ico_subset_Iio_self
File: Mathlib/Order/Interval/Finset/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
inst✝² : Preorder α
inst✝¹ : LocallyFiniteOrder α
a a₁ a₂ b b₁ b₂ c x : α
inst✝ : LocallyFiniteOrderBot α
⊢ Ico a b ⊆ Iio b
state_after: no goals
tactic: simpa [← coe_subset] using Set.Ico_subset_Iio_self
Theorem: AlgebraicTopology.DoldKan.N₂Γ₂_inv_app_f_f
File: Mathlib/AlgebraicTopology/DoldKan/GammaCompN.lean

Proof steps:
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : Karoubi (ChainComplex C ℕ)
n : ℕ
⊢ (N₂Γ₂.inv.app X).f.f n = X.p.f n ≫ ((Γ₀.splitting X.X).cofan (op [n])).inj (Splitting.IndexSet.id (op [n]))
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : Karoubi (ChainComplex C ℕ)
n : ℕ
⊢ ((((whiskeringLeft (ChainComplex C ℕ) (Karoubi (ChainComplex C ℕ)) (Karoubi (ChainComplex C ℕ))).obj
                    (toKaroubi (ChainComplex C ℕ))).preimage
                (N₁Γ₀.inv ≫ N₂Γ₂ToKaroubiIso.inv)).app
            X).f.f
      n =
    X.p.f n ≫ ((Γ₀.splitting X.X).cofan (op [n])).inj (Splitting.IndexSet.id (op [n]))
tactic: dsimp [N₂Γ₂]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : Karoubi (ChainComplex C ℕ)
n : ℕ
⊢ ((((whiskeringLeft (ChainComplex C ℕ) (Karoubi (ChainComplex C ℕ)) (Karoubi (ChainComplex C ℕ))).obj
                    (toKaroubi (ChainComplex C ℕ))).preimage
                (N₁Γ₀.inv ≫ N₂Γ₂ToKaroubiIso.inv)).app
            X).f.f
      n =
    X.p.f n ≫ ((Γ₀.splitting X.X).cofan (op [n])).inj (Splitting.IndexSet.id (op [n]))
state_after: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : Karoubi (ChainComplex C ℕ)
n : ℕ
⊢ ((𝟭 (Karoubi (ChainComplex C ℕ))).map X.decompId_i).f.f n ≫
      X.p.f n ≫ ((Γ₀.splitting X.X).cofan (op [n])).inj (Splitting.IndexSet.id (op [n])) =
    X.p.f n ≫ ((Γ₀.splitting X.X).cofan (op [n])).inj (Splitting.IndexSet.id (op [n]))
tactic: simp only [whiskeringLeft_obj_preimage_app, NatTrans.comp_app, Functor.comp_map,
    Karoubi.comp_f, N₂Γ₂ToKaroubiIso_inv_app, HomologicalComplex.comp_f,
    N₁Γ₀_inv_app_f_f, toKaroubi_obj_X, Splitting.toKaroubiNondegComplexIsoN₁_hom_f_f,
    Γ₀.obj_obj, PInfty_on_Γ₀_splitting_summand_eq_self, N₂_map_f_f,
    Γ₂_map_f_app, unop_op, Karoubi.decompId_p_f, PInfty_f_idem_assoc,
    PInfty_on_Γ₀_splitting_summand_eq_self_assoc, Splitting.IndexSet.id_fst, SimplexCategory.len_mk,
    Splitting.ι_desc]
state_before: C : Type u_1
inst✝² : Category.{u_2, u_1} C
inst✝¹ : Preadditive C
inst✝ : HasFiniteCoproducts C
X : Karoubi (ChainComplex C ℕ)
n : ℕ
⊢ ((𝟭 (Karoubi (ChainComplex C ℕ))).map X.decompId_i).f.f n ≫
      X.p.f n ≫ ((Γ₀.splitting X.X).cofan (op [n])).inj (Splitting.IndexSet.id (op [n])) =
    X.p.f n ≫ ((Γ₀.splitting X.X).cofan (op [n])).inj (Splitting.IndexSet.id (op [n]))
state_after: no goals
tactic: apply Karoubi.HomologicalComplex.p_idem_assoc
Theorem: intrinsicInterior_union_intrinsicFrontier
File: Mathlib/Analysis/Convex/Intrinsic.lean

Proof steps:
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s✝ t : Set P
x : P
s : Set P
⊢ intrinsicInterior 𝕜 s ∪ intrinsicFrontier 𝕜 s = intrinsicClosure 𝕜 s
state_after: no goals
tactic: simp [intrinsicClosure, intrinsicInterior, intrinsicFrontier, closure_eq_interior_union_frontier,
    image_union]
Theorem: NormedAddGroupHom.ext_iff
File: Mathlib/Analysis/Normed/Group/Hom.lean

Proof steps:
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f g : NormedAddGroupHom V₁ V₂
⊢ f = g → ∀ (x : V₁), f x = g x
state_after: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
x : V₁
⊢ f x = f x
tactic: rintro rfl x
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f : NormedAddGroupHom V₁ V₂
x : V₁
⊢ f x = f x
state_after: no goals
tactic: rfl
Theorem: IsCompact.nonempty_sInter_of_directed_nonempty_isCompact_isClosed
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
S : Set (Set X)
hS : Nonempty ↑S
hSd : DirectedOn (fun x x_1 => x ⊇ x_1) S
hSn : ∀ U ∈ S, U.Nonempty
hSc : ∀ U ∈ S, IsCompact U
hScl : ∀ U ∈ S, IsClosed U
⊢ (⋂₀ S).Nonempty
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
S : Set (Set X)
hS : Nonempty ↑S
hSd : DirectedOn (fun x x_1 => x ⊇ x_1) S
hSn : ∀ U ∈ S, U.Nonempty
hSc : ∀ U ∈ S, IsCompact U
hScl : ∀ U ∈ S, IsClosed U
⊢ (⋂ i, ↑i).Nonempty
tactic: rw [sInter_eq_iInter]
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
S : Set (Set X)
hS : Nonempty ↑S
hSd : DirectedOn (fun x x_1 => x ⊇ x_1) S
hSn : ∀ U ∈ S, U.Nonempty
hSc : ∀ U ∈ S, IsCompact U
hScl : ∀ U ∈ S, IsClosed U
⊢ (⋂ i, ↑i).Nonempty
state_after: no goals
tactic: exact IsCompact.nonempty_iInter_of_directed_nonempty_isCompact_isClosed _
    (DirectedOn.directed_val hSd) (fun i ↦ hSn i i.2) (fun i ↦ hSc i i.2) (fun i ↦ hScl i i.2)
Theorem: Filter.comap_cocompact_le
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
f : X → Y
hf : Continuous f
⊢ comap f (cocompact Y) ≤ cocompact X
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
hf : Continuous f
⊢ ∀ (i' : Set X), IsCompact i' → ∃ i, IsCompact i ∧ f ⁻¹' iᶜ ⊆ i'ᶜ
tactic: rw [(Filter.hasBasis_cocompact.comap f).le_basis_iff Filter.hasBasis_cocompact]
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
f : X → Y
hf : Continuous f
⊢ ∀ (i' : Set X), IsCompact i' → ∃ i, IsCompact i ∧ f ⁻¹' iᶜ ⊆ i'ᶜ
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
f : X → Y
hf : Continuous f
t : Set X
ht : IsCompact t
⊢ ∃ i, IsCompact i ∧ f ⁻¹' iᶜ ⊆ tᶜ
tactic: intro t ht
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
f : X → Y
hf : Continuous f
t : Set X
ht : IsCompact t
⊢ ∃ i, IsCompact i ∧ f ⁻¹' iᶜ ⊆ tᶜ
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
f : X → Y
hf : Continuous f
t : Set X
ht : IsCompact t
⊢ f ⁻¹' (f '' t)ᶜ ⊆ tᶜ
tactic: refine ⟨f '' t, ht.image hf, ?_⟩
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t✝ : Set X
f : X → Y
hf : Continuous f
t : Set X
ht : IsCompact t
⊢ f ⁻¹' (f '' t)ᶜ ⊆ tᶜ
state_after: no goals
tactic: simpa using t.subset_preimage_image f
Theorem: Int.ceil_eq_zero_iff
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a : α
⊢ ⌈a⌉ = 0 ↔ a ∈ Ioc (-1) 0
state_after: no goals
tactic: simp [ceil_eq_iff]
Theorem: Nat.image_cast_int_Icc
File: Mathlib/Data/Nat/Cast/SetInterval.lean

Proof steps:
state_before: a b : ℕ
⊢ (range ⇑castOrderEmbedding).OrdConnected
state_after: no goals
tactic: simp [ordConnected_Ici]
Theorem: RightDerivMeasurableAux.norm_sub_le_of_mem_A
File: Mathlib/Analysis/Calculus/FDeriv/Measurable.lean

Proof steps:
state_before: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
r x : ℝ
hr : 0 < r
ε : ℝ
L₁ L₂ : F
h₁ : x ∈ A f L₁ r ε
h₂ : x ∈ A f L₂ r ε
⊢ ‖L₁ - L₂‖ ≤ 4 * ε
state_after: F : Type u_1
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
f : ℝ → F
K : Set F
r x : ℝ
hr : 0 < r
ε : ℝ
L₁ L₂ : F
h₁ : x ∈ A f L₁ r ε
h₂ : x ∈ A f L₂ r ε
⊢ ‖(r / 2) • (L₁ - L₂)‖ ≤ r / 2 * (4 * ε)
tactic: suffices H : ‖(r / 2) • (L₁ - L₂)‖ ≤ r / 2 * (4 * ε) by
    rwa [norm_smul, Real.norm_of_nonneg (half_pos hr).le, mul_le_mul_left (half_pos hr)] at H
Theorem: HurwitzZeta.sinKernel_zero
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: x : ℝ
⊢ sinKernel 0 x = 0
state_after: no goals
tactic: simpa only [neg_zero, eq_neg_self_iff] using sinKernel_neg 0 x