ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: integrableOn_Ici_iff_integrableOn_Ioi
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
inst✝ : NoAtoms μ
⊢ μ {b} ≠ ⊤
state_after: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
inst✝ : NoAtoms μ
⊢ 0 ≠ ⊤
tactic: rw [measure_singleton]
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
inst✝² : PartialOrder α
inst✝¹ : MeasurableSingletonClass α
f : α → E
μ : Measure α
a b : α
inst✝ : NoAtoms μ
⊢ 0 ≠ ⊤
state_after: no goals
tactic: exact ENNReal.zero_ne_top
Theorem: squarefree_iff_irreducible_sq_not_dvd_of_exists_irreducible
File: Mathlib/Algebra/Squarefree/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
r : R
hr : ∃ x, Irreducible x
⊢ Squarefree r ↔ ∀ (x : R), Irreducible x → ¬x * x ∣ r
state_after: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
r : R
hr : ∃ x, Irreducible x
⊢ Squarefree r ↔ (r = 0 ∧ ¬∃ x, Irreducible x) ∨ Squarefree r
tactic: rw [irreducible_sq_not_dvd_iff_eq_zero_and_no_irreducibles_or_squarefree, ← not_exists]
state_before: R : Type u_1
inst✝¹ : CommMonoidWithZero R
inst✝ : WfDvdMonoid R
r : R
hr : ∃ x, Irreducible x
⊢ Squarefree r ↔ (r = 0 ∧ ¬∃ x, Irreducible x) ∨ Squarefree r
state_after: no goals
tactic: simp only [hr, not_true, false_or_iff, and_false_iff]
Theorem: MeasureTheory.Measure.sub_eq_zero_of_le
File: Mathlib/MeasureTheory/Measure/Sub.lean

Proof steps:
state_before: α : Type u_1
m : MeasurableSpace α
μ ν : Measure α
s : Set α
h : μ ≤ ν
⊢ μ ≤ 0 + ν
state_after: no goals
tactic: rwa [zero_add]
Theorem: EReal.add_top_of_ne_bot
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x : EReal
h : x ≠ ⊥
⊢ x + ⊤ = ⊤
state_after: no goals
tactic: rw [add_comm, top_add_of_ne_bot h]
Theorem: intervalIntegral.integral_eq_zero_iff_of_le_of_nonneg_ae
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
f g : ℝ → ℝ
a b : ℝ
μ : Measure ℝ
hab : a ≤ b
hf : 0 ≤ᶠ[ae (μ.restrict (Ioc a b))] f
hfi : IntervalIntegrable f μ a b
⊢ ∫ (x : ℝ) in a..b, f x ∂μ = 0 ↔ f =ᶠ[ae (μ.restrict (Ioc a b))] 0
state_after: no goals
tactic: rw [integral_of_le hab, integral_eq_zero_iff_of_nonneg_ae hf hfi.1]
Theorem: CategoryTheory.Functor.map_inv_hom
File: Mathlib/CategoryTheory/Iso.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z : C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
F : C ⥤ D
X Y : C
f : X ⟶ Y
inst✝ : IsIso f
⊢ F.map (inv f) ≫ F.map f = 𝟙 (F.obj Y)
state_after: no goals
tactic: simp
Theorem: CategoryTheory.Limits.inr_inr_pushoutAssoc_inv
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/Assoc.lean

Proof steps:
state_before: C : Type u
inst✝⁴ : Category.{v, u} C
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr g₁ g₂) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl g₃ g₄)
⊢ pushout.inr g₃ g₄ ≫ pushout.inr g₁ (g₂ ≫ pushout.inl g₃ g₄) ≫ (pushoutAssoc g₁ g₂ g₃ g₄).inv =
    pushout.inr (g₃ ≫ pushout.inr g₁ g₂) g₄
state_after: C : Type u
inst✝⁴ : Category.{v, u} C
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr g₁ g₂) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl g₃ g₄)
⊢ pushout.inr g₃ g₄ ≫ pushout.inr g₁ (g₂ ≫ pushout.inl g₃ g₄) ≫ (pushoutAssoc g₁ g₂ g₃ g₄).inv =
    pushout.inr g₃ g₄ ≫
      pushout.desc (pushout.inr g₁ g₂ ≫ pushout.inl (g₃ ≫ pushout.inr g₁ g₂) g₄)
        (pushout.inr (g₃ ≫ pushout.inr g₁ g₂) g₄) ⋯

C : Type u
inst✝⁴ : Category.{v, u} C
W X Y Z X₁ X₂ X₃ Z₁ Z₂ : C
g₁ : Z₁ ⟶ X₁
g₂ : Z₁ ⟶ X₂
g₃ : Z₂ ⟶ X₂
g₄ : Z₂ ⟶ X₃
inst✝³ : HasPushout g₁ g₂
inst✝² : HasPushout g₃ g₄
inst✝¹ : HasPushout (g₃ ≫ pushout.inr g₁ g₂) g₄
inst✝ : HasPushout g₁ (g₂ ≫ pushout.inl g₃ g₄)
⊢ pushout.inr g₃ g₄ ≫
      pushout.desc (pushout.inr g₁ g₂ ≫ pushout.inl (g₃ ≫ pushout.inr g₁ g₂) g₄)
        (pushout.inr (g₃ ≫ pushout.inr g₁ g₂) g₄) ⋯ =
    pushout.inr (g₃ ≫ pushout.inr g₁ g₂) g₄
tactic: trans f₄ ≫ l₂'
Theorem: HurwitzZeta.differentiable_hurwitzZeta_sub_hurwitzZeta
File: Mathlib/NumberTheory/LSeries/HurwitzZeta.lean

Proof steps:
state_before: a b : UnitAddCircle
⊢ Differentiable ℂ fun s => hurwitzZeta a s - hurwitzZeta b s
state_after: a b : UnitAddCircle
⊢ Differentiable ℂ fun s => hurwitzZetaEven a s - hurwitzZetaEven b s + (hurwitzZetaOdd a s - hurwitzZetaOdd b s)
tactic: simp only [hurwitzZeta, add_sub_add_comm]
state_before: a b : UnitAddCircle
⊢ Differentiable ℂ fun s => hurwitzZetaEven a s - hurwitzZetaEven b s + (hurwitzZetaOdd a s - hurwitzZetaOdd b s)
state_after: case refine_1
a b : UnitAddCircle
⊢ Differentiable ℂ (hurwitzZetaOdd a)

case refine_2
a b : UnitAddCircle
⊢ Differentiable ℂ (hurwitzZetaOdd b)
tactic: refine (differentiable_hurwitzZetaEven_sub_hurwitzZetaEven a b).add (Differentiable.sub ?_ ?_)
state_before: case refine_1
a b : UnitAddCircle
⊢ Differentiable ℂ (hurwitzZetaOdd a)

case refine_2
a b : UnitAddCircle
⊢ Differentiable ℂ (hurwitzZetaOdd b)
state_after: no goals
tactic: all_goals apply differentiable_hurwitzZetaOdd
Theorem: starConvex_zero_iff
File: Mathlib/Analysis/Convex/Star.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : OrderedRing 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMulWithZero 𝕜 E
s : Set E
⊢ StarConvex 𝕜 0 s ↔ ∀ ⦃x : E⦄, x ∈ s → ∀ ⦃a : 𝕜⦄, 0 ≤ a → a ≤ 1 → a • x ∈ s
state_after: case refine_1
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : OrderedRing 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMulWithZero 𝕜 E
s : Set E
x : E
x✝ : x ∈ s
h : ∀ ⦃a b : 𝕜⦄, 0 ≤ a → 0 ≤ b → a + b = 1 → a • 0 + b • x ∈ s
a : 𝕜
ha₀ : 0 ≤ a
ha₁ : a ≤ 1
⊢ a • x ∈ s

case refine_2
𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝² : OrderedRing 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : SMulWithZero 𝕜 E
s : Set E
x : E
x✝ : x ∈ s
h : ∀ ⦃a : 𝕜⦄, 0 ≤ a → a ≤ 1 → a • x ∈ s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • 0 + b • x ∈ s
tactic: refine
    forall_congr' fun x => forall_congr' fun _ => ⟨fun h a ha₀ ha₁ => ?_, fun h a b ha hb hab => ?_⟩
Theorem: ENNReal.coe_rpow_of_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x : ℝ≥0
h : x ≠ 0
y : ℝ
⊢ ↑x ^ y = ↑(x ^ y)
state_after: x : ℝ≥0
h : x ≠ 0
y : ℝ
⊢ some x ^ y = ↑(x ^ y)
tactic: rw [← ENNReal.some_eq_coe]
state_before: x : ℝ≥0
h : x ≠ 0
y : ℝ
⊢ (if x = 0 ∧ y < 0 then ⊤ else ↑(x.rpow y)) = ↑(x.rpow y)
state_after: no goals
tactic: simp [h]
Theorem: Nat.div_left_inj
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hda : d ∣ a
hdb : d ∣ b
⊢ a / d = b / d ↔ a = b
state_after: a b c d m n k : ℕ
p q : ℕ → Prop
hda : d ∣ a
hdb : d ∣ b
h : a / d = b / d
⊢ a = b
tactic: refine ⟨fun h ↦ ?_, congrArg fun b ↦ b / d⟩
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hda : d ∣ a
hdb : d ∣ b
h : a / d = b / d
⊢ a = b
state_after: no goals
tactic: rw [← Nat.mul_div_cancel' hda, ← Nat.mul_div_cancel' hdb, h]
Theorem: Complex.cot_eq_exp_ratio
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Cotangent.lean

Proof steps:
state_before: z : ℂ
⊢ z.cot = (cexp (2 * I * z) + 1) / (I * (1 - cexp (2 * I * z)))
state_after: z : ℂ
⊢ (cexp (z * I) + cexp (-z * I)) / 2 / ((cexp (-z * I) - cexp (z * I)) * I / 2) =
    (cexp (2 * I * z) + 1) / (I * (1 - cexp (2 * I * z)))
tactic: rw [Complex.cot, Complex.sin, Complex.cos]
state_before: z : ℂ
⊢ (cexp (z * I) + cexp (-z * I)) / 2 / ((cexp (-z * I) - cexp (z * I)) * I / 2) =
    (cexp (2 * I * z) + 1) / (I * (1 - cexp (2 * I * z)))
state_after: z : ℂ
⊢ (cexp (z * I) + cexp (-(z * I))) / ((cexp (-(z * I)) - cexp (z * I)) * I) =
    (cexp (2 * I * z) + 1) / (I * (1 - cexp (2 * I * z)))
tactic: field_simp
state_before: z : ℂ
⊢ (cexp (z * I) + cexp (-(z * I))) / ((cexp (-(z * I)) - cexp (z * I)) * I) =
    (cexp (2 * I * z) + 1) / (I * (1 - cexp (2 * I * z)))
state_after: z : ℂ
h1 : cexp (z * I) + cexp (-(z * I)) = cexp (-(z * I)) * (cexp (2 * I * z) + 1)
⊢ (cexp (z * I) + cexp (-(z * I))) / ((cexp (-(z * I)) - cexp (z * I)) * I) =
    (cexp (2 * I * z) + 1) / (I * (1 - cexp (2 * I * z)))
tactic: have h1 : exp (z * I) + exp (-(z * I)) = exp (-(z * I)) * (exp (2 * I * z) + 1) := by
    rw [mul_add, ← Complex.exp_add]
    simp only [mul_one, add_left_inj]
    ring_nf
state_before: z : ℂ
h1 : cexp (z * I) + cexp (-(z * I)) = cexp (-(z * I)) * (cexp (2 * I * z) + 1)
⊢ (cexp (z * I) + cexp (-(z * I))) / ((cexp (-(z * I)) - cexp (z * I)) * I) =
    (cexp (2 * I * z) + 1) / (I * (1 - cexp (2 * I * z)))
state_after: z : ℂ
h1 : cexp (z * I) + cexp (-(z * I)) = cexp (-(z * I)) * (cexp (2 * I * z) + 1)
h2 : (cexp (-(z * I)) - cexp (z * I)) * I = cexp (-(z * I)) * (I * (1 - cexp (2 * I * z)))
⊢ (cexp (z * I) + cexp (-(z * I))) / ((cexp (-(z * I)) - cexp (z * I)) * I) =
    (cexp (2 * I * z) + 1) / (I * (1 - cexp (2 * I * z)))
tactic: have h2 : (exp (-(z * I)) - exp (z * I)) * I = exp (-(z * I)) * (I * (1 - exp (2 * I * z))) := by
    ring_nf
    rw [mul_assoc, ← Complex.exp_add]
    ring_nf
state_before: z : ℂ
h1 : cexp (z * I) + cexp (-(z * I)) = cexp (-(z * I)) * (cexp (2 * I * z) + 1)
h2 : (cexp (-(z * I)) - cexp (z * I)) * I = cexp (-(z * I)) * (I * (1 - cexp (2 * I * z)))
⊢ (cexp (z * I) + cexp (-(z * I))) / ((cexp (-(z * I)) - cexp (z * I)) * I) =
    (cexp (2 * I * z) + 1) / (I * (1 - cexp (2 * I * z)))
state_after: no goals
tactic: rw [h1, h2, mul_div_mul_left _ _ (Complex.exp_ne_zero _)]
Theorem: Prod.smul_zero_mk
File: Mathlib/Algebra/GroupWithZero/Action/Prod.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
α✝ : Type u_3
β : Type u_4
inst✝⁶ : SMul M α✝
inst✝⁵ : SMul M β
inst✝⁴ : SMul N α✝
inst✝³ : SMul N β
a✝ : M
x : α✝ × β
α : Type u_5
inst✝² : Monoid M
inst✝¹ : AddMonoid α
inst✝ : DistribMulAction M α
a : M
c : β
⊢ a • (0, c) = (0, a • c)
state_after: no goals
tactic: rw [Prod.smul_mk, smul_zero]
Theorem: PowerSeries.coeff_zero_eq_constantCoeff_apply
File: Mathlib/RingTheory/PowerSeries/Basic.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
φ : R⟦X⟧
⊢ (coeff R 0) φ = (constantCoeff R) φ
state_after: no goals
tactic: rw [coeff_zero_eq_constantCoeff]
Theorem: Polynomial.leadingCoeff_divByMonic_X_sub_C
File: Mathlib/Algebra/Polynomial/RingDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p✝ q p : R[X]
hp : p.degree ≠ 0
a : R
⊢ (p /ₘ (X - C a)).leadingCoeff = p.leadingCoeff
state_after: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q p : R[X]
hp : p.degree ≠ 0
a : R
inst✝ : Nontrivial R
⊢ (p /ₘ (X - C a)).leadingCoeff = p.leadingCoeff
tactic: nontriviality
state_before: R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q p : R[X]
hp : p.degree ≠ 0
a : R
inst✝ : Nontrivial R
⊢ (p /ₘ (X - C a)).leadingCoeff = p.leadingCoeff
state_after: case inl
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q p : R[X]
hp : p.degree ≠ 0
a : R
inst✝ : Nontrivial R
hd : p.degree < 0
⊢ (p /ₘ (X - C a)).leadingCoeff = p.leadingCoeff

case inr
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q p : R[X]
hp : p.degree ≠ 0
a : R
inst✝ : Nontrivial R
hd : 0 < p.degree
⊢ (p /ₘ (X - C a)).leadingCoeff = p.leadingCoeff
tactic: cases' hp.lt_or_lt with hd hd
state_before: case inr
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q p : R[X]
hp : p.degree ≠ 0
a : R
inst✝ : Nontrivial R
hd : 0 < p.degree
⊢ (p /ₘ (X - C a)).leadingCoeff = p.leadingCoeff
state_after: case inr
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q p : R[X]
hp : p.degree ≠ 0
a : R
inst✝ : Nontrivial R
hd : 0 < p.degree
⊢ (X - C a).degree ≤ p.degree
tactic: refine leadingCoeff_divByMonic_of_monic (monic_X_sub_C a) ?_
state_before: case inr
R : Type u
S : Type v
T : Type w
a✝ b : R
n : ℕ
inst✝² : CommRing R
inst✝¹ : IsDomain R
p✝ q p : R[X]
hp : p.degree ≠ 0
a : R
inst✝ : Nontrivial R
hd : 0 < p.degree
⊢ (X - C a).degree ≤ p.degree
state_after: no goals
tactic: rwa [degree_X_sub_C, Nat.WithBot.one_le_iff_zero_lt]
Theorem: OnePoint.continuous_iff_from_nat
File: Mathlib/Topology/Compactification/OnePoint.lean

Proof steps:
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
Y : Type u_2
inst✝ : TopologicalSpace Y
f : OnePoint ℕ → Y
⊢ Continuous f ↔ Tendsto (fun x => f ↑x) atTop (𝓝 (f ∞))
state_after: no goals
tactic: rw [continuous_iff_from_discrete, Nat.cofinite_eq_atTop]
Theorem: List.lookupAll_eq_nil
File: Mathlib/Data/List/Sigma.lean

Proof steps:
state_before: α : Type u
β : α → Type v
l l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a : α
⊢ lookupAll a [] = [] ↔ ∀ (b : β a), ⟨a, b⟩ ∉ []
state_after: no goals
tactic: simp
state_before: α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
⊢ lookupAll a (⟨a', b⟩ :: l) = [] ↔ ∀ (b_1 : β a), ⟨a, b_1⟩ ∉ ⟨a', b⟩ :: l
state_after: case pos
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
h : a = a'
⊢ lookupAll a (⟨a', b⟩ :: l) = [] ↔ ∀ (b_1 : β a), ⟨a, b_1⟩ ∉ ⟨a', b⟩ :: l

case neg
α : Type u
β : α → Type v
l✝ l₁ l₂ : List (Sigma β)
inst✝ : DecidableEq α
a a' : α
b : β a'
l : List (Sigma β)
h : ¬a = a'
⊢ lookupAll a (⟨a', b⟩ :: l) = [] ↔ ∀ (b_1 : β a), ⟨a, b_1⟩ ∉ ⟨a', b⟩ :: l
tactic: by_cases h : a = a'
Theorem: CategoryTheory.Sieve.pullback_apply
File: Mathlib/CategoryTheory/Sites/Sieves.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S✝ R : Sieve X
h : Y ⟶ X
S : Sieve X
Y✝ Z✝ : C
f✝ : Y✝ ⟶ Y
g : (fun Y_1 sl => S.arrows (sl ≫ h)) Y✝ f✝
⊢ ∀ (g : Z✝ ⟶ Y✝), (fun Y_1 sl => S.arrows (sl ≫ h)) Z✝ (g ≫ f✝)
state_after: no goals
tactic: simp [g]
Theorem: CPolynomialOn.continuous
File: Mathlib/Analysis/Analytic/CPolynomial.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f✝ g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
n m : ℕ
f : E → F
fa : CPolynomialOn 𝕜 f univ
⊢ Continuous f
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f✝ g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
n m : ℕ
f : E → F
fa : CPolynomialOn 𝕜 f univ
⊢ ContinuousOn f univ
tactic: rw [continuous_iff_continuousOn_univ]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f✝ g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
n m : ℕ
f : E → F
fa : CPolynomialOn 𝕜 f univ
⊢ ContinuousOn f univ
state_after: no goals
tactic: exact fa.continuousOn
Theorem: MeasureTheory.measure_eq_zero_or_top_of_subset_compl_sigmaFiniteSet
File: Mathlib/MeasureTheory/Measure/WithDensityFinite.lean

Proof steps:
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝ : SFinite μ
ht_subset : t ⊆ μ.sigmaFiniteSetᶜ
⊢ μ t = 0 ∨ μ t = ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝ : SFinite μ
ht_subset : t ⊆ μ.sigmaFiniteSetᶜ
this : μ t = (μ.restrict μ.sigmaFiniteSetᶜ) t
⊢ μ t = 0 ∨ μ t = ⊤
tactic: have : μ t = μ.restrict μ.sigmaFiniteSetᶜ t := by
    rw [Measure.restrict_apply' (measurableSet_sigmaFiniteSet μ).compl,
      Set.inter_eq_left.mpr ht_subset]
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝ : SFinite μ
ht_subset : t ⊆ μ.sigmaFiniteSetᶜ
this : μ t = (μ.restrict μ.sigmaFiniteSetᶜ) t
⊢ μ t = 0 ∨ μ t = ⊤
state_after: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝ : SFinite μ
ht_subset : t ⊆ μ.sigmaFiniteSetᶜ
this : μ t = (μ.restrict μ.sigmaFiniteSetᶜ) t
⊢ (μ.restrict μ.sigmaFiniteSetᶜ) t = 0 ∨ (μ.restrict μ.sigmaFiniteSetᶜ) t = ⊤
tactic: rw [this]
state_before: α : Type u_1
mα : MeasurableSpace α
μ : Measure α
s t : Set α
inst✝ : SFinite μ
ht_subset : t ⊆ μ.sigmaFiniteSetᶜ
this : μ t = (μ.restrict μ.sigmaFiniteSetᶜ) t
⊢ (μ.restrict μ.sigmaFiniteSetᶜ) t = 0 ∨ (μ.restrict μ.sigmaFiniteSetᶜ) t = ⊤
state_after: no goals
tactic: exact restrict_compl_sigmaFiniteSet_eq_zero_or_top μ t
Theorem: multiplicity.multiplicity_sub_of_gt
File: Mathlib/RingTheory/Multiplicity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p b < multiplicity p a
⊢ multiplicity p (a - b) = multiplicity p b
state_after: α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p b < multiplicity p a
⊢ multiplicity p b < multiplicity p a
tactic: rw [sub_eq_add_neg, multiplicity_add_of_gt] <;> rw [multiplicity.neg]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Ring α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p a b : α
h : multiplicity p b < multiplicity p a
⊢ multiplicity p b < multiplicity p a
state_after: no goals
tactic: assumption
Theorem: IsCyclotomicExtension.splits_cyclotomic
File: Mathlib/NumberTheory/Cyclotomic/Basic.lean

Proof steps:
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : Algebra A B
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsCyclotomicExtension S K L
hS : n ∈ S
⊢ Splits (algebraMap K L) (cyclotomic (↑n) K)
state_after: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : Algebra A B
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsCyclotomicExtension S K L
hS : n ∈ S
⊢ cyclotomic (↑n) K ∣ X ^ ↑n - C 1
tactic: refine splits_of_splits_of_dvd _ (X_pow_sub_C_ne_zero n.pos _) (splits_X_pow_sub_one K L hS) ?_
state_before: n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : Algebra A B
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsCyclotomicExtension S K L
hS : n ∈ S
⊢ cyclotomic (↑n) K ∣ X ^ ↑n - C 1
state_after: case h
n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : Algebra A B
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsCyclotomicExtension S K L
hS : n ∈ S
⊢ X ^ ↑n - C 1 = cyclotomic (↑n) K * ∏ i ∈ (↑n).properDivisors, cyclotomic i K
tactic: use ∏ i ∈ (n : ℕ).properDivisors, Polynomial.cyclotomic i K
state_before: case h
n : ℕ+
S T : Set ℕ+
A : Type u
B : Type v
K : Type w
L : Type z
inst✝⁶ : CommRing A
inst✝⁵ : CommRing B
inst✝⁴ : Algebra A B
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsCyclotomicExtension S K L
hS : n ∈ S
⊢ X ^ ↑n - C 1 = cyclotomic (↑n) K * ∏ i ∈ (↑n).properDivisors, cyclotomic i K
state_after: no goals
tactic: rw [(eq_cyclotomic_iff n.pos _).1 rfl, RingHom.map_one]
Theorem: RingTheory.Sequence.eq_nil_of_isRegular_on_artinian
File: Mathlib/RingTheory/Regular/RegularSequence.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
M : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M₄
inst✝ : IsArtinian R M
r : R
rs : List R
h : IsRegular M (r :: rs)
⊢ r :: rs = []
state_after: R : Type u_1
S : Type u_2
M : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M₄
inst✝ : IsArtinian R M
r : R
rs : List R
h : (IsSMulRegular M r ∧ IsWeaklyRegular (QuotSMulTop r M) rs) ∧ r • ⊤ ⊔ Ideal.ofList rs • ⊤ < ⊤
⊢ r :: rs = []
tactic: rw [isRegular_iff, ne_comm, ← lt_top_iff_ne_top, Ideal.ofList_cons,
      sup_smul, ideal_span_singleton_smul, isWeaklyRegular_cons_iff] at h
state_before: R : Type u_1
S : Type u_2
M : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M₄
inst✝ : IsArtinian R M
r : R
rs : List R
h : (IsSMulRegular M r ∧ IsWeaklyRegular (QuotSMulTop r M) rs) ∧ r • ⊤ ⊔ Ideal.ofList rs • ⊤ < ⊤
⊢ r :: rs = []
state_after: R : Type u_1
S : Type u_2
M : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M₄
inst✝ : IsArtinian R M
r : R
rs : List R
h : (IsSMulRegular M r ∧ IsWeaklyRegular (QuotSMulTop r M) rs) ∧ r • ⊤ ⊔ Ideal.ofList rs • ⊤ < ⊤
⊢ r • ⊤ = ⊤
tactic: refine absurd ?_ (ne_of_lt (lt_of_le_of_lt le_sup_left h.right))
state_before: R : Type u_1
S : Type u_2
M : Type u_3
M₂ : Type u_4
M₃ : Type u_5
M₄ : Type u_6
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : AddCommGroup M₃
inst✝⁵ : AddCommGroup M₄
inst✝⁴ : Module R M
inst✝³ : Module R M₂
inst✝² : Module R M₃
inst✝¹ : Module R M₄
inst✝ : IsArtinian R M
r : R
rs : List R
h : (IsSMulRegular M r ∧ IsWeaklyRegular (QuotSMulTop r M) rs) ∧ r • ⊤ ⊔ Ideal.ofList rs • ⊤ < ⊤
⊢ r • ⊤ = ⊤
state_after: no goals
tactic: exact Eq.trans (Submodule.map_top _) <| LinearMap.range_eq_top.mpr <|
      surjective_of_injective_endomorphism (LinearMap.lsmul R M r) h.left.left
Theorem: Nat.count_modEq_card_eq_ceil
File: Mathlib/Data/Int/CardIntervalMod.lean

Proof steps:
state_before: a b r : ℕ
hr : 0 < r
v : ℕ
⊢ ↑(count (fun x => x ≡ v [MOD r]) b) = ⌈(↑b - ↑(v % r)) / ↑r⌉
state_after: a b r : ℕ
hr : 0 < r
v : ℕ
hr' : 0 < ↑r
⊢ ↑(count (fun x => x ≡ v [MOD r]) b) = ⌈(↑b - ↑(v % r)) / ↑r⌉
tactic: have hr' : 0 < (r : ℚ) := by positivity
state_before: a b r : ℕ
hr : 0 < r
v : ℕ
hr' : 0 < ↑r
⊢ ↑(count (fun x => x ≡ v [MOD r]) b) = ⌈(↑b - ↑(v % r)) / ↑r⌉
state_after: a b r : ℕ
hr : 0 < r
v : ℕ
hr' : 0 < ↑r
⊢ ⌈(↑b - ↑v) / ↑r⌉ - ⌈(↑0 - ↑v) / ↑r⌉ = ⌈(↑b - ↑(v % r)) / ↑r⌉
tactic: rw [count_eq_card_filter_range, ← Ico_zero_eq_range, Ico_filter_modEq_card _ _ hr,
    max_eq_left (sub_nonneg.mpr <| by gcongr <;> positivity)]
state_before: a b r : ℕ
hr : 0 < r
v : ℕ
hr' : 0 < ↑r
⊢ ⌈(↑b - ↑v) / ↑r⌉ - ⌈(↑0 - ↑v) / ↑r⌉ = ⌈(↑b - ↑(v % r)) / ↑r⌉
state_after: a b r : ℕ
hr : 0 < r
v : ℕ
hr' : 0 < ↑r
⊢ ⌈(↑b - ↑(v % r)) / ↑r⌉ - ⌈-↑(v % r) / ↑r⌉ = ⌈(↑b - ↑(v % r)) / ↑r⌉
tactic: conv_lhs =>
    rw [← div_add_mod v r, cast_add, cast_mul, add_comm]
    tactic => simp_rw [← sub_sub, sub_div (_ - _), mul_div_cancel_left₀ _ hr'.ne', ceil_sub_nat]
    rw [sub_sub_sub_cancel_right, cast_zero, zero_sub]
state_before: a b r : ℕ
hr : 0 < r
v : ℕ
hr' : 0 < ↑r
⊢ ⌈(↑b - ↑(v % r)) / ↑r⌉ - ⌈-↑(v % r) / ↑r⌉ = ⌈(↑b - ↑(v % r)) / ↑r⌉
state_after: a b r : ℕ
hr : 0 < r
v : ℕ
hr' : 0 < ↑r
⊢ v % r < r ∧ -↑(v % r) ≤ 0
tactic: rw [sub_eq_self, ceil_eq_zero_iff, Set.mem_Ioc, div_le_iff hr', lt_div_iff hr', neg_one_mul,
    zero_mul, neg_lt_neg_iff, cast_lt]
state_before: a b r : ℕ
hr : 0 < r
v : ℕ
hr' : 0 < ↑r
⊢ v % r < r ∧ -↑(v % r) ≤ 0
state_after: no goals
tactic: exact ⟨mod_lt _ hr, by simp⟩