ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.Limits.WidePushout.hom_eq_desc
File: Mathlib/CategoryTheory/Limits/Shapes/WidePullbacks.lean

Proof steps:
state_before: J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : C
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B objs arrows ⟶ X
j : J
⊢ arrows j ≫ (fun j => ι arrows j ≫ g) j = head arrows ≫ g
state_after: J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : C
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B objs arrows ⟶ X
j : J
⊢ (arrows j ≫ ι arrows j) ≫ g = head arrows ≫ g
tactic: rw [← Category.assoc]
state_before: J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : C
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B objs arrows ⟶ X
j : J
⊢ (arrows j ≫ ι arrows j) ≫ g = head arrows ≫ g
state_after: no goals
tactic: simp
state_before: J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : C
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B objs arrows ⟶ X
⊢ g = desc (head arrows ≫ g) (fun j => ι arrows j ≫ g) ⋯
state_after: case a
J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : C
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B objs arrows ⟶ X
⊢ ∀ (j : J), ι arrows j ≫ g = ι arrows j ≫ g

case a
J : Type w
C✝ : Type u
inst✝² : Category.{v, u} C✝
C : Type u
inst✝¹ : Category.{v, u} C
B : C
objs : J → C
arrows : (j : J) → B ⟶ objs j
inst✝ : HasWidePushout B objs arrows
X : C
f : B ⟶ X
fs : (j : J) → objs j ⟶ X
w : ∀ (j : J), arrows j ≫ fs j = f
g : widePushout B objs arrows ⟶ X
⊢ head arrows ≫ g = head arrows ≫ g
tactic: apply eq_desc_of_comp_eq
Theorem: LatticeHom.withTopWithBot_id
File: Mathlib/Order/Hom/Lattice.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
⊢ (fun f => ⇑f) (LatticeHom.id α).withTopWithBot = (fun f => ⇑f) (BoundedLatticeHom.id (WithTop (WithBot α)))
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
⊢ ⇑(LatticeHom.id α).withBot.toSupHom = id
tactic: refine (congr_arg Option.map ?_).trans Option.map_id
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
⊢ ⇑(LatticeHom.id α).withBot.toSupHom = id
state_after: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
⊢ ⇑(LatticeHom.id (WithBot α)).toSupHom = id
tactic: rw [withBot_id]
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
δ : Type u_6
inst✝³ : FunLike F α β
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
⊢ ⇑(LatticeHom.id (WithBot α)).toSupHom = id
state_after: no goals
tactic: rfl
Theorem: FreeAddGroup.Red.Step.append_left_iff
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
⊢ Step ([] ++ L₁) ([] ++ L₂) ↔ Step L₁ L₂
state_after: no goals
tactic: simp
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
p : α × Bool
l : List (α × Bool)
⊢ Step (p :: l ++ L₁) (p :: l ++ L₂) ↔ Step L₁ L₂
state_after: no goals
tactic: simp [Step.append_left_iff l, Step.cons_cons_iff]
Theorem: Multiset.prod_replicate
File: Mathlib/Algebra/BigOperators/Group/Multiset.lean

Proof steps:
state_before: F : Type u_1
ι : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝¹ : CommMonoid α
inst✝ : CommMonoid β
s t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
n : ℕ
a : α
⊢ (replicate n a).prod = a ^ n
state_after: no goals
tactic: simp [replicate, List.prod_replicate]
Theorem: MeasureTheory.tilted_zero_measure
File: Mathlib/MeasureTheory/Measure/Tilted.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f✝ f : α → ℝ
⊢ Measure.tilted 0 f = 0
state_after: no goals
tactic: simp [Measure.tilted]
Theorem: Monoid.CoprodI.Word.fstIdx_ne_iff
File: Mathlib/GroupTheory/CoprodI.lean

Proof steps:
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type u_3
inst✝ : Monoid N
w : Word M
i : ι
⊢ ¬w.fstIdx ≠ some i ↔ ¬∀ l ∈ w.toList.head?, i ≠ l.fst
state_after: no goals
tactic: simp [fstIdx]
Theorem: ProbabilityTheory.Kernel.lintegral_comp
File: Mathlib/Probability/Kernel/Composition.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
γ : Type u_4
mγ : MeasurableSpace γ
f : β → γ
g✝ : γ → α
η : Kernel β γ
κ : Kernel α β
a : α
g : γ → ℝ≥0∞
hg : Measurable g
⊢ ∫⁻ (c : γ), g c ∂(η ∘ₖ κ) a = ∫⁻ (b : β), ∫⁻ (c : γ), g c ∂η b ∂κ a
state_after: no goals
tactic: rw [comp_apply, Measure.lintegral_bind (Kernel.measurable _) hg]
Theorem: abs_nonneg
File: Mathlib/Algebra/Order/Group/Unbundled/Abs.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : Lattice α
inst✝² : Group α
a✝ b : α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ 1 ≤ mabs a
state_after: α : Type u_1
inst✝³ : Lattice α
inst✝² : Group α
a✝ b : α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ 1 ≤ mabs a ^ 2
tactic: apply pow_two_semiclosed _
state_before: α : Type u_1
inst✝³ : Lattice α
inst✝² : Group α
a✝ b : α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ 1 ≤ mabs a ^ 2
state_after: α : Type u_1
inst✝³ : Lattice α
inst✝² : Group α
a✝ b : α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ 1 ≤ (a ⊔ a⁻¹) * a⁻¹ ⊔ a ^ 2 ⊔ 1
tactic: rw [mabs, pow_two, mul_sup,  sup_mul, ← pow_two, mul_left_inv, sup_comm, ← sup_assoc]
state_before: α : Type u_1
inst✝³ : Lattice α
inst✝² : Group α
a✝ b : α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ 1 ≤ (a ⊔ a⁻¹) * a⁻¹ ⊔ a ^ 2 ⊔ 1
state_after: no goals
tactic: apply le_sup_right
Theorem: AddMonoidAlgebra.mul_of'_divOf
File: Mathlib/Algebra/MonoidAlgebra/Division.lean

Proof steps:
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : k[G]
a : G
⊢ x * of' k G a /ᵒᶠ a = x
state_after: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : k[G]
a x✝ : G
⊢ (x * of' k G a /ᵒᶠ a) x✝ = x x✝
tactic: refine Finsupp.ext fun _ => ?_
state_before: k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : k[G]
a x✝ : G
⊢ (x * of' k G a /ᵒᶠ a) x✝ = x x✝
state_after: case H
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : k[G]
a x✝ : G
⊢ ∀ (a_1 : G), a_1 + a = a + x✝ ↔ a_1 = x✝
tactic: rw [AddMonoidAlgebra.divOf_apply, of'_apply, mul_single_apply_aux, mul_one]
state_before: case H
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : k[G]
a x✝ : G
⊢ ∀ (a_1 : G), a_1 + a = a + x✝ ↔ a_1 = x✝
state_after: case H
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : k[G]
a x✝ c : G
⊢ c + a = a + x✝ ↔ c = x✝
tactic: intro c
state_before: case H
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : k[G]
a x✝ c : G
⊢ c + a = a + x✝ ↔ c = x✝
state_after: case H
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : k[G]
a x✝ c : G
⊢ a + c = a + x✝ ↔ c = x✝
tactic: rw [add_comm]
state_before: case H
k : Type u_1
G : Type u_2
inst✝¹ : Semiring k
inst✝ : AddCancelCommMonoid G
x : k[G]
a x✝ c : G
⊢ a + c = a + x✝ ↔ c = x✝
state_after: no goals
tactic: exact add_right_inj _
Theorem: IsScalarTower.algebraMap_apply
File: Mathlib/Algebra/Algebra/Tower.lean

Proof steps:
state_before: R : Type u
S : Type v
A : Type w
B : Type u₁
M : Type v₁
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring S
inst✝⁸ : Semiring A
inst✝⁷ : Semiring B
inst✝⁶ : Algebra R S
inst✝⁵ : Algebra S A
inst✝⁴ : Algebra S B
inst✝³ : Algebra R A
inst✝² : Algebra R B
inst✝¹ : IsScalarTower R S A
inst✝ : IsScalarTower R S B
x : R
⊢ (algebraMap R A) x = (algebraMap S A) ((algebraMap R S) x)
state_after: no goals
tactic: rw [algebraMap_eq R S A, RingHom.comp_apply]
Theorem: CategoryTheory.MorphismProperty.LeftFraction.map_eq_of_map_eq
File: Mathlib/CategoryTheory/Localization/CalculusOfFractions.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_4, u_1} C
inst✝⁴ : Category.{u_6, u_2} D
W : MorphismProperty C
inst✝³ : W.HasLeftCalculusOfFractions
X Y : C
φ₁ φ₂ : W.LeftFraction X Y
E : Type u_3
inst✝² : Category.{u_5, u_3} E
L₁ : C ⥤ D
L₂ : C ⥤ E
inst✝¹ : L₁.IsLocalization W
inst✝ : L₂.IsLocalization W
h : φ₁.map L₁ ⋯ = φ₂.map L₁ ⋯
⊢ φ₁.map L₂ ⋯ = φ₂.map L₂ ⋯
state_after: case a
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_4, u_1} C
inst✝⁴ : Category.{u_6, u_2} D
W : MorphismProperty C
inst✝³ : W.HasLeftCalculusOfFractions
X Y : C
φ₁ φ₂ : W.LeftFraction X Y
E : Type u_3
inst✝² : Category.{u_5, u_3} E
L₁ : C ⥤ D
L₂ : C ⥤ E
inst✝¹ : L₁.IsLocalization W
inst✝ : L₂.IsLocalization W
h : φ₁.map L₁ ⋯ = φ₂.map L₁ ⋯
⊢ (Localization.uniq L₂ L₁ W).functor.map (φ₁.map L₂ ⋯) = (Localization.uniq L₂ L₁ W).functor.map (φ₂.map L₂ ⋯)
tactic: apply (Localization.uniq L₂ L₁ W).functor.map_injective
state_before: case a
C : Type u_1
D : Type u_2
inst✝⁵ : Category.{u_4, u_1} C
inst✝⁴ : Category.{u_6, u_2} D
W : MorphismProperty C
inst✝³ : W.HasLeftCalculusOfFractions
X Y : C
φ₁ φ₂ : W.LeftFraction X Y
E : Type u_3
inst✝² : Category.{u_5, u_3} E
L₁ : C ⥤ D
L₂ : C ⥤ E
inst✝¹ : L₁.IsLocalization W
inst✝ : L₂.IsLocalization W
h : φ₁.map L₁ ⋯ = φ₂.map L₁ ⋯
⊢ (Localization.uniq L₂ L₁ W).functor.map (φ₁.map L₂ ⋯) = (Localization.uniq L₂ L₁ W).functor.map (φ₂.map L₂ ⋯)
state_after: no goals
tactic: rw [map_compatibility φ₁ L₂ L₁, map_compatibility φ₂ L₂ L₁, h]
Theorem: LieIdeal.idealizer_eq_normalizer
File: Mathlib/Algebra/Lie/Normalizer.lean

Proof steps:
state_before: R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
I : LieIdeal R L
⊢ idealizer I = normalizer I
state_after: case h
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
I : LieIdeal R L
x : L
⊢ x ∈ idealizer I ↔ x ∈ normalizer I
tactic: ext x
state_before: case h
R : Type u_1
L : Type u_2
M : Type u_3
M' : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
N N₁ N₂ : LieSubmodule R L M
I : LieIdeal R L
x : L
⊢ x ∈ idealizer I ↔ x ∈ normalizer I
state_after: no goals
tactic: exact forall_congr' fun y ↦ by simp only [← lie_skew x y, neg_mem_iff]
Theorem: fourierSubalgebra_separatesPoints
File: Mathlib/Analysis/Fourier/AddCircle.lean

Proof steps:
state_before: T : ℝ
hT : Fact (0 < T)
⊢ fourierSubalgebra.SeparatesPoints
state_after: T : ℝ
hT : Fact (0 < T)
x y : AddCircle T
hxy : x ≠ y
⊢ ∃ f ∈ (fun f => ⇑f) '' ↑fourierSubalgebra.toSubalgebra, f x ≠ f y
tactic: intro x y hxy
state_before: T : ℝ
hT : Fact (0 < T)
x y : AddCircle T
hxy : x ≠ y
⊢ ∃ f ∈ (fun f => ⇑f) '' ↑fourierSubalgebra.toSubalgebra, f x ≠ f y
state_after: T : ℝ
hT : Fact (0 < T)
x y : AddCircle T
hxy : x ≠ y
⊢ (fun f => ⇑f) (fourier 1) x ≠ (fun f => ⇑f) (fourier 1) y
tactic: refine ⟨_, ⟨fourier 1, subset_adjoin ⟨1, rfl⟩, rfl⟩, ?_⟩
state_before: T : ℝ
hT : Fact (0 < T)
x y : AddCircle T
hxy : x ≠ y
⊢ (fun f => ⇑f) (fourier 1) x ≠ (fun f => ⇑f) (fourier 1) y
state_after: T : ℝ
hT : Fact (0 < T)
x y : AddCircle T
hxy : x ≠ y
⊢ (fourier 1) x ≠ (fourier 1) y
tactic: dsimp only
state_before: T : ℝ
hT : Fact (0 < T)
x y : AddCircle T
hxy : x ≠ y
⊢ (fourier 1) x ≠ (fourier 1) y
state_after: T : ℝ
hT : Fact (0 < T)
x y : AddCircle T
hxy : x ≠ y
⊢ ↑x.toCircle ≠ ↑y.toCircle
tactic: rw [fourier_one, fourier_one]
state_before: T : ℝ
hT : Fact (0 < T)
x y : AddCircle T
hxy : x ≠ y
⊢ ↑x.toCircle ≠ ↑y.toCircle
state_after: T : ℝ
hT : Fact (0 < T)
x y : AddCircle T
hxy : ↑x.toCircle = ↑y.toCircle
⊢ x = y
tactic: contrapose! hxy
state_before: T : ℝ
hT : Fact (0 < T)
x y : AddCircle T
hxy : ↑x.toCircle = ↑y.toCircle
⊢ x = y
state_after: T : ℝ
hT : Fact (0 < T)
x y : AddCircle T
hxy : x.toCircle = y.toCircle
⊢ x = y
tactic: rw [Subtype.coe_inj] at hxy
state_before: T : ℝ
hT : Fact (0 < T)
x y : AddCircle T
hxy : x.toCircle = y.toCircle
⊢ x = y
state_after: no goals
tactic: exact injective_toCircle hT.elim.ne' hxy
Theorem: BoundedContinuousFunction.exists_extension_forall_mem_Icc_of_closedEmbedding
File: Mathlib/Topology/TietzeExtension.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : NormalSpace Y
f : X →ᵇ ℝ
a b : ℝ
e : X → Y
hf : ∀ (x : X), f x ∈ Icc a b
hle : a ≤ b
he : ClosedEmbedding e
⊢ ∃ g, (∀ (y : Y), g y ∈ Icc a b) ∧ ⇑g ∘ e = ⇑f
state_after: case intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : NormalSpace Y
f : X →ᵇ ℝ
a b : ℝ
e : X → Y
hf : ∀ (x : X), f x ∈ Icc a b
hle : a ≤ b
he : ClosedEmbedding e
g : Y →ᵇ ℝ
hgf : ‖g‖ = ‖f - const X ((a + b) / 2)‖
hge : ⇑g ∘ e = ⇑(f - const X ((a + b) / 2))
⊢ ∃ g, (∀ (y : Y), g y ∈ Icc a b) ∧ ⇑g ∘ e = ⇑f
tactic: rcases exists_extension_norm_eq_of_closedEmbedding (f - const X ((a + b) / 2)) he with
    ⟨g, hgf, hge⟩
state_before: case intro.intro
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : NormalSpace Y
f : X →ᵇ ℝ
a b : ℝ
e : X → Y
hf : ∀ (x : X), f x ∈ Icc a b
hle : a ≤ b
he : ClosedEmbedding e
g : Y →ᵇ ℝ
hgf : ‖g‖ = ‖f - const X ((a + b) / 2)‖
hge : ⇑g ∘ e = ⇑(f - const X ((a + b) / 2))
⊢ ∃ g, (∀ (y : Y), g y ∈ Icc a b) ∧ ⇑g ∘ e = ⇑f
state_after: case intro.intro.refine_1
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : NormalSpace Y
f : X →ᵇ ℝ
a b : ℝ
e : X → Y
hf : ∀ (x : X), f x ∈ Icc a b
hle : a ≤ b
he : ClosedEmbedding e
g : Y →ᵇ ℝ
hgf : ‖g‖ = ‖f - const X ((a + b) / 2)‖
hge : ⇑g ∘ e = ⇑(f - const X ((a + b) / 2))
y : Y
⊢ (const Y ((a + b) / 2) + g) y ∈ Icc a b

case intro.intro.refine_2
X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : NormalSpace Y
f : X →ᵇ ℝ
a b : ℝ
e : X → Y
hf : ∀ (x : X), f x ∈ Icc a b
hle : a ≤ b
he : ClosedEmbedding e
g : Y →ᵇ ℝ
hgf : ‖g‖ = ‖f - const X ((a + b) / 2)‖
hge : ⇑g ∘ e = ⇑(f - const X ((a + b) / 2))
⊢ ⇑(const Y ((a + b) / 2) + g) ∘ e = ⇑f
tactic: refine ⟨const Y ((a + b) / 2) + g, fun y => ?_, ?_⟩
Theorem: Cardinal.toNat_apply_of_aleph0_le
File: Mathlib/SetTheory/Cardinal/ToNat.lean

Proof steps:
state_before: α : Type u
c✝ d : Cardinal.{u}
c : Cardinal.{u_1}
h : ℵ₀ ≤ c
⊢ toNat c = 0
state_after: no goals
tactic: simp [h]
Theorem: PosNum.one_le_cast
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedSemiring α
n : PosNum
⊢ 1 ≤ ↑n
state_after: α : Type u_1
inst✝ : LinearOrderedSemiring α
n : PosNum
⊢ 1 ≤ ↑↑n
tactic: ← cast_to_nat,
state_before: α : Type u_1
inst✝ : LinearOrderedSemiring α
n : PosNum
⊢ 1 ≤ ↑↑n
state_after: α : Type u_1
inst✝ : LinearOrderedSemiring α
n : PosNum
⊢ ↑1 ≤ ↑↑n
tactic: ← Nat.cast_one,
state_before: α : Type u_1
inst✝ : LinearOrderedSemiring α
n : PosNum
⊢ ↑1 ≤ ↑↑n
state_after: α : Type u_1
inst✝ : LinearOrderedSemiring α
n : PosNum
⊢ 1 ≤ ↑n
tactic: Nat.cast_le (α := α)
state_before: α : Type u_1
inst✝ : LinearOrderedSemiring α
n : PosNum
⊢ 1 ≤ ↑n
state_after: no goals
tactic: apply to_nat_pos
Theorem: neg_mem_nhds_zero
File: Mathlib/Topology/Algebra/Group/Basic.lean

Proof steps:
state_before: G : Type w
H : Type x
α : Type u
β : Type v
inst✝³ : TopologicalSpace G
inst✝² : Group G
inst✝¹ : TopologicalGroup G
inst✝ : TopologicalSpace α
f : α → G
s : Set α
x : α
S : Set G
hS : S ∈ 𝓝 1
⊢ S⁻¹ ∈ 𝓝 1
state_after: no goals
tactic: rwa [← nhds_one_symm'] at hS
Theorem: AddMonoidHom.mk'_apply
File: Mathlib/Algebra/Group/Hom/Defs.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
H : Type u_8
F : Type u_9
inst✝¹ : Group G
inst✝ : MulOneClass M
f : M → G
map_mul : ∀ (a b : M), f (a * b) = f a * f b
⊢ f 1 = 1
state_after: no goals
tactic: rw [← mul_right_cancel_iff, ← map_mul _ 1, one_mul, one_mul]
Theorem: Homeomorph.map_nhds_eq
File: Mathlib/Topology/Homeomorph.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
x : X
⊢ range ⇑h ∈ 𝓝 (h x)
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Adjunction.equivHomsetRightOfNatIso_apply
File: Mathlib/CategoryTheory/Adjunction/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G✝ G G' : D ⥤ C
iso : G ≅ G'
X : C
Y : D
f : X ⟶ G.obj Y
⊢ (fun g => g ≫ iso.inv.app Y) ((fun f => f ≫ iso.hom.app Y) f) = f
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
G✝ G G' : D ⥤ C
iso : G ≅ G'
X : C
Y : D
g : X ⟶ G'.obj Y
⊢ (fun f => f ≫ iso.hom.app Y) ((fun g => g ≫ iso.inv.app Y) g) = g
state_after: no goals
tactic: simp
Theorem: Polynomial.div_tendsto_leadingCoeff_div_of_degree_eq
File: Mathlib/Analysis/SpecialFunctions/Polynomials.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : P.degree = Q.degree
⊢ Tendsto (fun x => eval x P / eval x Q) atTop (𝓝 (P.leadingCoeff / Q.leadingCoeff))
state_after: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : P.degree = Q.degree
⊢ Tendsto (fun x => P.leadingCoeff / Q.leadingCoeff * x ^ (↑P.natDegree - ↑Q.natDegree)) atTop
    (𝓝 (P.leadingCoeff / Q.leadingCoeff))
tactic: refine (isEquivalent_atTop_div P Q).symm.tendsto_nhds ?_
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : P.degree = Q.degree
⊢ Tendsto (fun x => P.leadingCoeff / Q.leadingCoeff * x ^ (↑P.natDegree - ↑Q.natDegree)) atTop
    (𝓝 (P.leadingCoeff / Q.leadingCoeff))
state_after: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : P.degree = Q.degree
⊢ Tendsto (fun x => P.leadingCoeff / Q.leadingCoeff * x ^ (↑Q.natDegree - ↑Q.natDegree)) atTop
    (𝓝 (P.leadingCoeff / Q.leadingCoeff))
tactic: rw [show (P.natDegree : ℤ) = Q.natDegree by simp [hdeg, natDegree]]
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : P.degree = Q.degree
⊢ Tendsto (fun x => P.leadingCoeff / Q.leadingCoeff * x ^ (↑Q.natDegree - ↑Q.natDegree)) atTop
    (𝓝 (P.leadingCoeff / Q.leadingCoeff))
state_after: no goals
tactic: simp [tendsto_const_nhds]
Theorem: convexHull_insert
File: Mathlib/Analysis/Convex/Join.lean

Proof steps:
state_before: ι : Sort u_1
𝕜 : Type u_2
E : Type u_3
inst✝² : LinearOrderedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t u : Set E
x y : E
hs : s.Nonempty
⊢ (convexHull 𝕜) (insert x s) = convexJoin 𝕜 {x} ((convexHull 𝕜) s)
state_after: no goals
tactic: rw [insert_eq, convexHull_union (singleton_nonempty _) hs, convexHull_singleton]
Theorem: Real.mk_one
File: Mathlib/Data/Real/Basic.lean

Proof steps:
state_before: x y : ℝ
⊢ mk 1 = 1
state_after: x y : ℝ
⊢ mk 1 = { cauchy := 1 }
tactic: rw [← ofCauchy_one]
state_before: x y : ℝ
⊢ mk 1 = { cauchy := 1 }
state_after: no goals
tactic: rfl
Theorem: Subspace.finrank_dualCoannihilator_eq
File: Mathlib/LinearAlgebra/Dual.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W : Subspace K V
inst✝ : FiniteDimensional K V
Φ : Subspace K (Module.Dual K V)
⊢ finrank K ↥(dualCoannihilator Φ) = finrank K ↥(dualAnnihilator Φ)
state_after: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W : Subspace K V
inst✝ : FiniteDimensional K V
Φ : Subspace K (Module.Dual K V)
⊢ finrank K ↥(comap (↑(Module.evalEquiv K V)) (dualAnnihilator Φ)) = finrank K ↥(dualAnnihilator Φ)
tactic: rw [Submodule.dualCoannihilator, ← Module.evalEquiv_toLinearMap]
state_before: K : Type u
V : Type v
inst✝³ : Field K
inst✝² : AddCommGroup V
inst✝¹ : Module K V
W : Subspace K V
inst✝ : FiniteDimensional K V
Φ : Subspace K (Module.Dual K V)
⊢ finrank K ↥(comap (↑(Module.evalEquiv K V)) (dualAnnihilator Φ)) = finrank K ↥(dualAnnihilator Φ)
state_after: no goals
tactic: exact LinearEquiv.finrank_eq (LinearEquiv.ofSubmodule' _ _)
Theorem: CategoryTheory.Functor.inv_fun_map
File: Mathlib/CategoryTheory/Equivalence.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : F.IsEquivalence
X Y : C
f : X ⟶ Y
⊢ F.inv.map (F.map f) = F.asEquivalence.unitInv.app X ≫ f ≫ F.asEquivalence.unit.app Y
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : F.IsEquivalence
X Y : C
f : X ⟶ Y
⊢ F.inv.map (F.map f) = (F.asEquivalence.functor ⋙ F.asEquivalence.inverse).map f
tactic: erw [NatIso.naturality_1]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
inst✝ : F.IsEquivalence
X Y : C
f : X ⟶ Y
⊢ F.inv.map (F.map f) = (F.asEquivalence.functor ⋙ F.asEquivalence.inverse).map f
state_after: no goals
tactic: rfl
Theorem: Matrix.vec2_dotProduct'
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝¹ : AddCommMonoid α
inst✝ : Mul α
a₀ a₁ b₀ b₁ : α
⊢ ![a₀, a₁] ⬝ᵥ ![b₀, b₁] = a₀ * b₀ + a₁ * b₁
state_after: no goals
tactic: rw [cons_dotProduct_cons, cons_dotProduct_cons, dotProduct_empty, add_zero]
Theorem: ne_iff_ne_of_mul_eq_mul
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✝ : CancelCommMonoid α
a b c d : α
h : a * b = c * d
⊢ a ≠ c ↔ b ≠ d
state_after: no goals
tactic: aesop
Theorem: intervalIntegral.integral_sub
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝² : NormedAddCommGroup E
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
a b : ℝ
f g : ℝ → E
μ : Measure ℝ
hf : IntervalIntegrable f μ a b
hg : IntervalIntegrable g μ a b
⊢ ∫ (x : ℝ) in a..b, f x - g x ∂μ = ∫ (x : ℝ) in a..b, f x ∂μ - ∫ (x : ℝ) in a..b, g x ∂μ
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using (integral_add hf hg.neg).trans (congr_arg _ integral_neg)