ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: BotHom.cancel_left
File: Mathlib/Order/Hom/Bounded.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
δ : Type u_5
inst✝⁴ : FunLike F α β
inst✝³ : Bot α
inst✝² : Bot β
inst✝¹ : Bot γ
inst✝ : Bot δ
g : BotHom β γ
f₁ f₂ : BotHom α β
hg : Injective ⇑g
h : g.comp f₁ = g.comp f₂
a : α
⊢ g (f₁ a) = g (f₂ a)
state_after: no goals
tactic: rw [← BotHom.comp_apply, h, BotHom.comp_apply]
Theorem: CategoryTheory.Limits.Pi.π_comp_eqToHom
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

Proof steps:
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
J : Type u_1
f : J → C
inst✝ : HasProduct f
j j' : J
w : j = j'
⊢ f j = f j'
state_after: no goals
tactic: simp [w]
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
J : Type u_1
f : J → C
inst✝ : HasProduct f
j j' : J
w : j = j'
⊢ π f j ≫ eqToHom ⋯ = π f j'
state_after: case refl
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
J : Type u_1
f : J → C
inst✝ : HasProduct f
j : J
⊢ π f j ≫ eqToHom ⋯ = π f j
tactic: cases w
state_before: case refl
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
J : Type u_1
f : J → C
inst✝ : HasProduct f
j : J
⊢ π f j ≫ eqToHom ⋯ = π f j
state_after: no goals
tactic: simp
Theorem: CategoryTheory.shift_shiftFunctorCompIsoId_add_neg_self_inv_app
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddGroup A
inst✝ : HasShift C A
X✝ Y : C
f : X✝ ⟶ Y
n : A
X : C
⊢ (shiftFunctor C n).map ((shiftFunctorCompIsoId C n (-n) ⋯).inv.app X) =
    (shiftFunctorCompIsoId C (-n) n ⋯).inv.app ((shiftFunctor C n).obj X)
state_after: no goals
tactic: apply shift_shiftFunctorCompIsoId_inv_app
Theorem: CategoryTheory.ShiftedHom.mk₀_comp_mk₀
File: Mathlib/CategoryTheory/Shift/ShiftedHom.lean

Proof steps:
state_before: C : Type u_1
inst✝⁶ : Category.{?u.25860, u_1} C
D : Type u_2
inst✝⁵ : Category.{?u.25867, u_2} D
E : Type u_3
inst✝⁴ : Category.{?u.25874, u_3} E
M : Type u_4
inst✝³ : AddMonoid M
inst✝² : HasShift C M
inst✝¹ : HasShift D M
inst✝ : HasShift E M
X Y Z T : C
f : X ⟶ Y
g : Y ⟶ Z
a b c : M
h : b + a = c
ha : a = 0
hb : b = 0
⊢ c = 0
state_after: no goals
tactic: rw [← h, ha, hb, add_zero]
state_before: C : Type u_1
inst✝⁶ : Category.{u_5, u_1} C
D : Type u_2
inst✝⁵ : Category.{?u.25867, u_2} D
E : Type u_3
inst✝⁴ : Category.{?u.25874, u_3} E
M : Type u_4
inst✝³ : AddMonoid M
inst✝² : HasShift C M
inst✝¹ : HasShift D M
inst✝ : HasShift E M
X Y Z T : C
f : X ⟶ Y
g : Y ⟶ Z
a b c : M
h : b + a = c
ha : a = 0
hb : b = 0
⊢ (mk₀ a ha f).comp (mk₀ b hb g) h = mk₀ c ⋯ (f ≫ g)
state_after: C : Type u_1
inst✝⁶ : Category.{u_5, u_1} C
D : Type u_2
inst✝⁵ : Category.{?u.25867, u_2} D
E : Type u_3
inst✝⁴ : Category.{?u.25874, u_3} E
M : Type u_4
inst✝³ : AddMonoid M
inst✝² : HasShift C M
inst✝¹ : HasShift D M
inst✝ : HasShift E M
X Y Z T : C
f : X ⟶ Y
g : Y ⟶ Z
c : M
h : 0 + 0 = c
⊢ (mk₀ 0 ⋯ f).comp (mk₀ 0 ⋯ g) h = mk₀ c ⋯ (f ≫ g)
tactic: subst ha hb
state_before: C : Type u_1
inst✝⁶ : Category.{u_5, u_1} C
D : Type u_2
inst✝⁵ : Category.{?u.25867, u_2} D
E : Type u_3
inst✝⁴ : Category.{?u.25874, u_3} E
M : Type u_4
inst✝³ : AddMonoid M
inst✝² : HasShift C M
inst✝¹ : HasShift D M
inst✝ : HasShift E M
X Y Z T : C
f : X ⟶ Y
g : Y ⟶ Z
c : M
h : 0 + 0 = c
⊢ (mk₀ 0 ⋯ f).comp (mk₀ 0 ⋯ g) h = mk₀ c ⋯ (f ≫ g)
state_after: C : Type u_1
inst✝⁶ : Category.{u_5, u_1} C
D : Type u_2
inst✝⁵ : Category.{?u.25867, u_2} D
E : Type u_3
inst✝⁴ : Category.{?u.25874, u_3} E
M : Type u_4
inst✝³ : AddMonoid M
inst✝² : HasShift C M
inst✝¹ : HasShift D M
inst✝ : HasShift E M
X Y Z T : C
f : X ⟶ Y
g : Y ⟶ Z
h : 0 + 0 = 0
⊢ (mk₀ 0 ⋯ f).comp (mk₀ 0 ⋯ g) h = mk₀ 0 ⋯ (f ≫ g)
tactic: obtain rfl : c = 0 := by rw [← h, zero_add]
state_before: C : Type u_1
inst✝⁶ : Category.{u_5, u_1} C
D : Type u_2
inst✝⁵ : Category.{?u.25867, u_2} D
E : Type u_3
inst✝⁴ : Category.{?u.25874, u_3} E
M : Type u_4
inst✝³ : AddMonoid M
inst✝² : HasShift C M
inst✝¹ : HasShift D M
inst✝ : HasShift E M
X Y Z T : C
f : X ⟶ Y
g : Y ⟶ Z
h : 0 + 0 = 0
⊢ (mk₀ 0 ⋯ f).comp (mk₀ 0 ⋯ g) h = mk₀ 0 ⋯ (f ≫ g)
state_after: no goals
tactic: rw [mk₀_comp, mk₀, mk₀, assoc]
Theorem: ENNReal.iUnion_Ico_coe_nat
File: Mathlib/Data/ENNReal/Basic.lean

Proof steps:
state_before: α : Type u_1
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ⋃ n, Ico a ↑n = Ici a \ {⊤}
state_after: no goals
tactic: simp only [← Ici_inter_Iio, ← inter_iUnion, iUnion_Iio_coe_nat, diff_eq]
Theorem: Real.toNNReal_prod_of_nonneg
File: Mathlib/Data/NNReal/Basic.lean

Proof steps:
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ a ∈ s, 0 ≤ f a
⊢ (∏ a ∈ s, f a).toNNReal = ∏ a ∈ s, (f a).toNNReal
state_after: r r₁ r₂ : ℝ≥0
x y : ℝ
α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ a ∈ s, 0 ≤ f a
⊢ ∏ i ∈ s, f i = ∏ a ∈ s, ↑(f a).toNNReal
tactic: rw [← coe_inj, NNReal.coe_prod, Real.coe_toNNReal _ (Finset.prod_nonneg hf)]
state_before: r r₁ r₂ : ℝ≥0
x y : ℝ
α : Type u_1
s : Finset α
f : α → ℝ
hf : ∀ a ∈ s, 0 ≤ f a
⊢ ∏ i ∈ s, f i = ∏ a ∈ s, ↑(f a).toNNReal
state_after: no goals
tactic: exact Finset.prod_congr rfl fun x hxs => by rw [Real.coe_toNNReal _ (hf x hxs)]
Theorem: Complex.coe_orthonormalBasisOneI
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝⁹ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type u_7
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
⊢ ⇑orthonormalBasisOneI = ![1, I]
state_after: no goals
tactic: simp [Complex.orthonormalBasisOneI]
Theorem: Filter.HasBasis.equicontinuousWithinAt_iff
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
κ₁ : Type u_13
κ₂ : Type u_14
p₁ : κ₁ → Prop
s₁ : κ₁ → Set X
p₂ : κ₂ → Prop
s₂ : κ₂ → Set (α × α)
F : ι → X → α
S : Set X
x₀ : X
hX : (𝓝[S] x₀).HasBasis p₁ s₁
hα : (𝓤 α).HasBasis p₂ s₂
⊢ EquicontinuousWithinAt F S x₀ ↔ ∀ (k₂ : κ₂), p₂ k₂ → ∃ k₁, p₁ k₁ ∧ ∀ x ∈ s₁ k₁, ∀ (i : ι), (F i x₀, F i x) ∈ s₂ k₂
state_after: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
κ₁ : Type u_13
κ₂ : Type u_14
p₁ : κ₁ → Prop
s₁ : κ₁ → Set X
p₂ : κ₂ → Prop
s₂ : κ₂ → Set (α × α)
F : ι → X → α
S : Set X
x₀ : X
hX : (𝓝[S] x₀).HasBasis p₁ s₁
hα : (𝓤 α).HasBasis p₂ s₂
⊢ (∀ (ib : κ₂),
      p₂ ib →
        ∃ ia,
          p₁ ia ∧
            ∀ x ∈ s₁ ia,
              (⇑UniformFun.ofFun ∘ swap F) x ∈
                {g | ((⇑UniformFun.ofFun ∘ swap F) x₀, g) ∈ UniformFun.gen ι α (s₂ ib)}) ↔
    ∀ (k₂ : κ₂), p₂ k₂ → ∃ k₁, p₁ k₁ ∧ ∀ x ∈ s₁ k₁, ∀ (i : ι), (F i x₀, F i x) ∈ s₂ k₂
tactic: rw [equicontinuousWithinAt_iff_continuousWithinAt, ContinuousWithinAt,
    hX.tendsto_iff (UniformFun.hasBasis_nhds_of_basis ι α _ hα)]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
κ₁ : Type u_13
κ₂ : Type u_14
p₁ : κ₁ → Prop
s₁ : κ₁ → Set X
p₂ : κ₂ → Prop
s₂ : κ₂ → Set (α × α)
F : ι → X → α
S : Set X
x₀ : X
hX : (𝓝[S] x₀).HasBasis p₁ s₁
hα : (𝓤 α).HasBasis p₂ s₂
⊢ (∀ (ib : κ₂),
      p₂ ib →
        ∃ ia,
          p₁ ia ∧
            ∀ x ∈ s₁ ia,
              (⇑UniformFun.ofFun ∘ swap F) x ∈
                {g | ((⇑UniformFun.ofFun ∘ swap F) x₀, g) ∈ UniformFun.gen ι α (s₂ ib)}) ↔
    ∀ (k₂ : κ₂), p₂ k₂ → ∃ k₁, p₁ k₁ ∧ ∀ x ∈ s₁ k₁, ∀ (i : ι), (F i x₀, F i x) ∈ s₂ k₂
state_after: no goals
tactic: rfl
Theorem: PNat.XgcdType.qp_eq
File: Mathlib/Data/PNat/Xgcd.lean

Proof steps:
state_before: u : XgcdType
hr : u.r = 0
⊢ u.q = u.qp + 1
state_after: case pos
u : XgcdType
hr : u.r = 0
hq : u.q = 0
⊢ u.q = u.qp + 1

case neg
u : XgcdType
hr : u.r = 0
hq : ¬u.q = 0
⊢ u.q = u.qp + 1
tactic: by_cases hq : u.q = 0
Theorem: AffineSubspace.wOppSide_of_left_mem
File: Mathlib/Analysis/Convex/Side.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✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
hx : x ∈ s
⊢ s.WOppSide x y
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
hx : x ∈ s
⊢ SameRay R (x -ᵥ x) (x -ᵥ y)
tactic: refine ⟨x, hx, x, hx, ?_⟩
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
hx : x ∈ s
⊢ SameRay R (x -ᵥ x) (x -ᵥ y)
state_after: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
hx : x ∈ s
⊢ SameRay R 0 (x -ᵥ y)
tactic: rw [vsub_self]
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁶ : StrictOrderedCommRing R
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
s : AffineSubspace R P
x y : P
hx : x ∈ s
⊢ SameRay R 0 (x -ᵥ y)
state_after: no goals
tactic: apply SameRay.zero_left
Theorem: jacobiTheta₂'_functional_equation
File: Mathlib/NumberTheory/ModularForms/JacobiTheta/TwoVariable.lean

Proof steps:
state_before: z τ : ℂ
⊢ jacobiTheta₂' z τ =
    1 / (-I * τ) ^ (1 / 2) * cexp (-↑π * I * z ^ 2 / τ) / τ *
      (jacobiTheta₂' (z / τ) (-1 / τ) - 2 * ↑π * I * z * jacobiTheta₂ (z / τ) (-1 / τ))
state_after: case inl
z τ : ℂ
hτ : τ.im ≤ 0
⊢ jacobiTheta₂' z τ =
    1 / (-I * τ) ^ (1 / 2) * cexp (-↑π * I * z ^ 2 / τ) / τ *
      (jacobiTheta₂' (z / τ) (-1 / τ) - 2 * ↑π * I * z * jacobiTheta₂ (z / τ) (-1 / τ))

case inr
z τ : ℂ
hτ : 0 < τ.im
⊢ jacobiTheta₂' z τ =
    1 / (-I * τ) ^ (1 / 2) * cexp (-↑π * I * z ^ 2 / τ) / τ *
      (jacobiTheta₂' (z / τ) (-1 / τ) - 2 * ↑π * I * z * jacobiTheta₂ (z / τ) (-1 / τ))
tactic: rcases le_or_lt (im τ) 0 with hτ | hτ
state_before: case inr
z τ : ℂ
hτ : 0 < τ.im
⊢ jacobiTheta₂' z τ =
    1 / (-I * τ) ^ (1 / 2) * cexp (-↑π * I * z ^ 2 / τ) / τ *
      (jacobiTheta₂' (z / τ) (-1 / τ) - 2 * ↑π * I * z * jacobiTheta₂ (z / τ) (-1 / τ))
state_after: case inr
z τ : ℂ
hτ : 0 < τ.im
hτ' : 0 < (-1 / τ).im
⊢ jacobiTheta₂' z τ =
    1 / (-I * τ) ^ (1 / 2) * cexp (-↑π * I * z ^ 2 / τ) / τ *
      (jacobiTheta₂' (z / τ) (-1 / τ) - 2 * ↑π * I * z * jacobiTheta₂ (z / τ) (-1 / τ))
tactic: have hτ' : 0 < (-1 / τ).im := by
    rw [div_eq_mul_inv, neg_one_mul, neg_im, inv_im, neg_div, neg_neg]
    exact div_pos hτ (normSq_pos.mpr (fun h ↦ lt_irrefl 0 (zero_im ▸ h ▸ hτ)))
state_before: case inr
z τ : ℂ
hτ : 0 < τ.im
hτ' : 0 < (-1 / τ).im
⊢ jacobiTheta₂' z τ =
    1 / (-I * τ) ^ (1 / 2) * cexp (-↑π * I * z ^ 2 / τ) / τ *
      (jacobiTheta₂' (z / τ) (-1 / τ) - 2 * ↑π * I * z * jacobiTheta₂ (z / τ) (-1 / τ))
state_after: case inr
z τ : ℂ
hτ : 0 < τ.im
hτ' : 0 < (-1 / τ).im
hj : HasDerivAt (fun w => jacobiTheta₂ (w / τ) (-1 / τ)) (1 / τ * jacobiTheta₂' (z / τ) (-1 / τ)) z
⊢ jacobiTheta₂' z τ =
    1 / (-I * τ) ^ (1 / 2) * cexp (-↑π * I * z ^ 2 / τ) / τ *
      (jacobiTheta₂' (z / τ) (-1 / τ) - 2 * ↑π * I * z * jacobiTheta₂ (z / τ) (-1 / τ))
tactic: have hj : HasDerivAt (fun w ↦ jacobiTheta₂ (w / τ) (-1 / τ))
      ((1 / τ) * jacobiTheta₂' (z / τ) (-1 / τ)) z := by
    have := hasDerivAt_jacobiTheta₂_fst (z / τ) hτ'
    simpa only [mul_comm, one_div] using this.comp z (hasDerivAt_mul_const τ⁻¹)
Theorem: mellin_comp_inv
File: Mathlib/Analysis/MellinTransform.lean

Proof steps:
state_before: E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → E
s : ℂ
⊢ mellin (fun t => f t⁻¹) s = mellin f (-s)
state_after: no goals
tactic: simp_rw [← rpow_neg_one, mellin_comp_rpow _ _ _, abs_neg, abs_one,
    inv_one, one_smul, ofReal_neg, ofReal_one, div_neg, div_one]
Theorem: FirstOrder.Language.LEquiv.addEmptyConstants_invLHom
File: Mathlib/ModelTheory/LanguageMap.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
inst✝ : L.Structure M
α : Type w'
ie : IsEmpty α
⊢ ((LHom.id L).sumElim (LHom.ofIsEmpty (constantsOn α) L)).comp (L.lhomWithConstants α) = LHom.id L
state_after: no goals
tactic: rw [lhomWithConstants, LHom.sumElim_comp_inl]
state_before: L : Language
L' : Language
M : Type w
inst✝ : L.Structure M
α : Type w'
ie : IsEmpty α
⊢ (L.lhomWithConstants α).comp ((LHom.id L).sumElim (LHom.ofIsEmpty (constantsOn α) L)) = LHom.id (L[[α]])
state_after: L : Language
L' : Language
M : Type w
inst✝ : L.Structure M
α : Type w'
ie : IsEmpty α
⊢ LHom.sumInl.sumElim (LHom.sumInl.comp (LHom.ofIsEmpty (constantsOn α) L)) = LHom.id (L[[α]])
tactic: simp only [LHom.comp_sumElim, lhomWithConstants, LHom.comp_id]
state_before: L : Language
L' : Language
M : Type w
inst✝ : L.Structure M
α : Type w'
ie : IsEmpty α
⊢ LHom.sumInl.sumElim (LHom.sumInl.comp (LHom.ofIsEmpty (constantsOn α) L)) = LHom.id (L[[α]])
state_after: no goals
tactic: exact _root_.trans (congr rfl (Subsingleton.elim _ _)) LHom.sumElim_inl_inr
Theorem: IsLocalization.smul_mk'_self
File: Mathlib/RingTheory/Localization/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝⁴ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝³ : CommSemiring S
inst✝² : Algebra R S
P : Type u_3
inst✝¹ : CommSemiring P
inst✝ : IsLocalization M S
m : ↥M
r : R
⊢ ↑m • mk' S r m = (algebraMap R S) r
state_after: no goals
tactic: rw [smul_mk', mk'_mul_cancel_left]
Theorem: Real.rpow_lt_rpow_of_exponent_gt
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x < 1
hyz : z < y
⊢ x ^ y < x ^ z
state_after: x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x < 1
hyz : z < y
⊢ rexp (log x * y) < rexp (log x * z)
tactic: repeat' rw [rpow_def_of_pos hx0]
state_before: x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x < 1
hyz : z < y
⊢ rexp (log x * y) < rexp (log x * z)
state_after: x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x < 1
hyz : z < y
⊢ log x * y < log x * z
tactic: rw [exp_lt_exp]
state_before: x y z : ℝ
n : ℕ
hx0 : 0 < x
hx1 : x < 1
hyz : z < y
⊢ log x * y < log x * z
state_after: no goals
tactic: exact mul_lt_mul_of_neg_left hyz (log_neg hx0 hx1)
Theorem: _private.Mathlib.NumberTheory.DiophantineApproximation.0.Real.invariant
File: Mathlib/NumberTheory/DiophantineApproximation.lean

Proof steps:
state_before: ξ : ℝ
u v : ℤ
hv : 2 ≤ v
h : ContfracLegendre.Ass ξ u v
⊢ ContfracLegendre.Ass (fract ξ)⁻¹ v (u - ⌊ξ⌋ * v)
state_after: case refine_1
ξ : ℝ
u v : ℤ
hv : 2 ≤ v
h : ContfracLegendre.Ass ξ u v
⊢ IsCoprime v (u - ⌊ξ⌋ * v)

case refine_2
ξ : ℝ
u v : ℤ
hv : 2 ≤ v
h : ContfracLegendre.Ass ξ u v
huv : u - ⌊ξ⌋ * v = 1
⊢ -(1 / 2) < (fract ξ)⁻¹ - ↑v
tactic: refine ⟨?_, fun huv => ?_, mod_cast aux₃ hv h⟩
Theorem: Polynomial.coeffs_ofSubring
File: Mathlib/RingTheory/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
S : Type u_1
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
T : Subring R
p : (↥T)[X]
⊢ ↑(ofSubring T p).coeffs ⊆ ↑T
state_after: no goals
tactic: classical
  intro i hi
  simp only [coeffs, Set.mem_image, mem_support_iff, Ne, Finset.mem_coe,
    (Finset.coe_image)] at hi
  rcases hi with ⟨n, _, h'n⟩
  rw [← h'n, coeff_ofSubring]
  exact Subtype.mem (coeff p n : T)
Theorem: MeasureTheory.upcrossingsBefore_bot
File: Mathlib/Probability/Martingale/Upcrossing.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f✝ : ℕ → Ω → ℝ
N n m : ℕ
ω✝ : Ω
ℱ : Filtration ℕ m0
inst✝² : Preorder ι
inst✝¹ : OrderBot ι
inst✝ : InfSet ι
a b : ℝ
f : ι → Ω → ℝ
ω : Ω
⊢ upcrossingsBefore a b f ⊥ ω = ⊥
state_after: no goals
tactic: simp [upcrossingsBefore]
Theorem: ExteriorAlgebra.GradedAlgebra.ι_sq_zero
File: Mathlib/LinearAlgebra/ExteriorAlgebra/Grading.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m : M
⊢ (GradedAlgebra.ι R M) m * (GradedAlgebra.ι R M) m = 0
state_after: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m : M
⊢ (DirectSum.of (fun i => ↥(⋀[R]^i M)) (1 + 1)) (GradedMonoid.GMul.mul ⟨(ι R) m, ⋯⟩ ⟨(ι R) m, ⋯⟩) = 0
tactic: rw [GradedAlgebra.ι_apply, DirectSum.of_mul_of]
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
m : M
⊢ (DirectSum.of (fun i => ↥(⋀[R]^i M)) (1 + 1)) (GradedMonoid.GMul.mul ⟨(ι R) m, ⋯⟩ ⟨(ι R) m, ⋯⟩) = 0
state_after: no goals
tactic: exact DFinsupp.single_eq_zero.mpr (Subtype.ext <| ExteriorAlgebra.ι_sq_zero _)
Theorem: SimpleGraph.Subgraph.isPerfectMatching_iff
File: Mathlib/Combinatorics/SimpleGraph/Matching.lean

Proof steps:
state_before: V : Type u_1
G G' : SimpleGraph V
M M' : G.Subgraph
v w : V
⊢ M.IsPerfectMatching ↔ ∀ (v : V), ∃! w, M.Adj v w
state_after: case refine_1
V : Type u_1
G G' : SimpleGraph V
M M' : G.Subgraph
v w : V
⊢ M.IsPerfectMatching → ∀ (v : V), ∃! w, M.Adj v w

case refine_2
V : Type u_1
G G' : SimpleGraph V
M M' : G.Subgraph
v✝ w : V
hm : ∀ (v : V), ∃! w, M.Adj v w
v : V
⊢ v ∈ M.verts
tactic: refine ⟨?_, fun hm => ⟨fun v _ => hm v, fun v => ?_⟩⟩
Theorem: Mathlib.Vector.traverse_eq_map_id
File: Mathlib/Data/Vector/Basic.lean

Proof steps:
state_before: n : ℕ
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α✝ β✝ γ : Type u
α β : Type u_1
f : α → β
⊢ ∀ (x : Vector α n), Vector.traverse (pure ∘ f) x = pure (map f x)
state_after: case mk
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α✝ β✝ γ : Type u
α β : Type u_1
f : α → β
x : List α
⊢ Vector.traverse (pure ∘ f) ⟨x, ⋯⟩ = pure (map f ⟨x, ⋯⟩)
tactic: rintro ⟨x, rfl⟩
state_before: case mk
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α✝ β✝ γ : Type u
α β : Type u_1
f : α → β
x : List α
⊢ Vector.traverse (pure ∘ f) ⟨x, ⋯⟩ = pure (map f ⟨x, ⋯⟩)
state_after: case mk
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α✝ β✝ γ : Type u
α β : Type u_1
f : α → β
x : List α
⊢ Mathlib.Vector.traverseAux (pure ∘ f) x = ⟨List.map f x, ⋯⟩
tactic: simp!
state_before: case mk
F G : Type u → Type u
inst✝² : Applicative F
inst✝¹ : Applicative G
inst✝ : LawfulApplicative G
α✝ β✝ γ : Type u
α β : Type u_1
f : α → β
x : List α
⊢ Mathlib.Vector.traverseAux (pure ∘ f) x = ⟨List.map f x, ⋯⟩
state_after: no goals
tactic: induction x <;> simp! [*, functor_norm] <;> rfl
Theorem: sub_lie
File: Mathlib/Algebra/Lie/Basic.lean

Proof steps:
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
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 N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
t : R
x y z : L
m n : M
⊢ ⁅x - y, m⁆ = ⁅x, m⁆ - ⁅y, m⁆
state_after: no goals
tactic: simp [sub_eq_add_neg]
Theorem: nmem_nonZeroDivisorsLeft_iff
File: Mathlib/Algebra/GroupWithZero/NonZeroDivisors.lean

Proof steps:
state_before: M₀ : Type u_1
inst✝ : MonoidWithZero M₀
r : M₀
⊢ r ∉ nonZeroDivisorsLeft M₀ ↔ {s | s * r = 0 ∧ s ≠ 0}.Nonempty
state_after: no goals
tactic: simpa [mem_nonZeroDivisorsLeft_iff] using Set.nonempty_def.symm
Theorem: mul_upperClosure
File: Mathlib/Algebra/Order/UpperLower.lean

Proof steps:
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ s * ↑(upperClosure t) = ↑(upperClosure (s * t))
state_after: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ ⋃ a ∈ s, a • ↑(upperClosure t) = ⋃ i ∈ s, ↑(i • upperClosure t)
tactic: simp_rw [← smul_eq_mul, ← Set.iUnion_smul_set, upperClosure_iUnion, upperClosure_smul,
    UpperSet.coe_iInf₂]
state_before: α : Type u_1
inst✝ : OrderedCommGroup α
s t : Set α
a : α
⊢ ⋃ a ∈ s, a • ↑(upperClosure t) = ⋃ i ∈ s, ↑(i • upperClosure t)
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.Limits.Concrete.isColimit_exists_rep
File: Mathlib/CategoryTheory/Limits/ConcreteCategory.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
J : Type w
inst✝¹ : Category.{r, w} J
F : J ⥤ C
inst✝ : PreservesColimit F (forget C)
D : Cocone F
hD : IsColimit D
x : (forget C).obj D.pt
⊢ ∃ j y, (D.ι.app j) y = x
state_after: case intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
J : Type w
inst✝¹ : Category.{r, w} J
F : J ⥤ C
inst✝ : PreservesColimit F (forget C)
D : Cocone F
hD : IsColimit D
a : (j : J) × (forget C).obj (F.obj j)
⊢ ∃ j y, (D.ι.app j) y = (fun a => (D.ι.app a.fst) a.snd) a
tactic: obtain ⟨a, rfl⟩ := Concrete.from_union_surjective_of_isColimit F hD x
state_before: case intro
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : ConcreteCategory C
J : Type w
inst✝¹ : Category.{r, w} J
F : J ⥤ C
inst✝ : PreservesColimit F (forget C)
D : Cocone F
hD : IsColimit D
a : (j : J) × (forget C).obj (F.obj j)
⊢ ∃ j y, (D.ι.app j) y = (fun a => (D.ι.app a.fst) a.snd) a
state_after: no goals
tactic: exact ⟨a.1, a.2, rfl⟩