ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ProbabilityTheory.aestronglyMeasurable_exp_mul_add
File: Mathlib/Probability/Moments.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_int_X : AEStronglyMeasurable (fun ω => rexp (t * X ω)) μ
h_int_Y : AEStronglyMeasurable (fun ω => rexp (t * Y ω)) μ
⊢ AEStronglyMeasurable (fun ω => rexp (t * (X + Y) ω)) μ
state_after: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_int_X : AEStronglyMeasurable (fun ω => rexp (t * X ω)) μ
h_int_Y : AEStronglyMeasurable (fun ω => rexp (t * Y ω)) μ
⊢ AEStronglyMeasurable (fun ω => rexp (t * X ω) * rexp (t * Y ω)) μ
tactic: simp_rw [Pi.add_apply, mul_add, exp_add]
state_before: Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_int_X : AEStronglyMeasurable (fun ω => rexp (t * X ω)) μ
h_int_Y : AEStronglyMeasurable (fun ω => rexp (t * Y ω)) μ
⊢ AEStronglyMeasurable (fun ω => rexp (t * X ω) * rexp (t * Y ω)) μ
state_after: no goals
tactic: exact AEStronglyMeasurable.mul h_int_X h_int_Y
Theorem: HomologicalComplex.singleMapHomologicalComplex_hom_app_self
File: Mathlib/Algebra/Homology/Additive.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹¹ : Category.{v, u} V
inst✝¹⁰ : Preadditive V
W : Type u_2
inst✝⁹ : Category.{?u.135432, u_2} W
inst✝⁸ : Preadditive W
W₁ : Type u_3
W₂ : Type u_4
inst✝⁷ : Category.{u_6, u_3} W₁
inst✝⁶ : Category.{u_5, u_4} W₂
inst✝⁵ : HasZeroMorphisms W₁
inst✝⁴ : HasZeroMorphisms W₂
c✝ : ComplexShape ι
C D E : HomologicalComplex V c✝
f g : C ⟶ D
h k : D ⟶ E
i : ι
inst✝³ : HasZeroObject W₁
inst✝² : HasZeroObject W₂
F : W₁ ⥤ W₂
inst✝¹ : F.PreservesZeroMorphisms
c : ComplexShape ι
inst✝ : DecidableEq ι
j : ι
X : W₁
⊢ ((singleMapHomologicalComplex F c j).hom.app X).f j =
    F.map (singleObjXSelf c j X).hom ≫ (singleObjXSelf c j (F.obj X)).inv
state_after: no goals
tactic: simp [singleMapHomologicalComplex, singleObjXSelf, singleObjXIsoOfEq, eqToHom_map]
Theorem: ProbabilityTheory.IsRatCondKernelCDFAux.iInf_rat_gt_eq
File: Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDFAux f κ ν
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel ν
a : α
⊢ ∀ᵐ (t : β) ∂ν a, ∀ (q : ℚ), ⨅ r, f (a, t) ↑r = f (a, t) q
state_after: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDFAux f κ ν
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel ν
a : α
⊢ ∀ (i : ℚ), ∀ᵐ (a_1 : β) ∂ν a, ⨅ r, f (a, a_1) ↑r = f (a, a_1) i
tactic: rw [ae_all_iff]
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDFAux f κ ν
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel ν
a : α
⊢ ∀ (i : ℚ), ∀ᵐ (a_1 : β) ∂ν a, ⨅ r, f (a, a_1) ↑r = f (a, a_1) i
state_after: case refine_1
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDFAux f κ ν
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel ν
a : α
q : ℚ
⊢ ∀ (s : Set β), MeasurableSet s → (ν a) s < ⊤ → IntegrableOn (fun a_3 => ⨅ r, f (a, a_3) ↑r) s (ν a)

case refine_2
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDFAux f κ ν
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel ν
a : α
q : ℚ
⊢ ∀ (s : Set β), MeasurableSet s → (ν a) s < ⊤ → IntegrableOn (fun a_3 => f (a, a_3) q) s (ν a)

case refine_3
α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f : α × β → ℚ → ℝ
hf : IsRatCondKernelCDFAux f κ ν
inst✝¹ : IsFiniteKernel κ
inst✝ : IsFiniteKernel ν
a : α
q : ℚ
⊢ ∀ (s : Set β), MeasurableSet s → (ν a) s < ⊤ → ∫ (x : β) in s, ⨅ r, f (a, x) ↑r ∂ν a = ∫ (x : β) in s, f (a, x) q ∂ν a
tactic: refine fun q ↦ ae_eq_of_forall_setIntegral_eq_of_sigmaFinite (μ := ν a) ?_ ?_ ?_
Theorem: AddSemiconjBy.conj_iff
File: Mathlib/Algebra/Group/Semiconj/Defs.lean

Proof steps:
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ SemiconjBy (b * a * b⁻¹) (b * x * b⁻¹) (b * y * b⁻¹) ↔ SemiconjBy a x y
state_after: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ b * a * b⁻¹ * (b * x * b⁻¹) = b * y * b⁻¹ * (b * a * b⁻¹) ↔ a * x = y * a
tactic: unfold SemiconjBy
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ b * a * b⁻¹ * (b * x * b⁻¹) = b * y * b⁻¹ * (b * a * b⁻¹) ↔ a * x = y * a
state_after: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ b * a * x * b⁻¹ = b * y * a * b⁻¹ ↔ a * x = y * a
tactic: simp only [← mul_assoc, inv_mul_cancel_right]
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ b * a * x * b⁻¹ = b * y * a * b⁻¹ ↔ a * x = y * a
state_after: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ b * (a * (x * b⁻¹)) = b * (y * (a * b⁻¹)) ↔ a * x = y * a
tactic: repeat rw [mul_assoc]
state_before: S : Type u_1
M : Type u_2
G : Type u_3
inst✝ : Group G
a✝ x✝ y✝ a x y b : G
⊢ b * (a * (x * b⁻¹)) = b * (y * (a * b⁻¹)) ↔ a * x = y * a
state_after: no goals
tactic: rw [mul_left_cancel_iff, ← mul_assoc, ← mul_assoc, mul_right_cancel_iff]
Theorem: CategoryTheory.Limits.Cofork.ofπ_pt
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : C
f✝ g : X ⟶ Y
P : C
π : Y ⟶ P
w : f✝ ≫ π = g ≫ π
i j : WalkingParallelPair
f : i ⟶ j
⊢ (parallelPair f✝ g).map f ≫ (fun X_1 => WalkingParallelPair.casesOn X_1 (f✝ ≫ π) π) j =
    (fun X_1 => WalkingParallelPair.casesOn X_1 (f✝ ≫ π) π) i ≫ ((Functor.const WalkingParallelPair).obj P).map f
state_after: no goals
tactic: cases f <;> dsimp <;> simp [w]
Theorem: NNReal.orderIsoRpow_apply
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: w x✝ y✝ z y : ℝ
hy : 0 < y
x : ℝ≥0
⊢ (fun x => x ^ y) ((fun x => x ^ (1 / y)) x) = x
state_after: w x✝ y✝ z y : ℝ
hy : 0 < y
x : ℝ≥0
⊢ (x ^ (1 / y)) ^ y = x
tactic: dsimp
state_before: w x✝ y✝ z y : ℝ
hy : 0 < y
x : ℝ≥0
⊢ (x ^ (1 / y)) ^ y = x
state_after: no goals
tactic: rw [← rpow_mul, one_div_mul_cancel hy.ne.symm, rpow_one]
Theorem: CategoryTheory.isSheaf_coherent
File: Mathlib/CategoryTheory/Sites/Coherent/CoherentSheaves.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Precoherent C
P : Cᵒᵖ ⥤ Type w
⊢ Presieve.IsSheaf (coherentTopology C) P ↔
    ∀ (B : C) (α : Type) [inst : Finite α] (X : α → C) (π : (a : α) → X a ⟶ B),
      EffectiveEpiFamily X π → Presieve.IsSheafFor P (Presieve.ofArrows X π)
state_after: case mp
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Precoherent C
P : Cᵒᵖ ⥤ Type w
⊢ Presieve.IsSheaf (coherentTopology C) P →
    ∀ (B : C) (α : Type) [inst : Finite α] (X : α → C) (π : (a : α) → X a ⟶ B),
      EffectiveEpiFamily X π → Presieve.IsSheafFor P (Presieve.ofArrows X π)

case mpr
C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Precoherent C
P : Cᵒᵖ ⥤ Type w
⊢ (∀ (B : C) (α : Type) [inst : Finite α] (X : α → C) (π : (a : α) → X a ⟶ B),
      EffectiveEpiFamily X π → Presieve.IsSheafFor P (Presieve.ofArrows X π)) →
    Presieve.IsSheaf (coherentTopology C) P
tactic: constructor
Theorem: sub_ball
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

Proof steps:
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ s / ball x δ = x⁻¹ • thickening δ s
state_after: no goals
tactic: simp [div_eq_mul_inv]
Theorem: NNReal.eventually_pow_one_div_le
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

Proof steps:
state_before: x y : ℝ≥0
hy : 1 < y
⊢ ∀ᶠ (n : ℕ) in atTop, x ^ (1 / ↑n) ≤ y
state_after: case intro
x y : ℝ≥0
hy : 1 < y
m : ℕ
hm : x < (y - 1 + 1) ^ m
⊢ ∀ᶠ (n : ℕ) in atTop, x ^ (1 / ↑n) ≤ y
tactic: obtain ⟨m, hm⟩ := add_one_pow_unbounded_of_pos x (tsub_pos_of_lt hy)
state_before: case intro
x y : ℝ≥0
hy : 1 < y
m : ℕ
hm : x < (y - 1 + 1) ^ m
⊢ ∀ᶠ (n : ℕ) in atTop, x ^ (1 / ↑n) ≤ y
state_after: case intro
x y : ℝ≥0
hy : 1 < y
m : ℕ
hm : x < y ^ m
⊢ ∀ᶠ (n : ℕ) in atTop, x ^ (1 / ↑n) ≤ y
tactic: rw [tsub_add_cancel_of_le hy.le] at hm
state_before: case intro
x y : ℝ≥0
hy : 1 < y
m : ℕ
hm : x < y ^ m
⊢ ∀ᶠ (n : ℕ) in atTop, x ^ (1 / ↑n) ≤ y
state_after: case intro
x y : ℝ≥0
hy : 1 < y
m : ℕ
hm : x < y ^ m
n : ℕ
hn : n ≥ m + 1
⊢ x ^ (1 / ↑n) ≤ y
tactic: refine eventually_atTop.2 ⟨m + 1, fun n hn => ?_⟩
state_before: case intro
x y : ℝ≥0
hy : 1 < y
m : ℕ
hm : x < y ^ m
n : ℕ
hn : n ≥ m + 1
⊢ x ^ (1 / ↑n) ≤ y
state_after: case intro
x y : ℝ≥0
hy : 1 < y
m : ℕ
hm : x < y ^ m
n : ℕ
hn : n ≥ m + 1
⊢ x ^ (↑n)⁻¹ ≤ y
tactic: simp only [one_div]
state_before: case intro
x y : ℝ≥0
hy : 1 < y
m : ℕ
hm : x < y ^ m
n : ℕ
hn : n ≥ m + 1
⊢ x ^ (↑n)⁻¹ ≤ y
state_after: no goals
tactic: simpa only [NNReal.rpow_inv_le_iff (Nat.cast_pos.2 <| m.succ_pos.trans_le hn),
    NNReal.rpow_natCast] using hm.le.trans (pow_le_pow_right hy.le (m.le_succ.trans hn))
Theorem: Bitraversable.tfst_eq_fst_id
File: Mathlib/Control/Bitraversable/Lemmas.lean

Proof steps:
state_before: t : Type u → Type u → Type u
inst✝⁵ : Bitraversable t
β✝ : Type u
F G : Type u → Type u
inst✝⁴ : Applicative F
inst✝³ : Applicative G
inst✝² : LawfulBitraversable t
inst✝¹ : LawfulApplicative F
inst✝ : LawfulApplicative G
α α' β : Type u
f : α → α'
x : t α β
⊢ tfst (pure ∘ f) x = pure (fst f x)
state_after: no goals
tactic: apply bitraverse_eq_bimap_id
Theorem: Set.Ici_mul_Ioi_subset'
File: Mathlib/Data/Set/Pointwise/Interval.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
⊢ Ici a * Ioi b ⊆ Ioi (a * b)
state_after: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
this :
  ∀ (M : Type ?u.12705) (N : Type ?u.12704) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
⊢ Ici a * Ioi b ⊆ Ioi (a * b)
tactic: haveI := covariantClass_le_of_lt
state_before: α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
this :
  ∀ (M : Type ?u.12705) (N : Type ?u.12704) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
⊢ Ici a * Ioi b ⊆ Ioi (a * b)
state_after: case intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
this :
  ∀ (M : Type ?u.12705) (N : Type ?u.12704) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
y : α
hya : y ∈ Ici a
z : α
hzb : z ∈ Ioi b
⊢ (fun x x_1 => x * x_1) y z ∈ Ioi (a * b)
tactic: rintro x ⟨y, hya, z, hzb, rfl⟩
state_before: case intro.intro.intro.intro
α : Type u_1
inst✝³ : Mul α
inst✝² : PartialOrder α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : CovariantClass α α (Function.swap HMul.hMul) LT.lt
a b : α
this :
  ∀ (M : Type ?u.12705) (N : Type ?u.12704) (μ : M → N → N) [inst : PartialOrder N]
    [inst_1 : CovariantClass M N μ fun x x_1 => x < x_1], CovariantClass M N μ fun x x_1 => x ≤ x_1
y : α
hya : y ∈ Ici a
z : α
hzb : z ∈ Ioi b
⊢ (fun x x_1 => x * x_1) y z ∈ Ioi (a * b)
state_after: no goals
tactic: exact mul_lt_mul_of_le_of_lt hya hzb
Theorem: CategoryTheory.LaxBraidedFunctor.mapCommMonFunctor_obj
File: Mathlib/CategoryTheory/Monoidal/CommMon_.lean

Proof steps:
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
X✝ Y✝ : LaxBraidedFunctor C D
α : X✝ ⟶ Y✝
⊢ ∀ ⦃X Y : CommMon_ C⦄ (f : X ⟶ Y),
    X✝.mapCommMon.map f ≫ (fun A => { hom := α.app A.X, one_hom := ⋯, mul_hom := ⋯ }) Y =
      (fun A => { hom := α.app A.X, one_hom := ⋯, mul_hom := ⋯ }) X ≫ Y✝.mapCommMon.map f
state_after: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
X✝¹ Y✝¹ : LaxBraidedFunctor C D
α : X✝¹ ⟶ Y✝¹
X✝ Y✝ : CommMon_ C
f✝ : X✝ ⟶ Y✝
⊢ X✝¹.mapCommMon.map f✝ ≫ (fun A => { hom := α.app A.X, one_hom := ⋯, mul_hom := ⋯ }) Y✝ =
    (fun A => { hom := α.app A.X, one_hom := ⋯, mul_hom := ⋯ }) X✝ ≫ Y✝¹.mapCommMon.map f✝
tactic: intros
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
X✝¹ Y✝¹ : LaxBraidedFunctor C D
α : X✝¹ ⟶ Y✝¹
X✝ Y✝ : CommMon_ C
f✝ : X✝ ⟶ Y✝
⊢ X✝¹.mapCommMon.map f✝ ≫ (fun A => { hom := α.app A.X, one_hom := ⋯, mul_hom := ⋯ }) Y✝ =
    (fun A => { hom := α.app A.X, one_hom := ⋯, mul_hom := ⋯ }) X✝ ≫ Y✝¹.mapCommMon.map f✝
state_after: case h
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
X✝¹ Y✝¹ : LaxBraidedFunctor C D
α : X✝¹ ⟶ Y✝¹
X✝ Y✝ : CommMon_ C
f✝ : X✝ ⟶ Y✝
⊢ (X✝¹.mapCommMon.map f✝ ≫ (fun A => { hom := α.app A.X, one_hom := ⋯, mul_hom := ⋯ }) Y✝).hom =
    ((fun A => { hom := α.app A.X, one_hom := ⋯, mul_hom := ⋯ }) X✝ ≫ Y✝¹.mapCommMon.map f✝).hom
tactic: ext
state_before: case h
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
inst✝⁴ : MonoidalCategory C
inst✝³ : BraidedCategory C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : MonoidalCategory D
inst✝ : BraidedCategory D
X✝¹ Y✝¹ : LaxBraidedFunctor C D
α : X✝¹ ⟶ Y✝¹
X✝ Y✝ : CommMon_ C
f✝ : X✝ ⟶ Y✝
⊢ (X✝¹.mapCommMon.map f✝ ≫ (fun A => { hom := α.app A.X, one_hom := ⋯, mul_hom := ⋯ }) Y✝).hom =
    ((fun A => { hom := α.app A.X, one_hom := ⋯, mul_hom := ⋯ }) X✝ ≫ Y✝¹.mapCommMon.map f✝).hom
state_after: no goals
tactic: simp
Theorem: MeasureTheory.indicatorConstLp_univ
File: Mathlib/MeasureTheory/Function/LpSpace.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : IsFiniteMeasure μ
c : E
⊢ indicatorConstLp p ⋯ ⋯ c = (Lp.const p μ) c
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : IsFiniteMeasure μ
c : E
⊢ Memℒp.toLp (Set.univ.indicator fun x => c) ⋯ = Memℒp.toLp (fun x => c) ⋯
tactic: rw [← Memℒp.toLp_const, indicatorConstLp]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedAddCommGroup G
inst✝ : IsFiniteMeasure μ
c : E
⊢ Memℒp.toLp (Set.univ.indicator fun x => c) ⋯ = Memℒp.toLp (fun x => c) ⋯
state_after: no goals
tactic: simp only [Set.indicator_univ, Function.const]
Theorem: ValuationSubring.image_maximalIdeal
File: Mathlib/RingTheory/Valuation/ValuationSubring.lean

Proof steps:
state_before: K : Type u
inst✝ : Field K
A : ValuationSubring K
⊢ Subtype.val '' ↑(LocalRing.maximalIdeal ↥A) = ↑A.nonunits
state_after: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ a ∈ Subtype.val '' ↑(LocalRing.maximalIdeal ↥A) ↔ a ∈ ↑A.nonunits
tactic: ext a
state_before: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ a ∈ Subtype.val '' ↑(LocalRing.maximalIdeal ↥A) ↔ a ∈ ↑A.nonunits
state_after: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ (∃ x ∈ LocalRing.maximalIdeal ↥A, ↑x = a) ↔ ∃ (ha : a ∈ A), ⟨a, ha⟩ ∈ LocalRing.maximalIdeal ↥A
tactic: simp only [Set.mem_image, SetLike.mem_coe, mem_nonunits_iff_exists_mem_maximalIdeal]
state_before: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ (∃ x ∈ LocalRing.maximalIdeal ↥A, ↑x = a) ↔ ∃ (ha : a ∈ A), ⟨a, ha⟩ ∈ LocalRing.maximalIdeal ↥A
state_after: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ (∃ a_1, ∃ (b : a_1 ∈ ↑A), ⟨a_1, b⟩ ∈ LocalRing.maximalIdeal ↥A ∧ ↑⟨a_1, b⟩ = a) ↔
    ∃ (ha : a ∈ A), ⟨a, ha⟩ ∈ LocalRing.maximalIdeal ↥A
tactic: erw [Subtype.exists]
state_before: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ (∃ a_1, ∃ (b : a_1 ∈ ↑A), ⟨a_1, b⟩ ∈ LocalRing.maximalIdeal ↥A ∧ ↑⟨a_1, b⟩ = a) ↔
    ∃ (ha : a ∈ A), ⟨a, ha⟩ ∈ LocalRing.maximalIdeal ↥A
state_after: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ (∃ (x : a ∈ ↑A), ⟨a, ⋯⟩ ∈ LocalRing.maximalIdeal ↥A) ↔ ∃ (ha : a ∈ A), ⟨a, ha⟩ ∈ LocalRing.maximalIdeal ↥A
tactic: simp_rw [exists_and_right, exists_eq_right]
state_before: case h
K : Type u
inst✝ : Field K
A : ValuationSubring K
a : K
⊢ (∃ (x : a ∈ ↑A), ⟨a, ⋯⟩ ∈ LocalRing.maximalIdeal ↥A) ↔ ∃ (ha : a ∈ A), ⟨a, ha⟩ ∈ LocalRing.maximalIdeal ↥A
state_after: no goals
tactic: simp
Theorem: Finsupp.mem_supported_support
File: Mathlib/LinearAlgebra/Finsupp.lean

Proof steps:
state_before: α : Type u_1
M : Type u_2
N : Type u_3
P : Type u_4
R : Type u_5
S : Type u_6
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
p : α →₀ M
⊢ p ∈ supported M R ↑p.support
state_after: no goals
tactic: rw [Finsupp.mem_supported]
Theorem: Complex.real_le_real
File: Mathlib/Data/Complex/Order.lean

Proof steps:
state_before: x y : ℝ
⊢ ↑x ≤ ↑y ↔ x ≤ y
state_after: no goals
tactic: simp [le_def, ofReal']
Theorem: Int.lcm_dvd
File: Mathlib/Data/Int/GCD.lean

Proof steps:
state_before: i j k : ℤ
⊢ i ∣ k → j ∣ k → ↑(i.lcm j) ∣ k
state_after: i j k : ℤ
⊢ i ∣ k → j ∣ k → ↑(i.natAbs.lcm j.natAbs) ∣ k
tactic: rw [Int.lcm]
state_before: i j k : ℤ
⊢ i ∣ k → j ∣ k → ↑(i.natAbs.lcm j.natAbs) ∣ k
state_after: i j k : ℤ
hi : i ∣ k
hj : j ∣ k
⊢ ↑(i.natAbs.lcm j.natAbs) ∣ k
tactic: intro hi hj
state_before: i j k : ℤ
hi : i ∣ k
hj : j ∣ k
⊢ ↑(i.natAbs.lcm j.natAbs) ∣ k
state_after: no goals
tactic: exact natCast_dvd.mpr (Nat.lcm_dvd (natAbs_dvd_natAbs.mpr hi) (natAbs_dvd_natAbs.mpr hj))
Theorem: Nat.two_pow_sub_pow
File: Mathlib/NumberTheory/Multiplicity.lean

Proof steps:
state_before: R : Type u_1
n✝ x y : ℕ
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : Even n
⊢ multiplicity 2 (x ^ n - y ^ n) + 1 = multiplicity 2 (x + y) + multiplicity 2 (x - y) + multiplicity 2 n
state_after: case inl
R : Type u_1
n✝ x y : ℕ
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : Even n
hyx : y ≤ x
⊢ multiplicity 2 (x ^ n - y ^ n) + 1 = multiplicity 2 (x + y) + multiplicity 2 (x - y) + multiplicity 2 n

case inr
R : Type u_1
n✝ x y : ℕ
hxy : 2 ∣ x - y
hx : ¬2 ∣ x
n : ℕ
hn : Even n
hyx : x ≤ y
⊢ multiplicity 2 (x ^ n - y ^ n) + 1 = multiplicity 2 (x + y) + multiplicity 2 (x - y) + multiplicity 2 n
tactic: obtain hyx | hyx := le_total y x
Theorem: FiniteDimensional.nontrivial_of_finrank_eq_succ
File: Mathlib/LinearAlgebra/Dimension/Finite.lean

Proof steps:
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
n : ℕ
hn : finrank R M = n.succ
⊢ 0 < finrank ?m.344409 M
state_after: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
n : ℕ
hn : finrank R M = n.succ
⊢ 0 < n.succ
tactic: rw [hn]
state_before: R : Type u
M M₁ : Type v
M' : Type v'
ι : Type w
inst✝⁸ : Ring R
inst✝⁷ : AddCommGroup M
inst✝⁶ : AddCommGroup M'
inst✝⁵ : AddCommGroup M₁
inst✝⁴ : Module R M
inst✝³ : Module R M'
inst✝² : Module R M₁
inst✝¹ : Nontrivial R
inst✝ : NoZeroSMulDivisors R M
n : ℕ
hn : finrank R M = n.succ
⊢ 0 < n.succ
state_after: no goals
tactic: exact n.succ_pos
Theorem: CategoryTheory.Subgroupoid.inv_mem_iff
File: Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean

Proof steps:
state_before: C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c d : C
f : c ⟶ d
⊢ Groupoid.inv f ∈ S.arrows d c ↔ f ∈ S.arrows c d
state_after: case mp
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c d : C
f : c ⟶ d
⊢ Groupoid.inv f ∈ S.arrows d c → f ∈ S.arrows c d

case mpr
C : Type u
inst✝ : Groupoid C
S : Subgroupoid C
c d : C
f : c ⟶ d
⊢ f ∈ S.arrows c d → Groupoid.inv f ∈ S.arrows d c
tactic: constructor
Theorem: Polynomial.tendsto_atBot_iff_leadingCoeff_nonpos
File: Mathlib/Analysis/SpecialFunctions/Polynomials.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
⊢ Tendsto (fun x => eval x P) atTop atBot ↔ 0 < P.degree ∧ P.leadingCoeff ≤ 0
state_after: no goals
tactic: simp only [← tendsto_neg_atTop_iff, ← eval_neg, tendsto_atTop_iff_leadingCoeff_nonneg,
    degree_neg, leadingCoeff_neg, neg_nonneg]
Theorem: AlgebraicGeometry.ΓSpec.adjunction_unit_app_app_top
File: Mathlib/AlgebraicGeometry/GammaSpecAdjunction.lean

Proof steps:
state_before: X : Scheme
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
state_after: X : Scheme
this :
  Scheme.Γ.rightOp.map (adjunction.unit.app X) ≫ adjunction.counit.app (Scheme.Γ.rightOp.obj X) =
    𝟙 (Scheme.Γ.rightOp.obj X)
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
tactic: have := ΓSpec.adjunction.left_triangle_components X
state_before: X : Scheme
this :
  Scheme.Γ.rightOp.map (adjunction.unit.app X) ≫ adjunction.counit.app (Scheme.Γ.rightOp.obj X) =
    𝟙 (Scheme.Γ.rightOp.obj X)
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
state_after: X : Scheme
this : (Scheme.Hom.app (adjunction.unit.app X) ⊤).op ≫ (Scheme.ΓSpecIso Γ(X, ⊤)).inv.op = 𝟙 (op Γ(X, ⊤))
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
tactic: dsimp at this
state_before: X : Scheme
this : (Scheme.Hom.app (adjunction.unit.app X) ⊤).op ≫ (Scheme.ΓSpecIso Γ(X, ⊤)).inv.op = 𝟙 (op Γ(X, ⊤))
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
state_after: X : Scheme
this : (Scheme.Hom.app (adjunction.unit.app X) ⊤).op = 𝟙 (op Γ(X, ⊤)) ≫ inv (Scheme.ΓSpecIso Γ(X, ⊤)).inv.op
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
tactic: rw [← IsIso.eq_comp_inv] at this
state_before: X : Scheme
this : (Scheme.Hom.app (adjunction.unit.app X) ⊤).op = 𝟙 (op Γ(X, ⊤)) ≫ inv (Scheme.ΓSpecIso Γ(X, ⊤)).inv.op
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
state_after: X : Scheme
this : (Scheme.Hom.app (adjunction.unit.app X) ⊤).op = inv (Scheme.ΓSpecIso Γ(X, ⊤)).inv.op
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
tactic: simp only [adjunction_counit_app, Functor.id_obj, Functor.comp_obj, Functor.rightOp_obj,
    Scheme.Γ_obj, Category.id_comp] at this
state_before: X : Scheme
this : (Scheme.Hom.app (adjunction.unit.app X) ⊤).op = inv (Scheme.ΓSpecIso Γ(X, ⊤)).inv.op
⊢ Scheme.Hom.app (adjunction.unit.app X) ⊤ = (Scheme.ΓSpecIso Γ(X, ⊤)).hom
state_after: no goals
tactic: rw [← Quiver.Hom.op_inj.eq_iff, this, ← op_inv, IsIso.Iso.inv_inv]