ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: wellOrderSucc_le
File: Mathlib/Order/IsWellOrderLimitElement.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : IsWellOrder α fun x x_1 => x < x_1
a b : α
ha : a < b
⊢ wellOrderSucc a ≤ b
state_after: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : IsWellOrder α fun x x_1 => x < x_1
a b : α
ha : a < b
⊢ (if h : ∃ y, a < y then ⋯.min {y | a < y} h else a) ≤ b
tactic: dsimp [wellOrderSucc, WellFounded.succ]
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : IsWellOrder α fun x x_1 => x < x_1
a b : α
ha : a < b
⊢ (if h : ∃ y, a < y then ⋯.min {y | a < y} h else a) ≤ b
state_after: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : IsWellOrder α fun x x_1 => x < x_1
a b : α
ha : a < b
⊢ ⋯.min {y | a < y} ⋯ ≤ b
tactic: rw [dif_pos ⟨_, ha⟩]
state_before: α : Type u_1
inst✝¹ : LinearOrder α
inst✝ : IsWellOrder α fun x x_1 => x < x_1
a b : α
ha : a < b
⊢ ⋯.min {y | a < y} ⋯ ≤ b
state_after: no goals
tactic: exact WellFounded.min_le _ ha
Theorem: Ideal.bot_isMaximal
File: Mathlib/RingTheory/Ideal/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
K : Type u
inst✝ : DivisionSemiring K
I : Ideal K
h : ⊥ = ⊤
⊢ 1 ∉ ⊤
state_after: α : Type u
β : Type v
K : Type u
inst✝ : DivisionSemiring K
I : Ideal K
h : ⊥ = ⊤
⊢ 1 ∉ ⊥
tactic: rw [← h]
state_before: α : Type u
β : Type v
K : Type u
inst✝ : DivisionSemiring K
I : Ideal K
h : ⊥ = ⊤
⊢ 1 ∉ ⊥
state_after: no goals
tactic: simp
Theorem: Nat.choose_le_centralBinom
File: Mathlib/Data/Nat/Choose/Central.lean

Proof steps:
state_before: r n : ℕ
⊢ (2 * n).choose (2 * n / 2) = (2 * n).choose n
state_after: no goals
tactic: rw [Nat.mul_div_cancel_left n zero_lt_two]
Theorem: MvPolynomial.sum_def
File: Mathlib/Algebra/MvPolynomial/Basic.lean

Proof steps:
state_before: R : Type u
S₁ : Type v
S₂ : Type w
S₃ : Type x
σ : Type u_1
a a' a₁ a₂ : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S₁
p✝ q : MvPolynomial σ R
A : Type u_2
inst✝ : AddCommMonoid A
p : MvPolynomial σ R
b : (σ →₀ ℕ) → R → A
⊢ sum p b = ∑ m ∈ p.support, b m (coeff m p)
state_after: no goals
tactic: simp [support, Finsupp.sum, coeff]
Theorem: Ring.choose_smul_choose
File: Mathlib/RingTheory/Binomial.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n k : ℕ
hkn : k ≤ n
⊢ n.choose k • choose r n = choose r k * choose (r - ↑k) (n - k)
state_after: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n k : ℕ
hkn : k ≤ n
⊢ (fun x => n.factorial • x) (n.choose k • choose r n) =
    (fun x => n.factorial • x) (choose r k * choose (r - ↑k) (n - k))
tactic: refine nsmul_right_injective (Nat.factorial n) (Nat.factorial_ne_zero n) ?_
state_before: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n k : ℕ
hkn : k ≤ n
⊢ (fun x => n.factorial • x) (n.choose k • choose r n) =
    (fun x => n.factorial • x) (choose r k * choose (r - ↑k) (n - k))
state_after: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n k : ℕ
hkn : k ≤ n
⊢ n.factorial • n.choose k • choose r n = n.factorial • (choose r k * choose (r - ↑k) (n - k))
tactic: simp only
state_before: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n k : ℕ
hkn : k ≤ n
⊢ n.factorial • n.choose k • choose r n = n.factorial • (choose r k * choose (r - ↑k) (n - k))
state_after: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n k : ℕ
hkn : k ≤ n
⊢ n.choose k • (descPochhammer ℤ n).smeval r =
    n.choose k • ((descPochhammer ℤ k).smeval r * (descPochhammer ℤ (n - k)).smeval (r - ↑k))
tactic: rw [nsmul_left_comm, ← descPochhammer_eq_factorial_smul_choose,
    ← Nat.choose_mul_factorial_mul_factorial hkn, ← smul_mul_smul,
    ← descPochhammer_eq_factorial_smul_choose, mul_nsmul',
    ← descPochhammer_eq_factorial_smul_choose, smul_mul_assoc]
state_before: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n k : ℕ
hkn : k ≤ n
⊢ n.choose k • (descPochhammer ℤ n).smeval r =
    n.choose k • ((descPochhammer ℤ k).smeval r * (descPochhammer ℤ (n - k)).smeval (r - ↑k))
state_after: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n k : ℕ
hkn : k ≤ n
⊢ n.choose k • (descPochhammer ℤ (n - k + k)).smeval r =
    n.choose k • ((descPochhammer ℤ k).smeval r * (descPochhammer ℤ (n - k)).smeval (r - ↑k))
tactic: nth_rw 2 [← Nat.sub_add_cancel hkn]
state_before: R : Type u_1
inst✝³ : NonAssocRing R
inst✝² : Pow R ℕ
inst✝¹ : BinomialRing R
inst✝ : NatPowAssoc R
r : R
n k : ℕ
hkn : k ≤ n
⊢ n.choose k • (descPochhammer ℤ (n - k + k)).smeval r =
    n.choose k • ((descPochhammer ℤ k).smeval r * (descPochhammer ℤ (n - k)).smeval (r - ↑k))
state_after: no goals
tactic: rw [add_comm, ← descPochhammer_mul, smeval_mul, smeval_comp, smeval_sub, smeval_X,
    ← C_eq_natCast, smeval_C, npow_one, npow_zero, zsmul_one, Int.cast_natCast, nsmul_eq_mul]
Theorem: dvd_geom_sum₂_iff_of_dvd_sub'
File: Mathlib/NumberTheory/Multiplicity.lean

Proof steps:
state_before: R : Type u_1
n : ℕ
inst✝ : CommRing R
a b x✝ y✝ x y p : R
h : p ∣ x - y
⊢ p ∣ ∑ i ∈ range n, x ^ i * y ^ (n - 1 - i) ↔ p ∣ ↑n * x ^ (n - 1)
state_after: R : Type u_1
n : ℕ
inst✝ : CommRing R
a b x✝ y✝ x y p : R
h : p ∣ x - y
⊢ p ∣ y - x
tactic: rw [geom_sum₂_comm, dvd_geom_sum₂_iff_of_dvd_sub]
state_before: R : Type u_1
n : ℕ
inst✝ : CommRing R
a b x✝ y✝ x y p : R
h : p ∣ x - y
⊢ p ∣ y - x
state_after: no goals
tactic: simpa using h.neg_right
Theorem: UpperSet.Ici_sSup
File: Mathlib/Order/UpperLower/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝ : CompleteLattice α
S : Set α
c : α
⊢ c ∈ Ici (sSup S) ↔ c ∈ ⨆ a ∈ S, Ici a
state_after: no goals
tactic: simp only [mem_Ici_iff, mem_iSup_iff, sSup_le_iff]
Theorem: CategoryTheory.IsPushout.id_vert
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/CommSq.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
Z X Y P : C
f✝ : Z ⟶ X
g : Z ⟶ Y
inl : X ⟶ P
inr : Y ⟶ P
f : X ⟶ Z
⊢ f ≫ 𝟙 Z = 𝟙 X ≫ f
state_after: no goals
tactic: simp only [Category.id_comp, Category.comp_id]
Theorem: pow_nonneg
File: Mathlib/Algebra/Order/Ring/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u
β : Type u_1
inst✝³ : Semiring α
inst✝² : Preorder α
a b c d : α
inst✝¹ : ZeroLEOneClass α
inst✝ : PosMulMono α
H : 0 ≤ a
⊢ 0 ≤ a ^ 0
state_after: α : Type u
β : Type u_1
inst✝³ : Semiring α
inst✝² : Preorder α
a b c d : α
inst✝¹ : ZeroLEOneClass α
inst✝ : PosMulMono α
H : 0 ≤ a
⊢ 0 ≤ 1
tactic: rw [pow_zero]
state_before: α : Type u
β : Type u_1
inst✝³ : Semiring α
inst✝² : Preorder α
a b c d : α
inst✝¹ : ZeroLEOneClass α
inst✝ : PosMulMono α
H : 0 ≤ a
⊢ 0 ≤ 1
state_after: no goals
tactic: exact zero_le_one
state_before: α : Type u
β : Type u_1
inst✝³ : Semiring α
inst✝² : Preorder α
a b c d : α
inst✝¹ : ZeroLEOneClass α
inst✝ : PosMulMono α
H : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ (n + 1)
state_after: α : Type u
β : Type u_1
inst✝³ : Semiring α
inst✝² : Preorder α
a b c d : α
inst✝¹ : ZeroLEOneClass α
inst✝ : PosMulMono α
H : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ n * a
tactic: rw [pow_succ]
state_before: α : Type u
β : Type u_1
inst✝³ : Semiring α
inst✝² : Preorder α
a b c d : α
inst✝¹ : ZeroLEOneClass α
inst✝ : PosMulMono α
H : 0 ≤ a
n : ℕ
⊢ 0 ≤ a ^ n * a
state_after: no goals
tactic: exact mul_nonneg (pow_nonneg H _) H
Theorem: Finset.centerMass_smul
File: Mathlib/Analysis/Convex/Combination.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
E : Type u_3
F : Type u_4
ι : Type u_5
ι' : Type u_6
α : Type u_7
inst✝⁸ : LinearOrderedField R
inst✝⁷ : LinearOrderedField R'
inst✝⁶ : AddCommGroup E
inst✝⁵ : AddCommGroup F
inst✝⁴ : LinearOrderedAddCommGroup α
inst✝³ : Module R E
inst✝² : Module R F
inst✝¹ : Module R α
inst✝ : OrderedSMul R α
s : Set E
i j : ι
c : R
t : Finset ι
w : ι → R
z : ι → E
⊢ (t.centerMass w fun i => c • z i) = c • t.centerMass w z
state_after: no goals
tactic: simp only [Finset.centerMass, Finset.smul_sum, (mul_smul _ _ _).symm, mul_comm c, mul_assoc]
Theorem: CategoryTheory.GlueData.mapGlueData_U
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: Ideal.isUnit_iff
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J K L I : Ideal R
h : I = ⊤
⊢ ⊤ = I * ⊤
state_after: no goals
tactic: rw [mul_top, h]
Theorem: Nat.succ_div_of_not_dvd
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
hba : ¬b ∣ a + 1
⊢ (a + 1) / b = a / b
state_after: no goals
tactic: rw [succ_div, if_neg hba, Nat.add_zero]
Theorem: Finset.truncatedInf_singleton
File: Mathlib/Combinatorics/SetFamily/AhlswedeZhang.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : SemilatticeInf α
inst✝⁴ : BoundedOrder α
inst✝³ : DecidableRel fun x x_1 => x ≤ x_1
inst✝² : SemilatticeInf β
inst✝¹ : BoundedOrder β
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a✝ b a : α
⊢ {b}.truncatedInf a = if b ≤ a then b else ⊥
state_after: α : Type u_1
β : Type u_2
inst✝⁵ : SemilatticeInf α
inst✝⁴ : BoundedOrder α
inst✝³ : DecidableRel fun x x_1 => x ≤ x_1
inst✝² : SemilatticeInf β
inst✝¹ : BoundedOrder β
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a✝ b a : α
⊢ (if h : b ≤ a then (filter (fun x => x ≤ a) {b}).inf' ⋯ fun x => x else ⊥) = if b ≤ a then b else ⊥
tactic: simp only [truncatedInf, coe_singleton, upperClosure_singleton, UpperSet.mem_Ici_iff,
    filter_congr_decidable, id_eq]
state_before: α : Type u_1
β : Type u_2
inst✝⁵ : SemilatticeInf α
inst✝⁴ : BoundedOrder α
inst✝³ : DecidableRel fun x x_1 => x ≤ x_1
inst✝² : SemilatticeInf β
inst✝¹ : BoundedOrder β
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
s t : Finset α
a✝ b a : α
⊢ (if h : b ≤ a then (filter (fun x => x ≤ a) {b}).inf' ⋯ fun x => x else ⊥) = if b ≤ a then b else ⊥
state_after: no goals
tactic: split_ifs <;> simp [Finset.filter_true_of_mem, *]
Theorem: MeasureTheory.Submartingale.mul_lintegral_upcrossings_le_lintegral_pos_part
File: Mathlib/Probability/Martingale/Upcrossing.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
a b : ℝ
hf : Submartingale f ℱ μ
⊢ ENNReal.ofReal (b - a) * ∫⁻ (ω : Ω), upcrossings a b f ω ∂μ ≤ ⨆ N, ∫⁻ (ω : Ω), ENNReal.ofReal (f N ω - a)⁺ ∂μ
state_after: case pos
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
a b : ℝ
hf : Submartingale f ℱ μ
hab : a < b
⊢ ENNReal.ofReal (b - a) * ∫⁻ (ω : Ω), upcrossings a b f ω ∂μ ≤ ⨆ N, ∫⁻ (ω : Ω), ENNReal.ofReal (f N ω - a)⁺ ∂μ

case neg
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a✝ b✝ : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
ℱ : Filtration ℕ m0
inst✝ : IsFiniteMeasure μ
a b : ℝ
hf : Submartingale f ℱ μ
hab : ¬a < b
⊢ ENNReal.ofReal (b - a) * ∫⁻ (ω : Ω), upcrossings a b f ω ∂μ ≤ ⨆ N, ∫⁻ (ω : Ω), ENNReal.ofReal (f N ω - a)⁺ ∂μ
tactic: by_cases hab : a < b
Theorem: Lagrange.derivative_nodal
File: Mathlib/LinearAlgebra/Lagrange.lean

Proof steps:
state_before: R : Type u_1
inst✝¹ : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝ : DecidableEq ι
⊢ derivative (nodal s v) = ∑ i ∈ s, nodal (s.erase i) v
state_after: case refine_1
R : Type u_1
inst✝¹ : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝ : DecidableEq ι
⊢ derivative (nodal ∅ v) = ∑ i ∈ ∅, nodal (∅.erase i) v

case refine_2
R : Type u_1
inst✝¹ : CommRing R
ι : Type u_2
s : Finset ι
v : ι → R
inst✝ : DecidableEq ι
i : ι
t : Finset ι
hit : i ∉ t
IH : derivative (nodal t v) = ∑ i ∈ t, nodal (t.erase i) v
⊢ derivative (nodal (insert i t) v) = ∑ i_1 ∈ insert i t, nodal ((insert i t).erase i_1) v
tactic: refine s.induction_on ?_ fun i t hit IH => ?_
Theorem: Complex.frontier_setOf_le_re_and_le_im
File: Mathlib/Analysis/Complex/ReImTopology.lean

Proof steps:
state_before: a b : ℝ
⊢ frontier {z | a ≤ z.re ∧ b ≤ z.im} = {z | a ≤ z.re ∧ z.im = b ∨ z.re = a ∧ b ≤ z.im}
state_after: no goals
tactic: simpa only [closure_Ici, frontier_Ici] using frontier_reProdIm (Ici a) (Ici b)
Theorem: sub_eq_iff_eq_add
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
⊢ a / b = c ↔ a = c * b
state_after: no goals
tactic: rw [div_eq_mul_inv, mul_inv_eq_iff_eq_mul]
Theorem: Multiset.sum_lt_sum_of_nonempty
File: Mathlib/Algebra/Order/BigOperators/Group/Multiset.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCancelCommMonoid α
s : Multiset ι
f g : ι → α
hs : s ≠ ∅
hfg : ∀ i ∈ s, f i < g i
⊢ (map f s).prod < (map g s).prod
state_after: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCancelCommMonoid α
s : Multiset ι
f g : ι → α
hs : s ≠ ∅
hfg : ∀ i ∈ s, f i < g i
i : ι
hi : i ∈ s
⊢ (map f s).prod < (map g s).prod
tactic: obtain ⟨i, hi⟩ := exists_mem_of_ne_zero hs
state_before: case intro
ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : OrderedCancelCommMonoid α
s : Multiset ι
f g : ι → α
hs : s ≠ ∅
hfg : ∀ i ∈ s, f i < g i
i : ι
hi : i ∈ s
⊢ (map f s).prod < (map g s).prod
state_after: no goals
tactic: exact prod_lt_prod' (fun i hi => le_of_lt (hfg i hi)) ⟨i, hi, hfg i hi⟩
Theorem: Finsupp.nonTorsionWeight_of
File: Mathlib/Data/Finsupp/Weight.lean

Proof steps:
state_before: σ : Type u_1
M : Type u_2
w : σ → M
inst✝¹ : AddCommMonoid M
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
n : ℕ
s : σ
h : n • w s = 0
⊢ n = 0
state_after: σ : Type u_1
M : Type u_2
w : σ → M
inst✝¹ : AddCommMonoid M
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
n : ℕ
s : σ
h : ¬w s = 0 → n = 0
⊢ n = 0
tactic: rw [smul_eq_zero, or_iff_not_imp_right] at h
state_before: σ : Type u_1
M : Type u_2
w : σ → M
inst✝¹ : AddCommMonoid M
inst✝ : NoZeroSMulDivisors ℕ M
hw : ∀ (i : σ), w i ≠ 0
n : ℕ
s : σ
h : ¬w s = 0 → n = 0
⊢ n = 0
state_after: no goals
tactic: exact h (hw s)
Theorem: TrivSqZeroExt.norm_def
File: Mathlib/Analysis/Normed/Algebra/TrivSqZeroExt.lean

Proof steps:
state_before: 𝕜 : Type u_1
S : Type u_2
R : Type u_3
M : Type u_4
inst✝¹³ : SeminormedCommRing S
inst✝¹² : SeminormedRing R
inst✝¹¹ : SeminormedAddCommGroup M
inst✝¹⁰ : Algebra S R
inst✝⁹ : Module S M
inst✝⁸ : Module R M
inst✝⁷ : Module Rᵐᵒᵖ M
inst✝⁶ : BoundedSMul S R
inst✝⁵ : BoundedSMul S M
inst✝⁴ : BoundedSMul R M
inst✝³ : BoundedSMul Rᵐᵒᵖ M
inst✝² : SMulCommClass R Rᵐᵒᵖ M
inst✝¹ : IsScalarTower S R M
inst✝ : IsScalarTower S Rᵐᵒᵖ M
x : tsze R M
⊢ ‖x‖ = ‖x.fst‖ + ‖x.snd‖
state_after: 𝕜 : Type u_1
S : Type u_2
R : Type u_3
M : Type u_4
inst✝¹³ : SeminormedCommRing S
inst✝¹² : SeminormedRing R
inst✝¹¹ : SeminormedAddCommGroup M
inst✝¹⁰ : Algebra S R
inst✝⁹ : Module S M
inst✝⁸ : Module R M
inst✝⁷ : Module Rᵐᵒᵖ M
inst✝⁶ : BoundedSMul S R
inst✝⁵ : BoundedSMul S M
inst✝⁴ : BoundedSMul R M
inst✝³ : BoundedSMul Rᵐᵒᵖ M
inst✝² : SMulCommClass R Rᵐᵒᵖ M
inst✝¹ : IsScalarTower S R M
inst✝ : IsScalarTower S Rᵐᵒᵖ M
x : tsze R M
⊢ (‖x.1‖ ^ ENNReal.toReal 1 + ‖x.2‖ ^ ENNReal.toReal 1) ^ (1 / ENNReal.toReal 1) = ‖x.fst‖ + ‖x.snd‖
tactic: rw [WithLp.prod_norm_eq_add (by norm_num)]
state_before: 𝕜 : Type u_1
S : Type u_2
R : Type u_3
M : Type u_4
inst✝¹³ : SeminormedCommRing S
inst✝¹² : SeminormedRing R
inst✝¹¹ : SeminormedAddCommGroup M
inst✝¹⁰ : Algebra S R
inst✝⁹ : Module S M
inst✝⁸ : Module R M
inst✝⁷ : Module Rᵐᵒᵖ M
inst✝⁶ : BoundedSMul S R
inst✝⁵ : BoundedSMul S M
inst✝⁴ : BoundedSMul R M
inst✝³ : BoundedSMul Rᵐᵒᵖ M
inst✝² : SMulCommClass R Rᵐᵒᵖ M
inst✝¹ : IsScalarTower S R M
inst✝ : IsScalarTower S Rᵐᵒᵖ M
x : tsze R M
⊢ (‖x.1‖ ^ ENNReal.toReal 1 + ‖x.2‖ ^ ENNReal.toReal 1) ^ (1 / ENNReal.toReal 1) = ‖x.fst‖ + ‖x.snd‖
state_after: 𝕜 : Type u_1
S : Type u_2
R : Type u_3
M : Type u_4
inst✝¹³ : SeminormedCommRing S
inst✝¹² : SeminormedRing R
inst✝¹¹ : SeminormedAddCommGroup M
inst✝¹⁰ : Algebra S R
inst✝⁹ : Module S M
inst✝⁸ : Module R M
inst✝⁷ : Module Rᵐᵒᵖ M
inst✝⁶ : BoundedSMul S R
inst✝⁵ : BoundedSMul S M
inst✝⁴ : BoundedSMul R M
inst✝³ : BoundedSMul Rᵐᵒᵖ M
inst✝² : SMulCommClass R Rᵐᵒᵖ M
inst✝¹ : IsScalarTower S R M
inst✝ : IsScalarTower S Rᵐᵒᵖ M
x : tsze R M
⊢ ‖x.1‖ + ‖x.2‖ = ‖x.fst‖ + ‖x.snd‖
tactic: simp only [ENNReal.one_toReal, Real.rpow_one, div_one]
state_before: 𝕜 : Type u_1
S : Type u_2
R : Type u_3
M : Type u_4
inst✝¹³ : SeminormedCommRing S
inst✝¹² : SeminormedRing R
inst✝¹¹ : SeminormedAddCommGroup M
inst✝¹⁰ : Algebra S R
inst✝⁹ : Module S M
inst✝⁸ : Module R M
inst✝⁷ : Module Rᵐᵒᵖ M
inst✝⁶ : BoundedSMul S R
inst✝⁵ : BoundedSMul S M
inst✝⁴ : BoundedSMul R M
inst✝³ : BoundedSMul Rᵐᵒᵖ M
inst✝² : SMulCommClass R Rᵐᵒᵖ M
inst✝¹ : IsScalarTower S R M
inst✝ : IsScalarTower S Rᵐᵒᵖ M
x : tsze R M
⊢ ‖x.1‖ + ‖x.2‖ = ‖x.fst‖ + ‖x.snd‖
state_after: no goals
tactic: rfl
Theorem: NNReal.rpow_of_add_eq
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: w x✝ y z : ℝ
x : ℝ≥0
hw : w ≠ 0
h : y + z = w
⊢ x ^ w = x ^ y * x ^ z
state_after: case h
w x✝ y z : ℝ
x : ℝ≥0
hw : w ≠ 0
h : y + z = w
⊢ y + z ≠ 0
tactic: rw [← h, rpow_add']
state_before: case h
w x✝ y z : ℝ
x : ℝ≥0
hw : w ≠ 0
h : y + z = w
⊢ y + z ≠ 0
state_after: no goals
tactic: rwa [h]
Theorem: List.perm_orderedInsert
File: Mathlib/Data/List/Sort.lean

Proof steps:
state_before: α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
⊢ orderedInsert r a (b :: l) ~ a :: b :: l
state_after: case pos
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
h : r a b
⊢ orderedInsert r a (b :: l) ~ a :: b :: l

case neg
α : Type u
r : α → α → Prop
inst✝ : DecidableRel r
a b : α
l : List α
h : ¬r a b
⊢ orderedInsert r a (b :: l) ~ a :: b :: l
tactic: by_cases h : a ≼ b
Theorem: one_lt_pow'
File: Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean

Proof steps:
state_before: β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
k : ℕ
hk : k ≠ 0
⊢ 1 < a ^ k
state_after: case intro
β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
hk : l.succ ≠ 0
⊢ 1 < a ^ l.succ
tactic: rcases Nat.exists_eq_succ_of_ne_zero hk with ⟨l, rfl⟩
state_before: case intro
β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
hk : l.succ ≠ 0
⊢ 1 < a ^ l.succ
state_after: case intro
β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
⊢ 1 < a ^ l.succ
tactic: clear hk
state_before: case intro
β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
⊢ 1 < a ^ l.succ
state_after: case intro.zero
β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
⊢ 1 < a ^ Nat.succ 0

case intro.succ
β : Type u_1
G : Type u_2
M : Type u_3
inst✝² : Monoid M
inst✝¹ : Preorder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x a : M
ha : 1 < a
l : ℕ
IH : 1 < a ^ l.succ
⊢ 1 < a ^ (l + 1).succ
tactic: induction' l with l IH
Theorem: Irreducible.normalizedFactors_pow
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

Proof steps:
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
inst✝¹ : NormalizationMonoid α
inst✝ : UniqueFactorizationMonoid α
p : α
hp : Irreducible p
k : ℕ
⊢ normalizedFactors (p ^ k) = Multiset.replicate k (normalize p)
state_after: no goals
tactic: rw [UniqueFactorizationMonoid.normalizedFactors_pow, normalizedFactors_irreducible hp,
    Multiset.nsmul_singleton]
Theorem: Algebra.trace_complex_apply
File: Mathlib/RingTheory/Complex.lean

Proof steps:
state_before: z : ℂ
⊢ (trace ℝ ℂ) z = 2 * z.re
state_after: z : ℂ
⊢ !![z.re, -z.im; z.im, z.re] 0 0 + !![z.re, -z.im; z.im, z.re] 1 1 = 2 * z.re
tactic: rw [Algebra.trace_eq_matrix_trace Complex.basisOneI, Algebra.leftMulMatrix_complex,
    Matrix.trace_fin_two]
state_before: z : ℂ
⊢ !![z.re, -z.im; z.im, z.re] 0 0 + !![z.re, -z.im; z.im, z.re] 1 1 = 2 * z.re
state_after: no goals
tactic: exact (two_mul _).symm
Theorem: Sublattice.map_top
File: Mathlib/Order/Sublattice.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L M : Sublattice α
f✝ : LatticeHom α β
s t : Set α
a : α
f : LatticeHom α β
h : Surjective ⇑f
⊢ ↑(map f ⊤) = ↑⊤
state_after: no goals
tactic: simp [h.range_eq]
Theorem: Asymptotics.IsBigOWith.weaken
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
E : Type u_3
F : Type u_4
G : Type u_5
E' : Type u_6
F' : Type u_7
G' : Type u_8
E'' : Type u_9
F'' : Type u_10
G'' : Type u_11
E''' : Type u_12
R : Type u_13
R' : Type u_14
𝕜 : Type u_15
𝕜' : Type u_16
inst✝¹³ : Norm E
inst✝¹² : Norm F
inst✝¹¹ : Norm G
inst✝¹⁰ : SeminormedAddCommGroup E'
inst✝⁹ : SeminormedAddCommGroup F'
inst✝⁸ : SeminormedAddCommGroup G'
inst✝⁷ : NormedAddCommGroup E''
inst✝⁶ : NormedAddCommGroup F''
inst✝⁵ : NormedAddCommGroup G''
inst✝⁴ : SeminormedRing R
inst✝³ : SeminormedAddGroup E'''
inst✝² : SeminormedRing R'
inst✝¹ : NormedDivisionRing 𝕜
inst✝ : NormedDivisionRing 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
h : IsBigOWith c l f g'
hc : c ≤ c'
x : α
hx : x ∈ {x | (fun x => ‖f x‖ ≤ c * ‖g' x‖) x}
⊢ c * ‖g' x‖ ≤ c' * ‖g' x‖
state_after: no goals
tactic: gcongr