ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Real.hasDerivAt_Gamma_one_half
File: Mathlib/NumberTheory/Harmonic/GammaDeriv.lean

Proof steps:
state_before: ⊢ HasDerivAt Gamma (-√π * (γ + 2 * log 2)) (1 / 2)
state_after: h_diff : ∀ {s : ℝ}, 0 < s → DifferentiableAt ℝ Gamma s
⊢ HasDerivAt Gamma (-√π * (γ + 2 * log 2)) (1 / 2)
tactic: have h_diff {s : ℝ} (hs : 0 < s) : DifferentiableAt ℝ Gamma s :=
    differentiableAt_Gamma fun m ↦ ((neg_nonpos.mpr m.cast_nonneg).trans_lt hs).ne'
state_before: h_diff : ∀ {s : ℝ}, 0 < s → DifferentiableAt ℝ Gamma s
⊢ HasDerivAt Gamma (-√π * (γ + 2 * log 2)) (1 / 2)
state_after: h_diff : ∀ {s : ℝ}, 0 < s → DifferentiableAt ℝ Gamma s
h_diff' : ∀ {s : ℝ}, 0 < s → DifferentiableAt ℝ (fun s => Gamma (2 * s)) s
⊢ HasDerivAt Gamma (-√π * (γ + 2 * log 2)) (1 / 2)
tactic: have h_diff' {s : ℝ} (hs : 0 < s) : DifferentiableAt ℝ (fun s ↦ Gamma (2 * s)) s :=
    .comp (g := Gamma) _ (h_diff <| mul_pos two_pos hs) (differentiableAt_id.const_mul _)
state_before: h_diff : ∀ {s : ℝ}, 0 < s → DifferentiableAt ℝ Gamma s
h_diff' : ∀ {s : ℝ}, 0 < s → DifferentiableAt ℝ (fun s => Gamma (2 * s)) s
⊢ HasDerivAt Gamma (-√π * (γ + 2 * log 2)) (1 / 2)
state_after: h_diff : ∀ {s : ℝ}, 0 < s → DifferentiableAt ℝ Gamma s
h_diff' : ∀ {s : ℝ}, 0 < s → DifferentiableAt ℝ (fun s => Gamma (2 * s)) s
⊢ deriv Gamma (1 / 2) = -√π * (γ + 2 * log 2)
tactic: refine (h_diff one_half_pos).hasDerivAt.congr_deriv ?_
Theorem: Filter.Germ.const_min
File: Mathlib/Order/Filter/FilterProduct.lean

Proof steps:
state_before: α : Type u
β : Type v
φ : Ultrafilter α
inst✝ : LinearOrder β
x y : β
⊢ ↑(min x y) = min ↑x ↑y
state_after: no goals
tactic: rw [min_def, map₂_const]
Theorem: Equiv.Perm.VectorsProdEqOne.one_eq
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Fintype α
G : Type u_2
inst✝ : Group G
n : ℕ
⊢ vectorsProdEqOne G 1 = {1 ::ᵥ Vector.nil}
state_after: α : Type u_1
inst✝¹ : Fintype α
G : Type u_2
inst✝ : Group G
n : ℕ
⊢ ∀ (x : Vector G 1), x.head = 1 → x = 1 ::ᵥ Vector.nil
tactic: simp_rw [Set.eq_singleton_iff_unique_mem, mem_iff, Vector.toList_singleton, List.prod_singleton,
    Vector.head_cons, true_and]
state_before: α : Type u_1
inst✝¹ : Fintype α
G : Type u_2
inst✝ : Group G
n : ℕ
⊢ ∀ (x : Vector G 1), x.head = 1 → x = 1 ::ᵥ Vector.nil
state_after: no goals
tactic: exact fun v hv => v.cons_head_tail.symm.trans (congr_arg₂ Vector.cons hv v.tail.eq_nil)
Theorem: Ordinal.fp_iff_derivBFamily
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

Proof steps:
state_before: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max u v}
⊢ (∀ (i : Ordinal.{u}) (hi : i < o), f i hi a = a) ↔ ∃ b, o.derivBFamily f b = a
state_after: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max u v}
⊢ (∀ (i : Ordinal.{u}) (hi : i < o), f i hi a = a) ↔ ∀ (i : Ordinal.{u}) (hi : i < o), f i hi a ≤ a
tactic: rw [← le_iff_derivBFamily H]
state_before: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max u v}
⊢ (∀ (i : Ordinal.{u}) (hi : i < o), f i hi a = a) ↔ ∀ (i : Ordinal.{u}) (hi : i < o), f i hi a ≤ a
state_after: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max u v}
h : ∀ (i : Ordinal.{u}) (hi : i < o), f i hi a ≤ a
i : Ordinal.{u}
hi : i < o
⊢ f i hi a = a
tactic: refine ⟨fun h i hi => le_of_eq (h i hi), fun h i hi => ?_⟩
state_before: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max u v}
h : ∀ (i : Ordinal.{u}) (hi : i < o), f i hi a ≤ a
i : Ordinal.{u}
hi : i < o
⊢ f i hi a = a
state_after: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max u v}
h : ∀ (i : Ordinal.{u}) (hi : i < o), f i hi a ≤ a
i : Ordinal.{u}
hi : i < o
⊢ f i hi a ≤ a
tactic: rw [← (H i hi).le_iff_eq]
state_before: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max u v}
h : ∀ (i : Ordinal.{u}) (hi : i < o), f i hi a ≤ a
i : Ordinal.{u}
hi : i < o
⊢ f i hi a ≤ a
state_after: no goals
tactic: exact h i hi
Theorem: wbtw_comm
File: Mathlib/Analysis/Convex/Between.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : OrderedRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x y z : P
⊢ Wbtw R x y z ↔ Wbtw R z y x
state_after: no goals
tactic: rw [Wbtw, Wbtw, affineSegment_comm]
Theorem: dist_div_div_le
File: Mathlib/Analysis/Normed/Group/Uniform.lean

Proof steps:
state_before: 𝓕 : Type u_1
α : Type u_2
E : Type u_3
F : Type u_4
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁✝ a₂✝ b b₁✝ b₂✝ : E
r r₁ r₂ : ℝ
a₁ a₂ b₁ b₂ : E
⊢ dist (a₁ / a₂) (b₁ / b₂) ≤ dist a₁ b₁ + dist a₂ b₂
state_after: no goals
tactic: simpa only [div_eq_mul_inv, dist_inv_inv] using dist_mul_mul_le a₁ a₂⁻¹ b₁ b₂⁻¹
Theorem: Submodule.ker_inl
File: Mathlib/LinearAlgebra/Prod.lean

Proof steps:
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid M
inst✝² : AddCommMonoid M₂
inst✝¹ : Module R M
inst✝ : Module R M₂
p : Submodule R M
q : Submodule R M₂
⊢ ker (inl R M M₂) = ⊥
state_after: no goals
tactic: rw [ker, ← prod_bot, prod_comap_inl]
Theorem: SetTheory.PGame.Numeric.left_lt_right
File: Mathlib/SetTheory/Surreal/Basic.lean

Proof steps:
state_before: x : PGame
o : x.Numeric
i : x.LeftMoves
j : x.RightMoves
⊢ x.moveLeft i < x.moveRight j
state_after: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
o : (PGame.mk α✝ β✝ a✝¹ a✝).Numeric
i : (PGame.mk α✝ β✝ a✝¹ a✝).LeftMoves
j : (PGame.mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (PGame.mk α✝ β✝ a✝¹ a✝).moveLeft i < (PGame.mk α✝ β✝ a✝¹ a✝).moveRight j
tactic: cases x
state_before: case mk
α✝ β✝ : Type u_1
a✝¹ : α✝ → PGame
a✝ : β✝ → PGame
o : (PGame.mk α✝ β✝ a✝¹ a✝).Numeric
i : (PGame.mk α✝ β✝ a✝¹ a✝).LeftMoves
j : (PGame.mk α✝ β✝ a✝¹ a✝).RightMoves
⊢ (PGame.mk α✝ β✝ a✝¹ a✝).moveLeft i < (PGame.mk α✝ β✝ a✝¹ a✝).moveRight j
state_after: no goals
tactic: exact o.1 i j
Theorem: Set.toFinset_union
File: Mathlib/Data/Fintype/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝³ : DecidableEq α
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s ∪ t)
⊢ (s ∪ t).toFinset = s.toFinset ∪ t.toFinset
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝³ : DecidableEq α
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s ∪ t)
a✝ : α
⊢ a✝ ∈ (s ∪ t).toFinset ↔ a✝ ∈ s.toFinset ∪ t.toFinset
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
s t : Set α
inst✝³ : DecidableEq α
inst✝² : Fintype ↑s
inst✝¹ : Fintype ↑t
inst✝ : Fintype ↑(s ∪ t)
a✝ : α
⊢ a✝ ∈ (s ∪ t).toFinset ↔ a✝ ∈ s.toFinset ∪ t.toFinset
state_after: no goals
tactic: simp
Theorem: finEquivZMultiples_symm_apply
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x✝ y : G
i : ℤ
x : G
hx : IsOfFinOrder x
n : ℕ
⊢ (fun x_1 => x ^ x_1) ↑n = x ^ n
state_after: no goals
tactic: simp
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x✝ y : G
i : ℤ
x : G
hx : IsOfFinOrder x
n : ℕ
⊢ (finEquivZPowers x hx).symm ⟨x ^ n, ⋯⟩ = ⟨n % orderOf x, ⋯⟩
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x✝ y : G
i : ℤ
x : G
hx : IsOfFinOrder x
n : ℕ
⊢ (finEquivPowers x hx).symm ((Equiv.Set.ofEq ⋯).symm ⟨x ^ n, ⋯⟩) = ⟨n % orderOf x, ⋯⟩
tactic: rw [finEquivZPowers, Equiv.symm_trans_apply]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Group G
x✝ y : G
i : ℤ
x : G
hx : IsOfFinOrder x
n : ℕ
⊢ (finEquivPowers x hx).symm ((Equiv.Set.ofEq ⋯).symm ⟨x ^ n, ⋯⟩) = ⟨n % orderOf x, ⋯⟩
state_after: no goals
tactic: exact finEquivPowers_symm_apply x _ n
Theorem: le_sub_self_iff
File: Mathlib/Algebra/Order/Group/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
inst✝³ : Group α
inst✝² : LE α
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✝ b✝ c d a b : α
⊢ a ≤ a / b ↔ b ≤ 1
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: Complex.hasDerivAt_GammaIntegral
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

Proof steps:
state_before: s : ℂ
hs : 0 < s.re
⊢ HasDerivAt GammaIntegral (∫ (t : ℝ) in Ioi 0, ↑t ^ (s - 1) * (↑(Real.log t) * ↑(rexp (-t)))) s
state_after: s : ℂ
hs : 0 < s.re
⊢ HasDerivAt (mellin fun x => ↑(rexp (-x))) (∫ (t : ℝ) in Ioi 0, ↑t ^ (s - 1) * (↑(Real.log t) * ↑(rexp (-t)))) s
tactic: rw [GammaIntegral_eq_mellin]
state_before: s : ℂ
hs : 0 < s.re
⊢ HasDerivAt (mellin fun x => ↑(rexp (-x))) (∫ (t : ℝ) in Ioi 0, ↑t ^ (s - 1) * (↑(Real.log t) * ↑(rexp (-t)))) s
state_after: case convert_2
s : ℂ
hs : 0 < s.re
⊢ LocallyIntegrableOn (fun x => ↑(rexp (-x))) (Ioi 0) volume

case convert_3
s : ℂ
hs : 0 < s.re
⊢ (fun x => ↑(rexp (-x))) =O[atTop] fun x => x ^ (-(s.re + 1))

case convert_4
s : ℂ
hs : 0 < s.re
⊢ (fun x => ↑(rexp (-x))) =O[𝓝[>] 0] fun x => x ^ (-0)
tactic: convert (mellin_hasDerivAt_of_isBigO_rpow (E := ℂ) _ _ (lt_add_one _) _ hs).2
Theorem: Complex.cpow_add
File: Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean

Proof steps:
state_before: x y z : ℂ
hx : x ≠ 0
⊢ x ^ (y + z) = x ^ y * x ^ z
state_after: x y z : ℂ
hx : x ≠ 0
⊢ (if x = 0 then if y + z = 0 then 1 else 0 else cexp (log x * (y + z))) =
    if x = 0 then
      if z = 0 then if x = 0 then if y = 0 then 1 * 1 else 0 * 1 else cexp (log x * y) * 1
      else if x = 0 then if y = 0 then 1 * 0 else 0 * 0 else cexp (log x * y) * 0
    else
      if x = 0 then if y = 0 then 1 * cexp (log x * z) else 0 * cexp (log x * z)
      else cexp (log x * y) * cexp (log x * z)
tactic: simp only [cpow_def, ite_mul, boole_mul, mul_ite, mul_boole]
state_before: x y z : ℂ
hx : x ≠ 0
⊢ (if x = 0 then if y + z = 0 then 1 else 0 else cexp (log x * (y + z))) =
    if x = 0 then
      if z = 0 then if x = 0 then if y = 0 then 1 * 1 else 0 * 1 else cexp (log x * y) * 1
      else if x = 0 then if y = 0 then 1 * 0 else 0 * 0 else cexp (log x * y) * 0
    else
      if x = 0 then if y = 0 then 1 * cexp (log x * z) else 0 * cexp (log x * z)
      else cexp (log x * y) * cexp (log x * z)
state_after: no goals
tactic: simp_all [exp_add, mul_add]
Theorem: polynomialFunctions.starClosure_eq_adjoin_X
File: Mathlib/Topology/ContinuousFunction/Polynomial.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
inst✝³ : TopologicalSpace R
inst✝² : TopologicalSemiring R
inst✝¹ : StarRing R
inst✝ : ContinuousStar R
s : Set R
⊢ (polynomialFunctions s).starClosure = adjoin R {(toContinuousMapOnAlgHom s) X}
state_after: no goals
tactic: rw [polynomialFunctions.eq_adjoin_X s, adjoin_eq_starClosure_adjoin]
Theorem: HurwitzKernelBounds.isBigO_atTop_F_nat_zero_sub
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/Bounds.lean

Proof steps:
state_before: a : ℝ
ha : 0 ≤ a
⊢ ∃ p, 0 < p ∧ (fun t => F_nat 0 a t - if a = 0 then 1 else 0) =O[atTop] fun t => rexp (-p * t)
state_after: case pos
a : ℝ
ha : 0 ≤ a
h : a = 0
⊢ ∃ p, 0 < p ∧ (fun t => F_nat 0 a t - 1) =O[atTop] fun t => rexp (-p * t)

case neg
a : ℝ
ha : 0 ≤ a
h : ¬a = 0
⊢ ∃ p, 0 < p ∧ (fun t => F_nat 0 a t - 0) =O[atTop] fun t => rexp (-p * t)
tactic: split_ifs with h
Theorem: Preord.Iso.mk_inv
File: Mathlib/Order/Category/Preord.lean

Proof steps:
state_before: α β : Preord
e : ↑α ≃o ↑β
⊢ ↑e ≫ ↑e.symm = 𝟙 α
state_after: case w
α β : Preord
e : ↑α ≃o ↑β
x : (forget Preord).obj α
⊢ (↑e ≫ ↑e.symm) x = (𝟙 α) x
tactic: ext x
state_before: case w
α β : Preord
e : ↑α ≃o ↑β
x : (forget Preord).obj α
⊢ (↑e ≫ ↑e.symm) x = (𝟙 α) x
state_after: no goals
tactic: exact e.symm_apply_apply x
state_before: α β : Preord
e : ↑α ≃o ↑β
⊢ ↑e.symm ≫ ↑e = 𝟙 β
state_after: case w
α β : Preord
e : ↑α ≃o ↑β
x : (forget Preord).obj β
⊢ (↑e.symm ≫ ↑e) x = (𝟙 β) x
tactic: ext x
state_before: case w
α β : Preord
e : ↑α ≃o ↑β
x : (forget Preord).obj β
⊢ (↑e.symm ≫ ↑e) x = (𝟙 β) x
state_after: no goals
tactic: exact e.apply_symm_apply x
Theorem: ZMod.trace_pow_card
File: Mathlib/LinearAlgebra/Matrix/Charpoly/FiniteField.lean

Proof steps:
state_before: n : Type u_1
inst✝² : DecidableEq n
inst✝¹ : Fintype n
p : ℕ
inst✝ : Fact (Nat.Prime p)
M : Matrix n n (ZMod p)
⊢ (M ^ p).trace = M.trace ^ p
state_after: n : Type u_1
inst✝² : DecidableEq n
inst✝¹ : Fintype n
p : ℕ
inst✝ : Fact (Nat.Prime p)
M : Matrix n n (ZMod p)
h : (M ^ Fintype.card (ZMod p)).trace = M.trace ^ Fintype.card (ZMod p)
⊢ (M ^ p).trace = M.trace ^ p
tactic: have h := FiniteField.trace_pow_card M
state_before: n : Type u_1
inst✝² : DecidableEq n
inst✝¹ : Fintype n
p : ℕ
inst✝ : Fact (Nat.Prime p)
M : Matrix n n (ZMod p)
h : (M ^ Fintype.card (ZMod p)).trace = M.trace ^ Fintype.card (ZMod p)
⊢ (M ^ p).trace = M.trace ^ p
state_after: no goals
tactic: rwa [ZMod.card] at h
Theorem: CategoryTheory.ShortComplex.leftHomologyMap'_neg
File: Mathlib/Algebra/Homology/ShortComplex/Preadditive.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
⊢ leftHomologyMap' (-φ) h₁ h₂ = -leftHomologyMap' φ h₁ h₂
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
γ : LeftHomologyMapData φ h₁ h₂
⊢ leftHomologyMap' (-φ) h₁ h₂ = -leftHomologyMap' φ h₁ h₂
tactic: have γ : LeftHomologyMapData φ h₁ h₂ := default
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
S₁ S₂ S₃ : ShortComplex C
φ φ' : S₁ ⟶ S₂
h₁ : S₁.LeftHomologyData
h₂ : S₂.LeftHomologyData
γ : LeftHomologyMapData φ h₁ h₂
⊢ leftHomologyMap' (-φ) h₁ h₂ = -leftHomologyMap' φ h₁ h₂
state_after: no goals
tactic: simp only [γ.leftHomologyMap'_eq, γ.neg.leftHomologyMap'_eq, LeftHomologyMapData.neg_φH]
Theorem: CategoryTheory.IsHomLift.of_fac'
File: Mathlib/CategoryTheory/FiberedCategory/HomLift.lean

Proof steps:
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
R S : 𝒮
a b : 𝒳
f : R ⟶ S
φ : a ⟶ b
ha : p.obj a = R
hb : p.obj b = S
h : p.map φ = eqToHom ha ≫ f ≫ eqToHom ⋯
⊢ p.IsHomLift f φ
state_after: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
a b : 𝒳
φ : a ⟶ b
f : p.obj a ⟶ p.obj b
h : p.map φ = eqToHom ⋯ ≫ f ≫ eqToHom ⋯
⊢ p.IsHomLift f φ
tactic: subst ha hb
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
a b : 𝒳
φ : a ⟶ b
f : p.obj a ⟶ p.obj b
h : p.map φ = eqToHom ⋯ ≫ f ≫ eqToHom ⋯
⊢ p.IsHomLift f φ
state_after: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
a b : 𝒳
φ : a ⟶ b
h : p.map φ = eqToHom ⋯ ≫ p.map φ ≫ eqToHom ⋯
⊢ p.IsHomLift (p.map φ) φ
tactic: obtain rfl : f = p.map φ := by simpa using h.symm
state_before: 𝒮 : Type u₁
𝒳 : Type u₂
inst✝¹ : Category.{v₁, u₂} 𝒳
inst✝ : Category.{v₂, u₁} 𝒮
p : 𝒳 ⥤ 𝒮
a b : 𝒳
φ : a ⟶ b
h : p.map φ = eqToHom ⋯ ≫ p.map φ ≫ eqToHom ⋯
⊢ p.IsHomLift (p.map φ) φ
state_after: no goals
tactic: infer_instance
Theorem: CategoryTheory.Bicategory.pentagon_hom_inv_inv_inv_inv
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

Proof steps:
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h : c ⟶ d
i : d ⟶ e
⊢ f ◁ (α_ g h i).hom ≫ (α_ f g (h ≫ i)).inv ≫ (α_ (f ≫ g) h i).inv = (α_ f (g ≫ h) i).inv ≫ (α_ f g h).inv ▷ i
state_after: no goals
tactic: simp [← cancel_epi (f ◁ (α_ g h i).inv)]
Theorem: RelSeries.smash_succ_natAdd
File: Mathlib/Order/RelSeries.lean

Proof steps:
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
i : Fin q.length
⊢ (p.smash q h).toFun (Fin.natAdd p.length i).succ = q.toFun i.succ
state_after: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
i : Fin q.length
⊢ (if H : ↑(Fin.natAdd p.length i).succ < p.length then p.toFun ⟨↑(Fin.natAdd p.length i).succ, ⋯⟩
    else q.toFun ⟨↑(Fin.natAdd p.length i).succ - p.length, ⋯⟩) =
    q.toFun i.succ
tactic: rw [smash_toFun]
state_before: α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
i : Fin q.length
⊢ (if H : ↑(Fin.natAdd p.length i).succ < p.length then p.toFun ⟨↑(Fin.natAdd p.length i).succ, ⋯⟩
    else q.toFun ⟨↑(Fin.natAdd p.length i).succ - p.length, ⋯⟩) =
    q.toFun i.succ
state_after: case pos
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
i : Fin q.length
H : ↑(Fin.natAdd p.length i).succ < p.length
⊢ p.toFun ⟨↑(Fin.natAdd p.length i).succ, ⋯⟩ = q.toFun i.succ

case neg
α : Type u_1
r : Rel α α
β : Type u_2
s : Rel β β
p q : RelSeries r
h : p.last = q.head
i : Fin q.length
H : ¬↑(Fin.natAdd p.length i).succ < p.length
⊢ q.toFun ⟨↑(Fin.natAdd p.length i).succ - p.length, ⋯⟩ = q.toFun i.succ
tactic: split_ifs with H
Theorem: IsCoprime.pow_left_iff
File: Mathlib/RingTheory/Coprime/Lemmas.lean

Proof steps:
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
hm : 0 < m
⊢ IsCoprime (x ^ m) y ↔ IsCoprime x y
state_after: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
hm : 0 < m
h : IsCoprime (x ^ m) y
⊢ IsCoprime x y
tactic: refine ⟨fun h ↦ ?_, IsCoprime.pow_left⟩
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
hm : 0 < m
h : IsCoprime (x ^ m) y
⊢ IsCoprime x y
state_after: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
hm : 0 < m
h : IsCoprime (∏ _x ∈ range m, x) y
⊢ IsCoprime x y
tactic: rw [← Finset.card_range m, ← Finset.prod_const] at h
state_before: R : Type u
I : Type v
inst✝ : CommSemiring R
x y z : R
s : I → R
t : Finset I
m n : ℕ
hm : 0 < m
h : IsCoprime (∏ _x ∈ range m, x) y
⊢ IsCoprime x y
state_after: no goals
tactic: exact h.of_prod_left 0 (Finset.mem_range.mpr hm)
Theorem: UniformSpace.Completion.dist_triangle
File: Mathlib/Topology/MetricSpace/Completion.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
⊢ dist x z ≤ dist x y + dist y z
state_after: case refine_1
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
⊢ IsClosed {x | dist x.1 x.2.2 ≤ dist x.1 x.2.1 + dist x.2.1 x.2.2}

case refine_2
α : Type u
β : Type v
inst✝ : PseudoMetricSpace α
x y z : Completion α
⊢ ∀ (a b c : α), dist (↑α a) (↑α c) ≤ dist (↑α a) (↑α b) + dist (↑α b) (↑α c)
tactic: refine induction_on₃ x y z ?_ ?_
Theorem: Homotopy.trans_hom
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✝ : ι
e f g : C ⟶ D
h : Homotopy e f
k : Homotopy f g
i j : ι
w : ¬c.Rel j i
⊢ (h.hom + k.hom) i j = 0
state_after: no goals
tactic: rw [Pi.add_apply, Pi.add_apply, h.zero i j w, k.zero i j w, zero_add]
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✝ : ι
e f g : C ⟶ D
h : Homotopy e f
k : Homotopy f g
i : ι
⊢ e.f i = (dNext i) (h.hom + k.hom) + (prevD i) (h.hom + k.hom) + g.f i
state_after: ι : 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✝ : ι
e f g : C ⟶ D
h : Homotopy e f
k : Homotopy f g
i : ι
⊢ (dNext i) h.hom + (prevD i) h.hom + ((dNext i) k.hom + (prevD i) k.hom + g.f i) =
    (dNext i) h.hom + (dNext i) k.hom + ((prevD i) h.hom + (prevD i) k.hom) + g.f i
tactic: rw [AddMonoidHom.map_add, AddMonoidHom.map_add, h.comm, k.comm]
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✝ : ι
e f g : C ⟶ D
h : Homotopy e f
k : Homotopy f g
i : ι
⊢ (dNext i) h.hom + (prevD i) h.hom + ((dNext i) k.hom + (prevD i) k.hom + g.f i) =
    (dNext i) h.hom + (dNext i) k.hom + ((prevD i) h.hom + (prevD i) k.hom) + g.f i
state_after: no goals
tactic: abel
Theorem: MeasureTheory.rnDeriv_tilted_left_self
File: Mathlib/MeasureTheory/Measure/Tilted.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
inst✝ : SigmaFinite μ
hf : AEMeasurable f μ
⊢ (μ.tilted f).rnDeriv μ =ᶠ[ae μ] fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)
state_after: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
inst✝ : SigmaFinite μ
hf : AEMeasurable f μ
⊢ (fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) * μ.rnDeriv μ x) =ᶠ[ae μ] fun x =>
    ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)
tactic: refine (rnDeriv_tilted_left μ hf).trans ?_
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
inst✝ : SigmaFinite μ
hf : AEMeasurable f μ
⊢ (fun x => ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) * μ.rnDeriv μ x) =ᶠ[ae μ] fun x =>
    ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)
state_after: case h
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
inst✝ : SigmaFinite μ
hf : AEMeasurable f μ
x : α
hx : μ.rnDeriv μ x = 1
⊢ ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) * μ.rnDeriv μ x =
    ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)
tactic: filter_upwards [Measure.rnDeriv_self μ] with x hx
state_before: case h
α : Type u_1
mα : MeasurableSpace α
μ : Measure α
f : α → ℝ
inst✝ : SigmaFinite μ
hf : AEMeasurable f μ
x : α
hx : μ.rnDeriv μ x = 1
⊢ ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ) * μ.rnDeriv μ x =
    ENNReal.ofReal (rexp (f x) / ∫ (x : α), rexp (f x) ∂μ)
state_after: no goals
tactic: rw [hx, mul_one]