ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: deriv.lhopital_zero_right_on_Ioo
File: Mathlib/Analysis/Calculus/LHopital.lean

Proof steps:
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf : DifferentiableOn ℝ f (Ioo a b)
hg' : ∀ x ∈ Ioo a b, deriv g x ≠ 0
hfa : Tendsto f (𝓝[>] a) (𝓝 0)
hga : Tendsto g (𝓝[>] a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝[>] a) l
⊢ Tendsto (fun x => f x / g x) (𝓝[>] a) l
state_after: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf✝ : DifferentiableOn ℝ f (Ioo a b)
hg' : ∀ x ∈ Ioo a b, deriv g x ≠ 0
hfa : Tendsto f (𝓝[>] a) (𝓝 0)
hga : Tendsto g (𝓝[>] a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝[>] a) l
hdf : ∀ x ∈ Ioo a b, DifferentiableAt ℝ f x
⊢ Tendsto (fun x => f x / g x) (𝓝[>] a) l
tactic: have hdf : ∀ x ∈ Ioo a b, DifferentiableAt ℝ f x := fun x hx =>
    (hdf x hx).differentiableAt (Ioo_mem_nhds hx.1 hx.2)
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf✝ : DifferentiableOn ℝ f (Ioo a b)
hg' : ∀ x ∈ Ioo a b, deriv g x ≠ 0
hfa : Tendsto f (𝓝[>] a) (𝓝 0)
hga : Tendsto g (𝓝[>] a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝[>] a) l
hdf : ∀ x ∈ Ioo a b, DifferentiableAt ℝ f x
⊢ Tendsto (fun x => f x / g x) (𝓝[>] a) l
state_after: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf✝ : DifferentiableOn ℝ f (Ioo a b)
hg' : ∀ x ∈ Ioo a b, deriv g x ≠ 0
hfa : Tendsto f (𝓝[>] a) (𝓝 0)
hga : Tendsto g (𝓝[>] a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝[>] a) l
hdf : ∀ x ∈ Ioo a b, DifferentiableAt ℝ f x
hdg : ∀ x ∈ Ioo a b, DifferentiableAt ℝ g x
⊢ Tendsto (fun x => f x / g x) (𝓝[>] a) l
tactic: have hdg : ∀ x ∈ Ioo a b, DifferentiableAt ℝ g x := fun x hx =>
    by_contradiction fun h => hg' x hx (deriv_zero_of_not_differentiableAt h)
state_before: a b : ℝ
hab : a < b
l : Filter ℝ
f f' g g' : ℝ → ℝ
hdf✝ : DifferentiableOn ℝ f (Ioo a b)
hg' : ∀ x ∈ Ioo a b, deriv g x ≠ 0
hfa : Tendsto f (𝓝[>] a) (𝓝 0)
hga : Tendsto g (𝓝[>] a) (𝓝 0)
hdiv : Tendsto (fun x => deriv f x / deriv g x) (𝓝[>] a) l
hdf : ∀ x ∈ Ioo a b, DifferentiableAt ℝ f x
hdg : ∀ x ∈ Ioo a b, DifferentiableAt ℝ g x
⊢ Tendsto (fun x => f x / g x) (𝓝[>] a) l
state_after: no goals
tactic: exact HasDerivAt.lhopital_zero_right_on_Ioo hab (fun x hx => (hdf x hx).hasDerivAt)
    (fun x hx => (hdg x hx).hasDerivAt) hg' hfa hga hdiv
Theorem: Set.preimage_inr_image_inl
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s✝ t s : Set α
⊢ Sum.inr ⁻¹' (Sum.inl '' s) = ∅
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s✝ t s : Set α
x✝ : β
⊢ x✝ ∈ Sum.inr ⁻¹' (Sum.inl '' s) ↔ x✝ ∈ ∅
tactic: ext
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f : ι → α
s✝ t s : Set α
x✝ : β
⊢ x✝ ∈ Sum.inr ⁻¹' (Sum.inl '' s) ↔ x✝ ∈ ∅
state_after: no goals
tactic: simp
Theorem: ProbabilityTheory.Kernel.measurable_kernel_prod_mk_left_of_finite
File: Mathlib/Probability/Kernel/MeasurableIntegral.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) ∅

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ ∀ t ∈ image2 (fun x x_1 => x ×ˢ x_1) {s | MeasurableSet s} {t | MeasurableSet t},
    (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) t

case refine_3
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ ∀ (t : Set (α × β)),
    MeasurableSet t →
      (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) t →
        (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) tᶜ

case refine_4
α : Type u_1
β : Type u_2
γ : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
mγ : MeasurableSpace γ
κ : Kernel α β
η : Kernel (α × β) γ
a : α
t : Set (α × β)
ht : MeasurableSet t
hκs : ∀ (a : α), IsFiniteMeasure (κ a)
⊢ ∀ (f : ℕ → Set (α × β)),
    Pairwise (Disjoint on f) →
      (∀ (i : ℕ), MeasurableSet (f i)) →
        (∀ (i : ℕ), (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (f i)) →
          (fun t => Measurable fun a => (κ a) (Prod.mk a ⁻¹' t)) (⋃ i, f i)
tactic: refine MeasurableSpace.induction_on_inter
    (C := fun t => Measurable fun a => κ a (Prod.mk a ⁻¹' t))
    generateFrom_prod.symm isPiSystem_prod ?_ ?_ ?_ ?_ ht
Theorem: Function.Periodic.map_mod_nat
File: Mathlib/Data/Nat/Periodic.lean

Proof steps:
state_before: α : Type u_1
f : ℕ → α
a : ℕ
hf : Periodic f a
n : ℕ
⊢ f (n % a) = f n
state_after: no goals
tactic: conv_rhs => rw [← Nat.mod_add_div n a, mul_comm, ← Nat.nsmul_eq_mul, hf.nsmul]
Theorem: Ordinal.log_zero_right
File: Mathlib/SetTheory/Ordinal/Exponential.lean

Proof steps:
state_before: b : Ordinal.{u_1}
b1 : 1 < b
⊢ log b 0 = 0
state_after: b : Ordinal.{u_1}
b1 : 1 < b
⊢ sInf {o | 0 < b ^ o} ≤ succ 0
tactic: rw [log_def b1, ← Ordinal.le_zero, pred_le]
state_before: b : Ordinal.{u_1}
b1 : 1 < b
⊢ sInf {o | 0 < b ^ o} ≤ succ 0
state_after: case h
b : Ordinal.{u_1}
b1 : 1 < b
⊢ succ 0 ∈ {o | 0 < b ^ o}
tactic: apply csInf_le'
state_before: case h
b : Ordinal.{u_1}
b1 : 1 < b
⊢ succ 0 ∈ {o | 0 < b ^ o}
state_after: case h
b : Ordinal.{u_1}
b1 : 1 < b
⊢ 0 < b ^ succ 0
tactic: dsimp
state_before: case h
b : Ordinal.{u_1}
b1 : 1 < b
⊢ 0 < b ^ succ 0
state_after: case h
b : Ordinal.{u_1}
b1 : 1 < b
⊢ 0 < b
tactic: rw [succ_zero, opow_one]
state_before: case h
b : Ordinal.{u_1}
b1 : 1 < b
⊢ 0 < b
state_after: no goals
tactic: exact zero_lt_one.trans b1
state_before: b : Ordinal.{u_1}
b1 : ¬1 < b
⊢ log b 0 = 0
state_after: no goals
tactic: simp only [log_of_not_one_lt_left b1]
Theorem: ComplexShape.Embedding.BoundaryGE.false_of_isTruncLE
File: Mathlib/Algebra/Homology/Embedding/Boundary.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
j : ι
hj : e.BoundaryGE j
inst✝ : e.IsTruncLE
⊢ False
state_after: case intro
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
j : ι
hj : e.BoundaryGE j
inst✝ : e.IsTruncLE
i : ι
hi : e.f i = c'.prev (e.f j)
⊢ False
tactic: obtain ⟨i, hi⟩ := e.mem_prev hj.1
state_before: case intro
ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
j : ι
hj : e.BoundaryGE j
inst✝ : e.IsTruncLE
i : ι
hi : e.f i = c'.prev (e.f j)
⊢ False
state_after: no goals
tactic: exact hj.2 i (by simpa only [hi] using hj.1)
Theorem: Filter.Germ.const_abs
File: Mathlib/Order/Filter/FilterProduct.lean

Proof steps:
state_before: α : Type u
β : Type v
φ : Ultrafilter α
inst✝ : LinearOrderedAddCommGroup β
x : β
⊢ ↑|x| = |↑x|
state_after: no goals
tactic: rw [abs_def, map_const]
Theorem: Submonoid.LocalizationMap.eq_of_eq
File: Mathlib/GroupTheory/MonoidLocalization/Basic.lean

Proof steps:
state_before: M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
x y : M
h : f.toMap x = f.toMap y
⊢ g x = g y
state_after: case intro
M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
x y : M
h : f.toMap x = f.toMap y
c : ↥S
hc : ↑c * x = ↑c * y
⊢ g x = g y
tactic: obtain ⟨c, hc⟩ := f.eq_iff_exists.1 h
state_before: case intro
M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
x y : M
h : f.toMap x = f.toMap y
c : ↥S
hc : ↑c * x = ↑c * y
⊢ g x = g y
state_after: case intro
M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
x y : M
h : f.toMap x = f.toMap y
c : ↥S
hc : ↑c * x = ↑c * y
⊢ ↑((IsUnit.liftRight (g.restrict S) hg) c)⁻¹ * (g.restrict S) c * g x = g y
tactic: rw [← one_mul (g x), ← IsUnit.liftRight_inv_mul (g.restrict S) hg c]
state_before: case intro
M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
x y : M
h : f.toMap x = f.toMap y
c : ↥S
hc : ↑c * x = ↑c * y
⊢ ↑((IsUnit.liftRight (g.restrict S) hg) c)⁻¹ * (g.restrict S) c * g x = g y
state_after: case intro
M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
x y : M
h : f.toMap x = f.toMap y
c : ↥S
hc : ↑c * x = ↑c * y
⊢ ↑((IsUnit.liftRight (g.restrict S) hg) c)⁻¹ * g ↑c * g x = g y
tactic: show _ * g c * _ = _
state_before: case intro
M : Type u_1
inst✝² : CommMonoid M
S : Submonoid M
N : Type u_2
inst✝¹ : CommMonoid N
P : Type u_3
inst✝ : CommMonoid P
f : S.LocalizationMap N
g : M →* P
hg : ∀ (y : ↥S), IsUnit (g ↑y)
x y : M
h : f.toMap x = f.toMap y
c : ↥S
hc : ↑c * x = ↑c * y
⊢ ↑((IsUnit.liftRight (g.restrict S) hg) c)⁻¹ * g ↑c * g x = g y
state_after: no goals
tactic: rw [mul_assoc, ← g.map_mul, hc, mul_comm, mul_inv_left hg, g.map_mul]
Theorem: Complex.GammaIntegral_one
File: Mathlib/Analysis/SpecialFunctions/Gamma/Basic.lean

Proof steps:
state_before: ⊢ GammaIntegral 1 = 1
state_after: no goals
tactic: simpa only [← ofReal_one, GammaIntegral_ofReal, ofReal_inj, sub_self, rpow_zero,
    mul_one] using integral_exp_neg_Ioi_zero
Theorem: Filter.EventuallyEq.lineDeriv_eq
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ : E → F
f' : F
s t : Set E
x v : E
L : E →L[𝕜] F
h : f₁ =ᶠ[𝓝 x] f
⊢ lineDeriv 𝕜 f₁ x v = lineDeriv 𝕜 f x v
state_after: no goals
tactic: rw [← lineDerivWithin_univ, ← lineDerivWithin_univ, h.lineDerivWithin_eq_nhds]
Theorem: MeasureTheory.setToFun_zero
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f g : α → E
hT : DominatedFinMeasAdditive μ T C
⊢ setToFun μ T hT 0 = 0
state_after: no goals
tactic: erw [setToFun_eq hT (integrable_zero _ _ _), Integrable.toL1_zero, ContinuousLinearMap.map_zero]
Theorem: List.oldMapIdxCore_append
File: Mathlib/Data/List/Indexes.lean

Proof steps:
state_before: α : Type u
β : Type v
⊢ ∀ (f : ℕ → α → β) (n : ℕ) (l₁ l₂ : List α),
    List.oldMapIdxCore f n (l₁ ++ l₂) = List.oldMapIdxCore f n l₁ ++ List.oldMapIdxCore f (n + l₁.length) l₂
state_after: α : Type u
β : Type v
f : ℕ → α → β
n : ℕ
l₁ l₂ : List α
⊢ List.oldMapIdxCore f n (l₁ ++ l₂) = List.oldMapIdxCore f n l₁ ++ List.oldMapIdxCore f (n + l₁.length) l₂
tactic: intros f n l₁ l₂
state_before: α : Type u
β : Type v
f : ℕ → α → β
n : ℕ
l₁ l₂ : List α
⊢ List.oldMapIdxCore f n (l₁ ++ l₂) = List.oldMapIdxCore f n l₁ ++ List.oldMapIdxCore f (n + l₁.length) l₂
state_after: α : Type u
β : Type v
f : ℕ → α → β
n : ℕ
l₁ l₂ : List α
len : ℕ
e : (l₁ ++ l₂).length = len
⊢ List.oldMapIdxCore f n (l₁ ++ l₂) = List.oldMapIdxCore f n l₁ ++ List.oldMapIdxCore f (n + l₁.length) l₂
tactic: generalize e : (l₁ ++ l₂).length = len
state_before: α : Type u
β : Type v
f : ℕ → α → β
n : ℕ
l₁ l₂ : List α
len : ℕ
e : (l₁ ++ l₂).length = len
⊢ List.oldMapIdxCore f n (l₁ ++ l₂) = List.oldMapIdxCore f n l₁ ++ List.oldMapIdxCore f (n + l₁.length) l₂
state_after: α : Type u
β : Type v
f : ℕ → α → β
len : ℕ
⊢ ∀ (n : ℕ) (l₁ l₂ : List α),
    (l₁ ++ l₂).length = len →
      List.oldMapIdxCore f n (l₁ ++ l₂) = List.oldMapIdxCore f n l₁ ++ List.oldMapIdxCore f (n + l₁.length) l₂
tactic: revert n l₁ l₂
state_before: α : Type u
β : Type v
f : ℕ → α → β
len : ℕ
⊢ ∀ (n : ℕ) (l₁ l₂ : List α),
    (l₁ ++ l₂).length = len →
      List.oldMapIdxCore f n (l₁ ++ l₂) = List.oldMapIdxCore f n l₁ ++ List.oldMapIdxCore f (n + l₁.length) l₂
state_after: case zero
α : Type u
β : Type v
f : ℕ → α → β
n : ℕ
l₁ l₂ : List α
h : (l₁ ++ l₂).length = 0
⊢ List.oldMapIdxCore f n (l₁ ++ l₂) = List.oldMapIdxCore f n l₁ ++ List.oldMapIdxCore f (n + l₁.length) l₂

case succ
α : Type u
β : Type v
f : ℕ → α → β
len : ℕ
ih :
  ∀ (n : ℕ) (l₁ l₂ : List α),
    (l₁ ++ l₂).length = len →
      List.oldMapIdxCore f n (l₁ ++ l₂) = List.oldMapIdxCore f n l₁ ++ List.oldMapIdxCore f (n + l₁.length) l₂
n : ℕ
l₁ l₂ : List α
h : (l₁ ++ l₂).length = len + 1
⊢ List.oldMapIdxCore f n (l₁ ++ l₂) = List.oldMapIdxCore f n l₁ ++ List.oldMapIdxCore f (n + l₁.length) l₂
tactic: induction' len with len ih <;> intros n l₁ l₂ h
Theorem: IsUnit.isNilpotent_mul_unit_of_commute_iff
File: Mathlib/RingTheory/Nilpotent/Defs.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
x y : R
inst✝ : MonoidWithZero R
r u : R
hu : IsUnit u
h_comm : Commute r u
n : ℕ
⊢ (r * u) ^ n = 0 ↔ r ^ n = 0
state_after: no goals
tactic: rw [h_comm.mul_pow, (hu.pow n).mul_left_eq_zero]
Theorem: Polynomial.degree_pos_of_root
File: Mathlib/Algebra/Polynomial/Degree/Lemmas.lean

Proof steps:
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
hp : p ≠ 0
h : p.IsRoot a
hlt : 0 ≥ p.degree
⊢ False
state_after: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
hp : p ≠ 0
h : p.IsRoot a
hlt : 0 ≥ p.degree
this : p = C (p.coeff 0)
⊢ False
tactic: have := eq_C_of_degree_le_zero hlt
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
hp : p ≠ 0
h : p.IsRoot a
hlt : 0 ≥ p.degree
this : p = C (p.coeff 0)
⊢ False
state_after: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
hp : p ≠ 0
h : p.coeff 0 = 0
hlt : 0 ≥ p.degree
this : p = C (p.coeff 0)
⊢ False
tactic: rw [IsRoot, this, eval_C] at h
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
hp : p ≠ 0
h : p.coeff 0 = 0
hlt : 0 ≥ p.degree
this : p = C (p.coeff 0)
⊢ False
state_after: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
hp : p ≠ 0
h : p.coeff 0 = 0
hlt : 0 ≥ p.degree
this : p = 0
⊢ False
tactic: simp only [h, RingHom.map_zero] at this
state_before: R : Type u
S : Type v
ι : Type w
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r p : R[X]
hp : p ≠ 0
h : p.coeff 0 = 0
hlt : 0 ≥ p.degree
this : p = 0
⊢ False
state_after: no goals
tactic: exact hp this
Theorem: Matrix.IsHermitian.fromBlocks₂₂
File: Mathlib/LinearAlgebra/Matrix/SchurComplement.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
𝕜 : Type u_5
inst✝⁵ : CommRing 𝕜
inst✝⁴ : PartialOrder 𝕜
inst✝³ : StarRing 𝕜
inst✝² : StarOrderedRing 𝕜
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix m m 𝕜
B : Matrix m n 𝕜
D : Matrix n n 𝕜
hD : D.IsHermitian
⊢ (Matrix.fromBlocks A B Bᴴ D).IsHermitian ↔ (A - B * D⁻¹ * Bᴴ).IsHermitian
state_after: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
𝕜 : Type u_5
inst✝⁵ : CommRing 𝕜
inst✝⁴ : PartialOrder 𝕜
inst✝³ : StarRing 𝕜
inst✝² : StarOrderedRing 𝕜
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix m m 𝕜
B : Matrix m n 𝕜
D : Matrix n n 𝕜
hD : D.IsHermitian
⊢ (Matrix.fromBlocks D Bᴴ B A).IsHermitian ↔ (A - B * D⁻¹ * Bᴴ).IsHermitian
tactic: rw [← isHermitian_submatrix_equiv (Equiv.sumComm n m), Equiv.sumComm_apply,
    fromBlocks_submatrix_sum_swap_sum_swap]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
𝕜 : Type u_5
inst✝⁵ : CommRing 𝕜
inst✝⁴ : PartialOrder 𝕜
inst✝³ : StarRing 𝕜
inst✝² : StarOrderedRing 𝕜
inst✝¹ : Fintype n
inst✝ : DecidableEq n
A : Matrix m m 𝕜
B : Matrix m n 𝕜
D : Matrix n n 𝕜
hD : D.IsHermitian
⊢ (Matrix.fromBlocks D Bᴴ B A).IsHermitian ↔ (A - B * D⁻¹ * Bᴴ).IsHermitian
state_after: no goals
tactic: convert IsHermitian.fromBlocks₁₁ _ _ hD <;> simp
Theorem: Int.lcm_comm
File: Mathlib/Data/Int/GCD.lean

Proof steps:
state_before: i j : ℤ
⊢ i.lcm j = j.lcm i
state_after: i j : ℤ
⊢ i.natAbs.lcm j.natAbs = j.natAbs.lcm i.natAbs
tactic: rw [Int.lcm, Int.lcm]
state_before: i j : ℤ
⊢ i.natAbs.lcm j.natAbs = j.natAbs.lcm i.natAbs
state_after: no goals
tactic: exact Nat.lcm_comm _ _
Theorem: CoxeterSystem.alternatingWord_succ'
File: Mathlib/GroupTheory/Coxeter/Basic.lean

Proof steps:
state_before: B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
i i' : B
m : ℕ
⊢ alternatingWord i i' (m + 1) = (if Even m then i' else i) :: alternatingWord i i' m
state_after: case zero
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
i i' : B
⊢ alternatingWord i i' (0 + 1) = (if Even 0 then i' else i) :: alternatingWord i i' 0

case succ
B : Type u_1
B' : Type u_2
e : B ≃ B'
W : Type u_3
H : Type u_4
inst✝¹ : Group W
inst✝ : Group H
M : CoxeterMatrix B
cs : CoxeterSystem M W
m : ℕ
ih : ∀ (i i' : B), alternatingWord i i' (m + 1) = (if Even m then i' else i) :: alternatingWord i i' m
i i' : B
⊢ alternatingWord i i' (m + 1 + 1) = (if Even (m + 1) then i' else i) :: alternatingWord i i' (m + 1)
tactic: induction' m with m ih generalizing i i'
Theorem: ZMod.intCast_zmod_eq_zero_iff_dvd
File: Mathlib/Data/ZMod/Basic.lean

Proof steps:
state_before: m n : ℕ
a : ℤ
b : ℕ
⊢ ↑a = 0 ↔ ↑b ∣ a
state_after: no goals
tactic: rw [← Int.cast_zero, ZMod.intCast_eq_intCast_iff, Int.modEq_zero_iff_dvd]
Theorem: Matroid.Indep.subset_basis'_of_subset
File: Mathlib/Data/Matroid/Basic.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hI : M.Indep I
hIX : I ⊆ X
⊢ ∃ J, M.Basis' J X ∧ I ⊆ J
state_after: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hI : M.Indep I
hIX : I ⊆ X
⊢ ∃ J, M.Basis J (X ∩ M.E) ∧ I ⊆ J
tactic: simp_rw [basis'_iff_basis_inter_ground]
state_before: α : Type u_1
M : Matroid α
B I J X Y : Set α
e : α
hI : M.Indep I
hIX : I ⊆ X
⊢ ∃ J, M.Basis J (X ∩ M.E) ∧ I ⊆ J
state_after: no goals
tactic: exact hI.subset_basis_of_subset (subset_inter hIX hI.subset_ground)
Theorem: Composition.mem_range_embedding
File: Mathlib/Combinatorics/Enumerative/Composition.lean

Proof steps:
state_before: n : ℕ
c : Composition n
j : Fin n
⊢ j ∈ Set.range ⇑(c.embedding (c.index j))
state_after: n : ℕ
c : Composition n
j : Fin n
this : (c.embedding (c.index j)) (c.invEmbedding j) ∈ Set.range ⇑(c.embedding (c.index j))
⊢ j ∈ Set.range ⇑(c.embedding (c.index j))
tactic: have : c.embedding (c.index j) (c.invEmbedding j) ∈ Set.range (c.embedding (c.index j)) :=
    Set.mem_range_self _
state_before: n : ℕ
c : Composition n
j : Fin n
this : (c.embedding (c.index j)) (c.invEmbedding j) ∈ Set.range ⇑(c.embedding (c.index j))
⊢ j ∈ Set.range ⇑(c.embedding (c.index j))
state_after: no goals
tactic: rwa [c.embedding_comp_inv j] at this
Theorem: LocalRing.subsingleton_cotangentSpace_iff
File: Mathlib/RingTheory/Ideal/Cotangent.lean

Proof steps:
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : LocalRing R
inst✝ : IsNoetherianRing R
⊢ Subsingleton (CotangentSpace R) ↔ IsField R
state_after: R : Type u_1
inst✝² : CommRing R
inst✝¹ : LocalRing R
inst✝ : IsNoetherianRing R
⊢ IsIdempotentElem (maximalIdeal R) ↔ IsField R
tactic: refine (maximalIdeal R).cotangent_subsingleton_iff.trans ?_
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : LocalRing R
inst✝ : IsNoetherianRing R
⊢ IsIdempotentElem (maximalIdeal R) ↔ IsField R
state_after: R : Type u_1
inst✝² : CommRing R
inst✝¹ : LocalRing R
inst✝ : IsNoetherianRing R
⊢ maximalIdeal R = ⊥ ∨ maximalIdeal R = ⊤ ↔ maximalIdeal R = ⊥
tactic: rw [LocalRing.isField_iff_maximalIdeal_eq, Ideal.isIdempotentElem_iff_eq_bot_or_top_of_localRing]
state_before: R : Type u_1
inst✝² : CommRing R
inst✝¹ : LocalRing R
inst✝ : IsNoetherianRing R
⊢ maximalIdeal R = ⊥ ∨ maximalIdeal R = ⊤ ↔ maximalIdeal R = ⊥
state_after: no goals
tactic: simp [(maximalIdeal.isMaximal R).ne_top]
Theorem: CategoryTheory.Limits.lift_comp_kernelIsoOfEq_hom
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
Z : C
f g : X ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasKernel g
h : f = g
e : Z ⟶ X
he : e ≫ f = 0
⊢ e ≫ g = 0
state_after: no goals
tactic: simp [← h, he]
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
Z : C
f g : X ⟶ Y
inst✝¹ : HasKernel f
inst✝ : HasKernel g
h : f = g
e : Z ⟶ X
he : e ≫ f = 0
⊢ kernel.lift f e he ≫ (kernelIsoOfEq h).hom = kernel.lift g e ⋯
state_after: case refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
Z : C
f : X ⟶ Y
inst✝¹ : HasKernel f
e : Z ⟶ X
he : e ≫ f = 0
inst✝ : HasKernel f
⊢ kernel.lift f e he ≫ (kernelIsoOfEq ⋯).hom = kernel.lift f e ⋯
tactic: cases h
state_before: case refl
C : Type u
inst✝⁴ : Category.{v, u} C
inst✝³ : HasZeroMorphisms C
X Y : C
f✝ : X ⟶ Y
inst✝² : HasKernel f✝
Z : C
f : X ⟶ Y
inst✝¹ : HasKernel f
e : Z ⟶ X
he : e ≫ f = 0
inst✝ : HasKernel f
⊢ kernel.lift f e he ≫ (kernelIsoOfEq ⋯).hom = kernel.lift f e ⋯
state_after: no goals
tactic: simp
Theorem: Set.preimage_mul_const_Ioo
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : 0 < c
⊢ (fun x => x * c) ⁻¹' Ioo a b = Ioo (a / c) (b / c)
state_after: no goals
tactic: simp [← Ioi_inter_Iio, h]
Theorem: NNReal.geom_mean_le_arith_mean4_weighted
File: Mathlib/Analysis/MeanInequalities.lean

Proof steps:
state_before: ι : Type u
s : Finset ι
w₁ w₂ w₃ w₄ p₁ p₂ p₃ p₄ : ℝ≥0
⊢ w₁ + w₂ + w₃ + w₄ = 1 → p₁ ^ ↑w₁ * p₂ ^ ↑w₂ * p₃ ^ ↑w₃ * p₄ ^ ↑w₄ ≤ w₁ * p₁ + w₂ * p₂ + w₃ * p₃ + w₄ * p₄
state_after: no goals
tactic: simpa only [Fin.prod_univ_succ, Fin.sum_univ_succ, Finset.prod_empty, Finset.sum_empty,
    Finset.univ_eq_empty, Fin.cons_succ, Fin.cons_zero, add_zero, mul_one, ← add_assoc,
    mul_assoc] using geom_mean_le_arith_mean_weighted univ ![w₁, w₂, w₃, w₄] ![p₁, p₂, p₃, p₄]
Theorem: Matroid.ground_indep_iff_eq_freeOn
File: Mathlib/Data/Matroid/Constructions.lean

Proof steps:
state_before: α : Type u_1
M : Matroid α
E B I X R J : Set α
⊢ M.Indep M.E ↔ M = freeOn M.E
state_after: no goals
tactic: simp [eq_freeOn_iff]
Theorem: eq_of_germ_isConstant
File: Mathlib/Topology/Germ.lean

Proof steps:
state_before: F : Type u_1
G : Type u_2
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
X : Type u_3
Y : Type u_4
Z : Type u_5
inst✝ : TopologicalSpace X
f g : X → Y
A : Set X
x✝ : X
i : PreconnectedSpace X
h : ∀ (x : X), (↑f).IsConstant
x x' : X
⊢ x ∈ univ
state_after: no goals
tactic: trivial
state_before: F : Type u_1
G : Type u_2
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace ℝ F
inst✝² : NormedAddCommGroup G
inst✝¹ : NormedSpace ℝ G
X : Type u_3
Y : Type u_4
Z : Type u_5
inst✝ : TopologicalSpace X
f g : X → Y
A : Set X
x✝ : X
i : PreconnectedSpace X
h : ∀ (x : X), (↑f).IsConstant
x x' : X
⊢ x' ∈ univ
state_after: no goals
tactic: trivial