ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Nat.floorRoot_one_left
File: Mathlib/Data/Nat/Factorization/Root.lean

Proof steps:
state_before: a✝ b n a : ℕ
⊢ floorRoot 1 a = a
state_after: a✝ b n a : ℕ
⊢ (if a = 0 then 0 else a.factorization.prod fun p k => p ^ k) = a
tactic: simp [floorRoot]
state_before: a✝ b n a : ℕ
⊢ (if a = 0 then 0 else a.factorization.prod fun p k => p ^ k) = a
state_after: no goals
tactic: split_ifs <;> simp [*]
Theorem: HasDerivAt.comp_add_const
File: Mathlib/Analysis/Calculus/Deriv/Shift.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
x a : 𝕜
𝕜' : Type u_2
inst✝¹ : NormedAddCommGroup 𝕜'
inst✝ : NormedSpace 𝕜 𝕜'
h : 𝕜 → 𝕜'
h' : 𝕜'
hh : HasDerivAt h h' (x + a)
⊢ HasDerivAt (fun x => h (x + a)) h' x
state_after: no goals
tactic: simpa [Function.comp_def] using HasDerivAt.scomp (𝕜 := 𝕜) x hh <| hasDerivAt_id' x |>.add_const a
Theorem: CategoryTheory.GlueData.mapGlueData_f
File: Mathlib/CategoryTheory/GlueData.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (D.f i j) (D.f i k)) F
i : D.J
⊢ (fun i j => F.map (D.t i j)) i i = 𝟙 ((fun i => F.obj (D.V i)) (i, i))
state_after: no goals
tactic: simp [D.t_id i]
state_before: C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (D.f i j) (D.f i k)) F
i j k : D.J
⊢ (fun i j k =>
          (PreservesPullback.iso F (D.f i j) (D.f i k)).inv ≫
            F.map (D.t' i j k) ≫ (PreservesPullback.iso F (D.f j k) (D.f j i)).hom)
        i j k ≫
      pullback.snd ((fun i j => F.map (D.f i j)) j k) ((fun i j => F.map (D.f i j)) j i) =
    pullback.fst ((fun i j => F.map (D.f i j)) i j) ((fun i j => F.map (D.f i j)) i k) ≫
      (fun i j => F.map (D.t i j)) i j
state_after: no goals
tactic: simpa [Iso.inv_comp_eq] using congr_arg (fun f => F.map f) (D.t_fac i j k)
state_before: C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (D.f i j) (D.f i k)) F
i j k : D.J
⊢ (fun i j k =>
          (PreservesPullback.iso F (D.f i j) (D.f i k)).inv ≫
            F.map (D.t' i j k) ≫ (PreservesPullback.iso F (D.f j k) (D.f j i)).hom)
        i j k ≫
      (fun i j k =>
            (PreservesPullback.iso F (D.f i j) (D.f i k)).inv ≫
              F.map (D.t' i j k) ≫ (PreservesPullback.iso F (D.f j k) (D.f j i)).hom)
          j k i ≫
        (fun i j k =>
            (PreservesPullback.iso F (D.f i j) (D.f i k)).inv ≫
              F.map (D.t' i j k) ≫ (PreservesPullback.iso F (D.f j k) (D.f j i)).hom)
          k i j =
    𝟙 (pullback ((fun i j => F.map (D.f i j)) i j) ((fun i j => F.map (D.f i j)) i k))
state_after: no goals
tactic: simp only [Category.assoc, Iso.hom_inv_id_assoc, ← Functor.map_comp_assoc, D.cocycle,
      Iso.inv_hom_id, CategoryTheory.Functor.map_id, Category.id_comp]
Theorem: List.alternatingSum_cons
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝ : CommGroup α
a : α
l : List α
⊢ (a :: l).alternatingProd = a / l.alternatingProd
state_after: no goals
tactic: rw [div_eq_mul_inv, alternatingProd_cons']
Theorem: Filter.Tendsto.atBot_mul
File: Mathlib/Topology/Algebra/Order/Field.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : 0 < C
hf : Tendsto f l atBot
hg : Tendsto g l (𝓝 C)
⊢ Tendsto (fun x => f x * g x) l atBot
state_after: 𝕜 : Type u_1
α : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : TopologicalSpace 𝕜
inst✝ : OrderTopology 𝕜
l : Filter α
f g : α → 𝕜
C : 𝕜
hC : 0 < C
hf : Tendsto f l atBot
hg : Tendsto g l (𝓝 C)
this : Tendsto (fun x => (Neg.neg ∘ f) x * g x) l atTop
⊢ Tendsto (fun x => f x * g x) l atBot
tactic: have := (tendsto_neg_atBot_atTop.comp hf).atTop_mul hC hg
Theorem: ComputablePred.rice₂
File: Mathlib/Computability/Halting.lean

Proof steps:
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
C : Set Code
H : ∀ (cf cg : Code), cf.eval = cg.eval → (cf ∈ C ↔ cg ∈ C)
⊢ (ComputablePred fun c => c ∈ C) ↔ C = ∅ ∨ C = Set.univ
state_after: no goals
tactic: classical exact
      have hC : ∀ f, f ∈ C ↔ eval f ∈ eval '' C := fun f =>
        ⟨Set.mem_image_of_mem _, fun ⟨g, hg, e⟩ => (H _ _ e).1 hg⟩
      ⟨fun h =>
        or_iff_not_imp_left.2 fun C0 =>
          Set.eq_univ_of_forall fun cg =>
            let ⟨cf, fC⟩ := Set.nonempty_iff_ne_empty.2 C0
            (hC _).2 <|
              rice (eval '' C) (h.of_eq hC)
                (Partrec.nat_iff.1 <| eval_part.comp (const cf) Computable.id)
                (Partrec.nat_iff.1 <| eval_part.comp (const cg) Computable.id) ((hC _).1 fC),
        fun h => by {
          obtain rfl | rfl := h <;> simpa [ComputablePred, Set.mem_empty_iff_false] using
            ⟨by infer_instance, Computable.const _⟩ }⟩
Theorem: SSet.Augmented.StandardSimplex.shiftFun_succ
File: Mathlib/AlgebraicTopology/ExtraDegeneracy.lean

Proof steps:
state_before: n : ℕ
X : Type u_1
inst✝ : Zero X
f : Fin n → X
i : Fin n
⊢ shiftFun f i.succ = f i
state_after: n : ℕ
X : Type u_1
inst✝ : Zero X
f : Fin n → X
i : Fin n
⊢ (if x : i.succ = 0 then 0 else f (i.succ.pred x)) = f i
tactic: dsimp [shiftFun]
state_before: n : ℕ
X : Type u_1
inst✝ : Zero X
f : Fin n → X
i : Fin n
⊢ (if x : i.succ = 0 then 0 else f (i.succ.pred x)) = f i
state_after: case pos
n : ℕ
X : Type u_1
inst✝ : Zero X
f : Fin n → X
i : Fin n
h : i.succ = 0
⊢ 0 = f i

case neg
n : ℕ
X : Type u_1
inst✝ : Zero X
f : Fin n → X
i : Fin n
h : ¬i.succ = 0
⊢ f (i.succ.pred h) = f i
tactic: split_ifs with h
Theorem: Matrix.mul_sub
File: Mathlib/Data/Matrix/Basic.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
m' : o → Type u_5
n' : o → Type u_6
R : Type u_7
S : Type u_8
α : Type v
β : Type w
γ : Type u_9
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
M : Matrix m n α
N N' : Matrix n o α
⊢ M * (N - N') = M * N - M * N'
state_after: no goals
tactic: rw [sub_eq_add_neg, Matrix.mul_add, Matrix.mul_neg, sub_eq_add_neg]
Theorem: WeierstrassCurve.Jacobian.addX_of_X_eq
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P Q : Fin 3 → F
hP : W.Equation P
hQ : W.Equation Q
hPz : P z ≠ 0
hQz : Q z ≠ 0
hx : P x * Q z ^ 2 = Q x * P z ^ 2
⊢ W.addX P Q = addU P Q ^ 2
state_after: no goals
tactic: rw [addU, neg_sq, div_pow, ← addX_of_X_eq' hP hQ hx,
    mul_div_cancel_right₀ _ <| pow_ne_zero 2 <| mul_ne_zero hPz hQz]
Theorem: Equiv.Perm.coe_support_eq_set_support
File: Mathlib/GroupTheory/Perm/Support.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
⊢ ↑f.support = {x | f x ≠ x}
state_after: case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
x✝ : α
⊢ x✝ ∈ ↑f.support ↔ x✝ ∈ {x | f x ≠ x}
tactic: ext
state_before: case h
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
x✝ : α
⊢ x✝ ∈ ↑f.support ↔ x✝ ∈ {x | f x ≠ x}
state_after: no goals
tactic: simp
Theorem: tendsto_exp_div_rpow_atTop
File: Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean

Proof steps:
state_before: s : ℝ
⊢ Tendsto (fun x => rexp x / x ^ s) atTop atTop
state_after: case intro
s : ℝ
n : ℕ
hn : s < ↑n
⊢ Tendsto (fun x => rexp x / x ^ s) atTop atTop
tactic: cases' archimedean_iff_nat_lt.1 Real.instArchimedean s with n hn
state_before: case intro
s : ℝ
n : ℕ
hn : s < ↑n
⊢ Tendsto (fun x => rexp x / x ^ s) atTop atTop
state_after: case intro
s : ℝ
n : ℕ
hn : s < ↑n
⊢ (fun x => rexp x / x ^ n) ≤ᶠ[atTop] fun x => rexp x / x ^ s
tactic: refine tendsto_atTop_mono' _ ?_ (tendsto_exp_div_pow_atTop n)
state_before: case intro
s : ℝ
n : ℕ
hn : s < ↑n
⊢ (fun x => rexp x / x ^ n) ≤ᶠ[atTop] fun x => rexp x / x ^ s
state_after: case h
s : ℝ
n : ℕ
hn : s < ↑n
x : ℝ
hx₀ : 0 < x
hx₁ : 1 ≤ x
⊢ rexp x / x ^ n ≤ rexp x / x ^ s
tactic: filter_upwards [eventually_gt_atTop (0 : ℝ), eventually_ge_atTop (1 : ℝ)] with x hx₀ hx₁
state_before: case h
s : ℝ
n : ℕ
hn : s < ↑n
x : ℝ
hx₀ : 0 < x
hx₁ : 1 ≤ x
⊢ rexp x / x ^ n ≤ rexp x / x ^ s
state_after: case h
s : ℝ
n : ℕ
hn : s < ↑n
x : ℝ
hx₀ : 0 < x
hx₁ : 1 ≤ x
⊢ x ^ s ≤ x ^ ↑n
tactic: rw [div_le_div_left (exp_pos _) (pow_pos hx₀ _) (rpow_pos_of_pos hx₀ _), ← Real.rpow_natCast]
state_before: case h
s : ℝ
n : ℕ
hn : s < ↑n
x : ℝ
hx₀ : 0 < x
hx₁ : 1 ≤ x
⊢ x ^ s ≤ x ^ ↑n
state_after: no goals
tactic: exact rpow_le_rpow_of_exponent_le hx₁ hn.le
Theorem: Set.insert_sigma
File: Mathlib/Data/Set/Sigma.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β✝² : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
β✝¹ : Type u_5
inst✝ : CompleteLattice β✝¹
β✝ : Type u_6
β : ι → Type u_7
⊢ (insert i s).sigma t = Sigma.mk i '' t i ∪ s.sigma t
state_after: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β✝² : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
β✝¹ : Type u_5
inst✝ : CompleteLattice β✝¹
β✝ : Type u_6
β : ι → Type u_7
⊢ α i
tactic: rw [insert_eq, union_sigma, singleton_sigma]
state_before: ι : Type u_1
ι' : Type u_2
α : ι → Type u_3
β✝² : ι → Type u_4
s s₁ s₂ : Set ι
t t₁ t₂ : (i : ι) → Set (α i)
u : Set ((i : ι) × α i)
x : (i : ι) × α i
i j : ι
a : α i
β✝¹ : Type u_5
inst✝ : CompleteLattice β✝¹
β✝ : Type u_6
β : ι → Type u_7
⊢ α i
state_after: no goals
tactic: exact a
Theorem: setOf_isPreconnected_eq_of_ordered
File: Mathlib/Topology/Order/IntermediateValue.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
inst✝¹ : Nonempty γ
inst✝ : DenselyOrdered α
a b : α
⊢ {s | IsPreconnected s} =
    range (uncurry Icc) ∪ range (uncurry Ico) ∪ range (uncurry Ioc) ∪ range (uncurry Ioo) ∪
      (range Ici ∪ range Ioi ∪ range Iic ∪ range Iio ∪ {univ, ∅})
state_after: α : Type u
β : Type v
γ : Type w
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
inst✝¹ : Nonempty γ
inst✝ : DenselyOrdered α
a b : α
⊢ range (uncurry Icc) ∪ range (uncurry Ico) ∪ range (uncurry Ioc) ∪ range (uncurry Ioo) ∪
      (range Ici ∪ range Ioi ∪ range Iic ∪ range Iio ∪ {univ, ∅}) ⊆
    {s | IsPreconnected s}
tactic: refine Subset.antisymm setOf_isPreconnected_subset_of_ordered ?_
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : ConditionallyCompleteLinearOrder α
inst✝⁶ : TopologicalSpace α
inst✝⁵ : OrderTopology α
inst✝⁴ : ConditionallyCompleteLinearOrder β
inst✝³ : TopologicalSpace β
inst✝² : OrderTopology β
inst✝¹ : Nonempty γ
inst✝ : DenselyOrdered α
a b : α
⊢ range (uncurry Icc) ∪ range (uncurry Ico) ∪ range (uncurry Ioc) ∪ range (uncurry Ioo) ∪
      (range Ici ∪ range Ioi ∪ range Iic ∪ range Iio ∪ {univ, ∅}) ⊆
    {s | IsPreconnected s}
state_after: no goals
tactic: simp only [subset_def, forall_mem_range, uncurry, or_imp, forall_and, mem_union,
    mem_setOf_eq, insert_eq, mem_singleton_iff, forall_eq, forall_true_iff, and_true_iff,
    isPreconnected_Icc, isPreconnected_Ico, isPreconnected_Ioc, isPreconnected_Ioo,
    isPreconnected_Ioi, isPreconnected_Iio, isPreconnected_Ici, isPreconnected_Iic,
    isPreconnected_univ, isPreconnected_empty]
Theorem: CategoryTheory.Presheaf.imageSieve_apply
File: Mathlib/CategoryTheory/Sites/LocallySurjective.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝¹ : Category.{v', u'} A
inst✝ : ConcreteCategory A
F G : Cᵒᵖ ⥤ A
f : F ⟶ G
U : C
s : (forget A).obj (G.obj (op U))
⊢ ∀ {Y Z : C} {f_1 : Y ⟶ U},
    (fun V i => ∃ t, (f.app (op V)) t = (G.map i.op) s) Y f_1 →
      ∀ (g : Z ⟶ Y), (fun V i => ∃ t, (f.app (op V)) t = (G.map i.op) s) Z (g ≫ f_1)
state_after: case intro
C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝¹ : Category.{v', u'} A
inst✝ : ConcreteCategory A
F G : Cᵒᵖ ⥤ A
f : F ⟶ G
U : C
s : (forget A).obj (G.obj (op U))
V W : C
i : V ⟶ U
t : (forget A).obj (F.obj (op V))
ht : (f.app (op V)) t = (G.map i.op) s
j : W ⟶ V
⊢ ∃ t, (f.app (op W)) t = (G.map (j ≫ i).op) s
tactic: rintro V W i ⟨t, ht⟩ j
state_before: case intro
C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝¹ : Category.{v', u'} A
inst✝ : ConcreteCategory A
F G : Cᵒᵖ ⥤ A
f : F ⟶ G
U : C
s : (forget A).obj (G.obj (op U))
V W : C
i : V ⟶ U
t : (forget A).obj (F.obj (op V))
ht : (f.app (op V)) t = (G.map i.op) s
j : W ⟶ V
⊢ ∃ t, (f.app (op W)) t = (G.map (j ≫ i).op) s
state_after: case intro
C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝¹ : Category.{v', u'} A
inst✝ : ConcreteCategory A
F G : Cᵒᵖ ⥤ A
f : F ⟶ G
U : C
s : (forget A).obj (G.obj (op U))
V W : C
i : V ⟶ U
t : (forget A).obj (F.obj (op V))
ht : (f.app (op V)) t = (G.map i.op) s
j : W ⟶ V
⊢ (f.app (op W)) ((F.map j.op) t) = (G.map (j ≫ i).op) s
tactic: refine ⟨F.map j.op t, ?_⟩
state_before: case intro
C : Type u
inst✝² : Category.{v, u} C
J : GrothendieckTopology C
A : Type u'
inst✝¹ : Category.{v', u'} A
inst✝ : ConcreteCategory A
F G : Cᵒᵖ ⥤ A
f : F ⟶ G
U : C
s : (forget A).obj (G.obj (op U))
V W : C
i : V ⟶ U
t : (forget A).obj (F.obj (op V))
ht : (f.app (op V)) t = (G.map i.op) s
j : W ⟶ V
⊢ (f.app (op W)) ((F.map j.op) t) = (G.map (j ≫ i).op) s
state_after: no goals
tactic: rw [op_comp, G.map_comp, comp_apply, ← ht, elementwise_of% f.naturality]
Theorem: Hyperreal.infinitePos_mul_of_infiniteNeg_not_infinitesimal_neg
File: Mathlib/Data/Real/Hyperreal.lean

Proof steps:
state_before: x y : ℝ*
⊢ x.InfiniteNeg → ¬y.Infinitesimal → y < 0 → (x * y).InfinitePos
state_after: x y : ℝ*
⊢ (-x).InfinitePos → ¬(-y).Infinitesimal → 0 < -y → (-x * -y).InfinitePos
tactic: rw [← infinitePos_neg, ← neg_pos, ← neg_mul_neg, ← infinitesimal_neg]
state_before: x y : ℝ*
⊢ (-x).InfinitePos → ¬(-y).Infinitesimal → 0 < -y → (-x * -y).InfinitePos
state_after: no goals
tactic: exact infinitePos_mul_of_infinitePos_not_infinitesimal_pos
Theorem: HahnSeries.isPWO_iUnion_support_powers
File: Mathlib/RingTheory/HahnSeries/Summable.lean

Proof steps:
state_before: Γ : Type u_1
R : Type u_2
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : Ring R
inst✝ : IsDomain R
x : HahnSeries Γ R
hx : 0 < x.orderTop
⊢ (⋃ n, (x ^ n).support).IsPWO
state_after: Γ : Type u_1
R : Type u_2
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : Ring R
inst✝ : IsDomain R
x : HahnSeries Γ R
hx : 0 < x.orderTop
⊢ ∀ x_1 ∈ x.support, 0 ≤ x_1

Γ : Type u_1
R : Type u_2
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : Ring R
inst✝ : IsDomain R
x : HahnSeries Γ R
hx : 0 < x.orderTop
⊢ ⋃ n, (x ^ n).support ⊆ ↑(AddSubmonoid.closure x.support)
tactic: apply (x.isWF_support.isPWO.addSubmonoid_closure _).mono _
state_before: Γ : Type u_1
R : Type u_2
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : Ring R
inst✝ : IsDomain R
x : HahnSeries Γ R
hx : 0 < x.orderTop
⊢ ⋃ n, (x ^ n).support ⊆ ↑(AddSubmonoid.closure x.support)
state_after: Γ : Type u_1
R : Type u_2
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : Ring R
inst✝ : IsDomain R
x : HahnSeries Γ R
hx : 0 < x.orderTop
n : ℕ
⊢ (x ^ n).support ⊆ ↑(AddSubmonoid.closure x.support)
tactic: refine Set.iUnion_subset fun n => ?_
state_before: Γ : Type u_1
R : Type u_2
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : Ring R
inst✝ : IsDomain R
x : HahnSeries Γ R
hx : 0 < x.orderTop
n : ℕ
⊢ (x ^ n).support ⊆ ↑(AddSubmonoid.closure x.support)
state_after: case zero
Γ : Type u_1
R : Type u_2
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : Ring R
inst✝ : IsDomain R
x : HahnSeries Γ R
hx : 0 < x.orderTop
g : Γ
hn : g ∈ (x ^ 0).support
⊢ g ∈ ↑(AddSubmonoid.closure x.support)

case succ
Γ : Type u_1
R : Type u_2
inst✝² : LinearOrderedCancelAddCommMonoid Γ
inst✝¹ : Ring R
inst✝ : IsDomain R
x : HahnSeries Γ R
hx : 0 < x.orderTop
n : ℕ
ih : (x ^ n).support ⊆ ↑(AddSubmonoid.closure x.support)
g : Γ
hn : g ∈ (x ^ (n + 1)).support
⊢ g ∈ ↑(AddSubmonoid.closure x.support)
tactic: induction' n with n ih <;> intro g hn
Theorem: ProbabilityTheory.IndepFun.cgf_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_indep : IndepFun X Y μ
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
h_int_Y : Integrable (fun ω => rexp (t * Y ω)) μ
⊢ cgf (X + Y) μ t = cgf X μ t + cgf Y μ t
state_after: case pos
Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
h_int_Y : Integrable (fun ω => rexp (t * Y ω)) μ
hμ : μ = 0
⊢ cgf (X + Y) μ t = cgf X μ t + cgf Y μ t

case neg
Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
h_int_Y : Integrable (fun ω => rexp (t * Y ω)) μ
hμ : ¬μ = 0
⊢ cgf (X + Y) μ t = cgf X μ t + cgf Y μ t
tactic: by_cases hμ : μ = 0
state_before: case neg
Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
h_int_Y : Integrable (fun ω => rexp (t * Y ω)) μ
hμ : ¬μ = 0
⊢ cgf (X + Y) μ t = cgf X μ t + cgf Y μ t
state_after: case neg
Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
h_int_Y : Integrable (fun ω => rexp (t * Y ω)) μ
hμ : ¬μ = 0
⊢ log (mgf X μ t * mgf Y μ t) = log (mgf X μ t) + log (mgf Y μ t)
tactic: simp only [cgf, h_indep.mgf_add h_int_X.aestronglyMeasurable h_int_Y.aestronglyMeasurable]
state_before: case neg
Ω : Type u_1
ι : Type u_2
m : MeasurableSpace Ω
X✝ : Ω → ℝ
p : ℕ
μ : Measure Ω
t : ℝ
X Y : Ω → ℝ
h_indep : IndepFun X Y μ
h_int_X : Integrable (fun ω => rexp (t * X ω)) μ
h_int_Y : Integrable (fun ω => rexp (t * Y ω)) μ
hμ : ¬μ = 0
⊢ log (mgf X μ t * mgf Y μ t) = log (mgf X μ t) + log (mgf Y μ t)
state_after: no goals
tactic: exact log_mul (mgf_pos' hμ h_int_X).ne' (mgf_pos' hμ h_int_Y).ne'
Theorem: RootPairing.isCrystallographic_iff
File: Mathlib/LinearAlgebra/RootSystem/Defs.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
P : RootPairing ι R M N
i j : ι
⊢ P.IsCrystallographic ↔ ∀ (i j : ι), ∃ z, ↑z = P.pairing i j
state_after: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
P : RootPairing ι R M N
i j : ι
⊢ (∀ (i : ι), MapsTo (⇑(P.toLin (P.root i))) (range ⇑P.coroot) ↑(zmultiples 1)) ↔ ∀ (i j : ι), ∃ z, ↑z = P.pairing i j
tactic: rw [IsCrystallographic]
state_before: ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
P : RootPairing ι R M N
i j : ι
⊢ (∀ (i : ι), MapsTo (⇑(P.toLin (P.root i))) (range ⇑P.coroot) ↑(zmultiples 1)) ↔ ∀ (i j : ι), ∃ z, ↑z = P.pairing i j
state_after: case refine_1
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
P : RootPairing ι R M N
i✝ j✝ : ι
h : ∀ (i : ι), MapsTo (⇑(P.toLin (P.root i))) (range ⇑P.coroot) ↑(zmultiples 1)
i j : ι
⊢ ∃ z, ↑z = P.pairing i j

case refine_2
ι : Type u_1
R : Type u_2
M : Type u_3
N : Type u_4
inst✝⁴ : CommRing R
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
P : RootPairing ι R M N
i✝ j✝ : ι
h : ∀ (i j : ι), ∃ z, ↑z = P.pairing i j
i : ι
x✝¹ : N
x✝ : x✝¹ ∈ range ⇑P.coroot
j : ι
hj : P.coroot j = x✝¹
⊢ (P.toLin (P.root i)) x✝¹ ∈ ↑(zmultiples 1)
tactic: refine ⟨fun h i j ↦ ?_, fun h i _ ⟨j, hj⟩ ↦ ?_⟩
Theorem: Multiset.sym2_mono
File: Mathlib/Data/Multiset/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m m' : Multiset α
h : m ≤ m'
⊢ m.sym2 ≤ m'.sym2
state_after: α : Type u_1
β : Type u_2
m m' : Multiset α
h✝ : m ≤ m'
xs ys : List α
h : ⟦xs⟧ ≤ ⟦ys⟧
⊢ Multiset.sym2 ⟦xs⟧ ≤ Multiset.sym2 ⟦ys⟧
tactic: refine Quotient.inductionOn₂ m m' (fun xs ys h => ?_) h
state_before: α : Type u_1
β : Type u_2
m m' : Multiset α
h✝ : m ≤ m'
xs ys : List α
h : ⟦xs⟧ ≤ ⟦ys⟧
⊢ Multiset.sym2 ⟦xs⟧ ≤ Multiset.sym2 ⟦ys⟧
state_after: α : Type u_1
β : Type u_2
m m' : Multiset α
h✝ : m ≤ m'
xs ys : List α
h : ⟦xs⟧ ≤ ⟦ys⟧
⊢ xs <+~ ys
tactic: suffices xs <+~ ys from this.sym2
state_before: α : Type u_1
β : Type u_2
m m' : Multiset α
h✝ : m ≤ m'
xs ys : List α
h : ⟦xs⟧ ≤ ⟦ys⟧
⊢ xs <+~ ys
state_after: no goals
tactic: simpa only [quot_mk_to_coe, coe_le, sym2_coe] using h
Theorem: Fintype.sum_pow
File: Mathlib/Algebra/BigOperators/Ring.lean

Proof steps:
state_before: ι✝ : Type u_1
α✝ : Type u_2
β : Type u_3
γ : Type u_4
κ✝ : ι✝ → Type u_5
s s₁ s₂ : Finset ι✝
i : ι✝
a : α✝
f✝ g : ι✝ → α✝
ι : Type u_6
κ : Type u_7
α : Type u_8
inst✝³ : DecidableEq ι
inst✝² : Fintype ι
inst✝¹ : Fintype κ
inst✝ : CommSemiring α
f : ι → α
n : ℕ
⊢ (∑ a : ι, f a) ^ n = ∑ p : Fin n → ι, ∏ i : Fin n, f (p i)
state_after: no goals
tactic: simp [sum_pow']
Theorem: IsCompact.eventually_forall_of_forall_eventually
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
x₀ : X
K : Set Y
hK : IsCompact K
P : X → Y → Prop
hP : ∀ y ∈ K, ∀ᶠ (z : X × Y) in 𝓝 (x₀, y), P z.1 z.2
⊢ ∀ᶠ (x : X) in 𝓝 x₀, ∀ y ∈ K, P x y
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
x₀ : X
K : Set Y
hK : IsCompact K
P : X → Y → Prop
hP : ∀ᶠ (z : X × Y) in 𝓝 x₀ ×ˢ 𝓝ˢ K, P z.1 z.2
⊢ ∀ᶠ (x : X) in 𝓝 x₀, ∀ y ∈ K, P x y
tactic: simp only [nhds_prod_eq, ← eventually_iSup, ← hK.prod_nhdsSet_eq_biSup] at hP
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
x₀ : X
K : Set Y
hK : IsCompact K
P : X → Y → Prop
hP : ∀ᶠ (z : X × Y) in 𝓝 x₀ ×ˢ 𝓝ˢ K, P z.1 z.2
⊢ ∀ᶠ (x : X) in 𝓝 x₀, ∀ y ∈ K, P x y
state_after: no goals
tactic: exact hP.curry.mono fun _ h ↦ h.self_of_nhdsSet
Theorem: LinearMap.range_smul'
File: Mathlib/Algebra/Module/Submodule/Range.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝⁵ : Semifield K
inst✝⁴ : Semifield K₂
inst✝³ : AddCommMonoid V
inst✝² : Module K V
inst✝¹ : AddCommMonoid V₂
inst✝ : Module K V₂
f : V →ₗ[K] V₂
a : K
⊢ range (a • f) = ⨆ (_ : a ≠ 0), range f
state_after: no goals
tactic: simpa only [range_eq_map] using Submodule.map_smul' f _ a