ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ONote.fastGrowing_limit
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: o : ONote
f : ℕ → ONote
h : o.fundamentalSequence = Sum.inr f
⊢ o.fastGrowing = fun i => (f i).fastGrowing i
state_after: no goals
tactic: rw [fastGrowing_def h]
Theorem: AddMonoidAlgebra.freeAlgebra_lift_of_surjective_of_closure
File: Mathlib/RingTheory/FiniteType.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹ : AddMonoid M
inst✝ : CommSemiring R
S : Set M
hS : closure S = ⊤
⊢ Surjective ⇑((FreeAlgebra.lift R) fun s => of' R M ↑s)
state_after: R : Type u_1
M : Type u_2
inst✝¹ : AddMonoid M
inst✝ : CommSemiring R
S : Set M
hS : closure S = ⊤
f : R[M]
⊢ ∃ a, ((FreeAlgebra.lift R) fun s => of' R M ↑s) a = f
tactic: intro f
state_before: R : Type u_1
M : Type u_2
inst✝¹ : AddMonoid M
inst✝ : CommSemiring R
S : Set M
hS : closure S = ⊤
f : R[M]
⊢ ∃ a, ((FreeAlgebra.lift R) fun s => of' R M ↑s) a = f
state_after: case hM
R : Type u_1
M : Type u_2
inst✝¹ : AddMonoid M
inst✝ : CommSemiring R
S : Set M
hS : closure S = ⊤
m : M
⊢ ∃ a, ((FreeAlgebra.lift R) fun s => of' R M ↑s) a = (of R M) (Multiplicative.ofAdd m)

case hadd
R : Type u_1
M : Type u_2
inst✝¹ : AddMonoid M
inst✝ : CommSemiring R
S : Set M
hS : closure S = ⊤
f g : R[M]
ihf : ∃ a, ((FreeAlgebra.lift R) fun s => of' R M ↑s) a = f
ihg : ∃ a, ((FreeAlgebra.lift R) fun s => of' R M ↑s) a = g
⊢ ∃ a, ((FreeAlgebra.lift R) fun s => of' R M ↑s) a = f + g

case hsmul
R : Type u_1
M : Type u_2
inst✝¹ : AddMonoid M
inst✝ : CommSemiring R
S : Set M
hS : closure S = ⊤
r : R
f : R[M]
ih : ∃ a, ((FreeAlgebra.lift R) fun s => of' R M ↑s) a = f
⊢ ∃ a, ((FreeAlgebra.lift R) fun s => of' R M ↑s) a = r • f
tactic: induction' f using induction_on with m f g ihf ihg r f ih
Theorem: Finset.sup_eq_bot_iff
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝¹ : SemilatticeSup α
inst✝ : OrderBot α
s s₁ s₂ : Finset β
f✝ g : β → α
a : α
f : β → α
S : Finset β
⊢ S.sup f = ⊥ ↔ ∀ s ∈ S, f s = ⊥
state_after: no goals
tactic: classical induction' S using Finset.induction with a S _ hi <;> simp [*]
Theorem: WithZeroTopology.isOpen_iff
File: Mathlib/Topology/Algebra/WithZeroTopology.lean

Proof steps:
state_before: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
s : Set Γ₀
⊢ IsOpen s ↔ 0 ∉ s ∨ ∃ γ, γ ≠ 0 ∧ Iio γ ⊆ s
state_after: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
s : Set Γ₀
⊢ ((0 ∈ s → s ∈ 𝓝 0) ∧ ∀ (b : Γ₀), b ≠ 0 → b ∈ s → s ∈ 𝓝 b) ↔ 0 ∉ s ∨ ∃ γ, γ ≠ 0 ∧ Iio γ ⊆ s
tactic: rw [isOpen_iff_mem_nhds, ← and_forall_ne (0 : Γ₀)]
state_before: α : Type u_1
Γ₀ : Type u_2
inst✝ : LinearOrderedCommGroupWithZero Γ₀
γ γ₁ γ₂ : Γ₀
l : Filter α
f : α → Γ₀
s : Set Γ₀
⊢ ((0 ∈ s → s ∈ 𝓝 0) ∧ ∀ (b : Γ₀), b ≠ 0 → b ∈ s → s ∈ 𝓝 b) ↔ 0 ∉ s ∨ ∃ γ, γ ≠ 0 ∧ Iio γ ⊆ s
state_after: no goals
tactic: simp (config := { contextual := true }) [nhds_of_ne_zero, imp_iff_not_or,
    hasBasis_nhds_zero.mem_iff]
Theorem: Polynomial.eval_intCast
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n✝ : ℕ
inst✝ : Ring R
p q r : R[X]
n : ℤ
x : R
⊢ eval x ↑n = ↑n
state_after: no goals
tactic: simp only [← C_eq_intCast, eval_C]
Theorem: CategoryTheory.Square.toArrowArrowFunctor_obj_hom_left
File: Mathlib/CategoryTheory/Square.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : Square C
φ : X✝ ⟶ Y✝
⊢ Arrow.homMk ⋯ ≫ ((fun sq => Arrow.mk (Arrow.homMk ⋯)) Y✝).hom =
    ((fun sq => Arrow.mk (Arrow.homMk ⋯)) X✝).hom ≫ Arrow.homMk ⋯
state_after: no goals
tactic: aesop_cat
Theorem: Rat.num_dvd
File: Mathlib/Data/Rat/Lemmas.lean

Proof steps:
state_before: a b : ℤ
b0 : b ≠ 0
⊢ (a /. b).num ∣ a
state_after: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
e : a /. b = { num := n, den := d, den_nz := h, reduced := c }
⊢ { num := n, den := d, den_nz := h, reduced := c }.num ∣ a
tactic: cases' e : a /. b with n d h c
state_before: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
e : a /. b = { num := n, den := d, den_nz := h, reduced := c }
⊢ { num := n, den := d, den_nz := h, reduced := c }.num ∣ a
state_after: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
e : a * ↑d = n * b
⊢ { num := n, den := d, den_nz := h, reduced := c }.num ∣ a
tactic: rw [Rat.mk'_eq_divInt, divInt_eq_iff b0 (mod_cast h)] at e
state_before: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
e : a * ↑d = n * b
⊢ { num := n, den := d, den_nz := h, reduced := c }.num ∣ a
state_after: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
e : a * ↑d = n * b
⊢ n.natAbs ∣ a.natAbs * d
tactic: refine Int.natAbs_dvd.1 <| Int.dvd_natAbs.1 <| Int.natCast_dvd_natCast.2 <|
    c.dvd_of_dvd_mul_right ?_
state_before: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
e : a * ↑d = n * b
⊢ n.natAbs ∣ a.natAbs * d
state_after: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
e : a * ↑d = n * b
this : (a * ↑d).natAbs = (n * b).natAbs
⊢ n.natAbs ∣ a.natAbs * d
tactic: have := congr_arg Int.natAbs e
state_before: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
e : a * ↑d = n * b
this : (a * ↑d).natAbs = (n * b).natAbs
⊢ n.natAbs ∣ a.natAbs * d
state_after: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
e : a * ↑d = n * b
this : a.natAbs * d = n.natAbs * b.natAbs
⊢ n.natAbs ∣ a.natAbs * d
tactic: simp only [Int.natAbs_mul, Int.natAbs_ofNat] at this
state_before: case mk'
a b : ℤ
b0 : b ≠ 0
n : ℤ
d : ℕ
h : d ≠ 0
c : n.natAbs.Coprime d
e : a * ↑d = n * b
this : a.natAbs * d = n.natAbs * b.natAbs
⊢ n.natAbs ∣ a.natAbs * d
state_after: no goals
tactic: simp [this]
Theorem: List.rdrop_concat_succ
File: Mathlib/Data/List/DropRight.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ (l ++ [x]).rdrop (n + 1) = l.rdrop n
state_after: no goals
tactic: simp [rdrop_eq_reverse_drop_reverse]
Theorem: Finset.mem_convexHull
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
s : Finset E
x : E
⊢ x ∈ (convexHull R) ↑s ↔ ∃ w, (∀ y ∈ s, 0 ≤ w y) ∧ ∑ y ∈ s, w y = 1 ∧ s.centerMass w id = x
state_after: no goals
tactic: rw [Finset.convexHull_eq, Set.mem_setOf_eq]
Theorem: Commute.add_pow_dvd_pow_of_pow_eq_zero_right
File: Mathlib/Algebra/Ring/Divisibility/Lemmas.lean

Proof steps:
state_before: R : Type u_1
x y : R
n m p : ℕ
inst✝ : Ring R
hp : n + m ≤ p + 1
h_comm : Commute x y
hx : x ^ n = 0
⊢ (x + y - y) ^ n = 0
state_after: no goals
tactic: simpa
Theorem: Nat.Partition.ofSym_map
File: Mathlib/Combinatorics/Enumerative/Partition.lean

Proof steps:
state_before: n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
e : σ ≃ τ
s : Sym σ n
⊢ ofSym (Sym.map (⇑e) s) = ofSym s
state_after: n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
e : σ ≃ τ
s : Sym σ n
⊢ map (fun x => count x (map ⇑e ↑s)) (map ⇑e ↑s).dedup = map (fun x => count x ↑s) (↑s).dedup
tactic: simp only [ofSym, Sym.val_eq_coe, Sym.coe_map, toFinset_val, mk.injEq]
state_before: n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
e : σ ≃ τ
s : Sym σ n
⊢ map (fun x => count x (map ⇑e ↑s)) (map ⇑e ↑s).dedup = map (fun x => count x ↑s) (↑s).dedup
state_after: n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
e : σ ≃ τ
s : Sym σ n
⊢ map (fun x => count x (map ⇑e ↑s)) (map (⇑e) (↑s).dedup) = map (fun x => count x ↑s) (↑s).dedup
tactic: rw [Multiset.dedup_map_of_injective e.injective]
state_before: n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
e : σ ≃ τ
s : Sym σ n
⊢ map (fun x => count x (map ⇑e ↑s)) (map (⇑e) (↑s).dedup) = map (fun x => count x ↑s) (↑s).dedup
state_after: n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
e : σ ≃ τ
s : Sym σ n
⊢ map (fun x => count (e x) (map ⇑e ↑s)) (↑s).dedup = map (fun x => count x ↑s) (↑s).dedup
tactic: simp only [map_map, Function.comp_apply]
state_before: n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
e : σ ≃ τ
s : Sym σ n
⊢ map (fun x => count (e x) (map ⇑e ↑s)) (↑s).dedup = map (fun x => count x ↑s) (↑s).dedup
state_after: case e_f
n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
e : σ ≃ τ
s : Sym σ n
⊢ (fun x => count (e x) (map ⇑e ↑s)) = fun x => count x ↑s
tactic: congr
state_before: case e_f
n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
e : σ ≃ τ
s : Sym σ n
⊢ (fun x => count (e x) (map ⇑e ↑s)) = fun x => count x ↑s
state_after: case e_f.h
n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
e : σ ≃ τ
s : Sym σ n
i : σ
⊢ count (e i) (map ⇑e ↑s) = count i ↑s
tactic: funext i
state_before: case e_f.h
n : ℕ
σ : Type u_1
τ : Type u_2
inst✝¹ : DecidableEq σ
inst✝ : DecidableEq τ
e : σ ≃ τ
s : Sym σ n
i : σ
⊢ count (e i) (map ⇑e ↑s) = count i ↑s
state_after: no goals
tactic: rw [← Multiset.count_map_eq_count' e _ e.injective]
Theorem: FreeAbelianGroup.support_of
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

Proof steps:
state_before: X : Type u_1
x : X
⊢ (of x).support = {x}
state_after: no goals
tactic: rw [support, toFinsupp_of, Finsupp.support_single_ne_zero _ one_ne_zero]
Theorem: MeasureTheory.IsStoppingTime.add_const_nat
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
f : Filtration ℕ m
τ : Ω → ℕ
hτ : IsStoppingTime f τ
i : ℕ
⊢ IsStoppingTime f fun ω => τ ω + i
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
f : Filtration ℕ m
τ : Ω → ℕ
hτ : IsStoppingTime f τ
i j : ℕ
⊢ MeasurableSet {ω | τ ω + i = j}
tactic: refine isStoppingTime_of_measurableSet_eq fun j => ?_
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
f : Filtration ℕ m
τ : Ω → ℕ
hτ : IsStoppingTime f τ
i j : ℕ
⊢ MeasurableSet {ω | τ ω + i = j}
state_after: case pos
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
f : Filtration ℕ m
τ : Ω → ℕ
hτ : IsStoppingTime f τ
i j : ℕ
hij : i ≤ j
⊢ MeasurableSet {ω | τ ω + i = j}

case neg
Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
f : Filtration ℕ m
τ : Ω → ℕ
hτ : IsStoppingTime f τ
i j : ℕ
hij : ¬i ≤ j
⊢ MeasurableSet {ω | τ ω + i = j}
tactic: by_cases hij : i ≤ j
Theorem: Int.isSquare_natCast_iff
File: Mathlib/Algebra/Ring/Int.lean

Proof steps:
state_before: m n✝ : ℤ
n : ℕ
⊢ IsSquare ↑n ↔ IsSquare n
state_after: case mp.intro
m n✝ : ℤ
n : ℕ
x : ℤ
h : ↑n = x * x
⊢ IsSquare n

case mpr.intro
m n✝ : ℤ
n x : ℕ
h : n = x * x
⊢ IsSquare ↑n
tactic: constructor <;> rintro ⟨x, h⟩
Theorem: preNormEDS_ofNat
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
n : ℕ
⊢ preNormEDS b c d ↑n = preNormEDS' b c d n
state_after: case pos
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
n : ℕ
hn : n = 0
⊢ preNormEDS b c d ↑n = preNormEDS' b c d n

case neg
R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
n : ℕ
hn : ¬n = 0
⊢ preNormEDS b c d ↑n = preNormEDS' b c d n
tactic: by_cases hn : n = 0
Theorem: CategoryTheory.Pretriangulated.productTriangle.π_hom₃
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

Proof steps:
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ (productTriangle T).mor₃ ≫ (shiftFunctor C 1).map (Pi.π (fun j => (T j).obj₁) j) =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ ((Pi.map fun j => (T j).mor₃) ≫ inv (piComparison (shiftFunctor C 1) fun j => (T j).obj₁)) ≫
      (shiftFunctor C 1).map (Pi.π (fun j => (T j).obj₁) j) =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
tactic: dsimp
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ ((Pi.map fun j => (T j).mor₃) ≫ inv (piComparison (shiftFunctor C 1) fun j => (T j).obj₁)) ≫
      (shiftFunctor C 1).map (Pi.π (fun j => (T j).obj₁) j) =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ (Pi.map fun j => (T j).mor₃) ≫ Pi.π (fun b => (shiftFunctor C 1).obj (T b).obj₁) j =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
tactic: rw [← piComparison_comp_π, assoc, IsIso.inv_hom_id_assoc]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ (Pi.map fun j => (T j).mor₃) ≫ Pi.π (fun b => (shiftFunctor C 1).obj (T b).obj₁) j =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
state_after: no goals
tactic: simp only [limMap_π, Discrete.natTrans_app]
Theorem: InnerProductGeometry.angle_eq_pi_iff
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Basic.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ angle x y = π ↔ x ≠ 0 ∧ ∃ r < 0, y = r • x
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ -1 ≤ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖)
tactic: rw [angle, ← real_inner_div_norm_mul_norm_eq_neg_one_iff, Real.arccos_eq_pi, LE.le.le_iff_eq]
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
x✝ y✝ x y : V
⊢ -1 ≤ ⟪x, y⟫_ℝ / (‖x‖ * ‖y‖)
state_after: no goals
tactic: exact (abs_le.mp (abs_real_inner_div_norm_mul_norm_le_one x y)).1
Theorem: IsArtinian.exists_pow_succ_smul_dvd
File: Mathlib/RingTheory/Artinian.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsArtinian R M
r : R
x : M
⊢ ∃ n y, r ^ n.succ • y = r ^ n • x
state_after: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsArtinian R M
r : R
x : M
n : ℕ
hn : ∀ (m : ℕ), n ≤ m → LinearMap.range (r ^ n • LinearMap.id) = LinearMap.range (r ^ m • LinearMap.id)
⊢ ∃ n y, r ^ n.succ • y = r ^ n • x
tactic: obtain ⟨n, hn⟩ := IsArtinian.range_smul_pow_stabilizes M r
state_before: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsArtinian R M
r : R
x : M
n : ℕ
hn : ∀ (m : ℕ), n ≤ m → LinearMap.range (r ^ n • LinearMap.id) = LinearMap.range (r ^ m • LinearMap.id)
⊢ ∃ n y, r ^ n.succ • y = r ^ n • x
state_after: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsArtinian R M
r : R
x : M
n : ℕ
hn :
  ∀ (m : ℕ), n ≤ m → ∀ (x : M), x ∈ LinearMap.range (r ^ n • LinearMap.id) ↔ x ∈ LinearMap.range (r ^ m • LinearMap.id)
⊢ ∃ n y, r ^ n.succ • y = r ^ n • x
tactic: simp_rw [SetLike.ext_iff] at hn
state_before: case intro
R : Type u_1
M : Type u_2
inst✝³ : CommRing R
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsArtinian R M
r : R
x : M
n : ℕ
hn :
  ∀ (m : ℕ), n ≤ m → ∀ (x : M), x ∈ LinearMap.range (r ^ n • LinearMap.id) ↔ x ∈ LinearMap.range (r ^ m • LinearMap.id)
⊢ ∃ n y, r ^ n.succ • y = r ^ n • x
state_after: no goals
tactic: exact ⟨n, by simpa using hn n.succ n.le_succ (r ^ n • x)⟩
Theorem: norm_zsmul
File: Mathlib/Analysis/Normed/Module/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
E : Type u_3
F : Type u_4
α : Type u_5
inst✝⁵ : NormedField 𝕜
inst✝⁴ : SeminormedAddCommGroup E
inst✝³ : SeminormedAddCommGroup F
inst✝² : NormedSpace 𝕜 E
inst✝¹ : NormedSpace 𝕜 F
inst✝ : NormedSpace 𝕜 E
n : ℤ
x : E
⊢ ‖n • x‖ = ‖↑n‖ * ‖x‖
state_after: no goals
tactic: rw [← norm_smul, ← Int.smul_one_eq_cast, smul_assoc, one_smul]
Theorem: Real.volume_pi_Ioc_toReal
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Fintype ι
a b : ι → ℝ
h : a ≤ b
⊢ (volume (univ.pi fun i => Ioc (a i) (b i))).toReal = ∏ i : ι, (b i - a i)
state_after: no goals
tactic: simp only [volume_pi_Ioc, ENNReal.toReal_prod, ENNReal.toReal_ofReal (sub_nonneg.2 (h _))]
Theorem: PrimeSpectrum.iInf_localization_eq_bot
File: Mathlib/RingTheory/MaximalSpectrum.lean

Proof steps:
state_before: R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type v
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
⊢ ⨅ v, Localization.subalgebra.ofField K v.asIdeal.primeCompl ⋯ = ⊥
state_after: case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type v
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
x : K
⊢ x ∈ ⨅ v, Localization.subalgebra.ofField K v.asIdeal.primeCompl ⋯ ↔ x ∈ ⊥
tactic: ext x
state_before: case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type v
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
x : K
⊢ x ∈ ⨅ v, Localization.subalgebra.ofField K v.asIdeal.primeCompl ⋯ ↔ x ∈ ⊥
state_after: case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type v
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
x : K
⊢ (∀ (i : PrimeSpectrum R), x ∈ Localization.subalgebra.ofField K i.asIdeal.primeCompl ⋯) ↔ x ∈ ⊥
tactic: rw [Algebra.mem_iInf]
state_before: case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type v
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
x : K
⊢ (∀ (i : PrimeSpectrum R), x ∈ Localization.subalgebra.ofField K i.asIdeal.primeCompl ⋯) ↔ x ∈ ⊥
state_after: case h.mp
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type v
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
x : K
⊢ (∀ (i : PrimeSpectrum R), x ∈ Localization.subalgebra.ofField K i.asIdeal.primeCompl ⋯) → x ∈ ⊥

case h.mpr
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsDomain R
K : Type v
inst✝² : Field K
inst✝¹ : Algebra R K
inst✝ : IsFractionRing R K
x : K
⊢ x ∈ ⊥ → ∀ (i : PrimeSpectrum R), x ∈ Localization.subalgebra.ofField K i.asIdeal.primeCompl ⋯
tactic: constructor
Theorem: divp_eq_one_iff_eq
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a✝ b c a : α
u : αˣ
⊢ a /ₚ u * ↑u = 1 * ↑u ↔ a = ↑u
state_after: no goals
tactic: rw [divp_mul_cancel, one_mul]
Theorem: PNat.factorMultiset_le_iff'
File: Mathlib/Data/PNat/Factors.lean

Proof steps:
state_before: m : ℕ+
v : PrimeMultiset
⊢ m.factorMultiset ≤ v ↔ m ∣ v.prod
state_after: m : ℕ+
v : PrimeMultiset
h : m.factorMultiset ≤ v.prod.factorMultiset ↔ m ∣ v.prod := factorMultiset_le_iff
⊢ m.factorMultiset ≤ v ↔ m ∣ v.prod
tactic: let h := @factorMultiset_le_iff m v.prod
state_before: m : ℕ+
v : PrimeMultiset
h : m.factorMultiset ≤ v.prod.factorMultiset ↔ m ∣ v.prod := factorMultiset_le_iff
⊢ m.factorMultiset ≤ v ↔ m ∣ v.prod
state_after: m : ℕ+
v : PrimeMultiset
h : m.factorMultiset ≤ v ↔ m ∣ v.prod
⊢ m.factorMultiset ≤ v ↔ m ∣ v.prod
tactic: rw [v.factorMultiset_prod] at h
state_before: m : ℕ+
v : PrimeMultiset
h : m.factorMultiset ≤ v ↔ m ∣ v.prod
⊢ m.factorMultiset ≤ v ↔ m ∣ v.prod
state_after: no goals
tactic: exact h
Theorem: MulAction.period_dvd_exponent
File: Mathlib/GroupTheory/GroupAction/Period.lean

Proof steps:
state_before: α : Type v
G : Type u
inst✝³ : Group G
inst✝² : MulAction G α
M : Type u
inst✝¹ : Monoid M
inst✝ : MulAction M α
m : M
a : α
⊢ period m a ∣ Monoid.exponent M
state_after: no goals
tactic: rw [← pow_smul_eq_iff_period_dvd, Monoid.pow_exponent_eq_one, one_smul]
Theorem: NNReal.isGreatest_Lp
File: Mathlib/Analysis/MeanInequalities.lean

Proof steps:
state_before: ι : Type u
s : Finset ι
f : ι → ℝ≥0
p q : ℝ
hpq : p.IsConjExponent q
⊢ IsGreatest ((fun g => ∑ i ∈ s, f i * g i) '' {g | ∑ i ∈ s, g i ^ q ≤ 1}) ((∑ i ∈ s, f i ^ p) ^ (1 / p))
state_after: case left
ι : Type u
s : Finset ι
f : ι → ℝ≥0
p q : ℝ
hpq : p.IsConjExponent q
⊢ (∑ i ∈ s, f i ^ p) ^ (1 / p) ∈ (fun g => ∑ i ∈ s, f i * g i) '' {g | ∑ i ∈ s, g i ^ q ≤ 1}

case right
ι : Type u
s : Finset ι
f : ι → ℝ≥0
p q : ℝ
hpq : p.IsConjExponent q
⊢ (∑ i ∈ s, f i ^ p) ^ (1 / p) ∈ upperBounds ((fun g => ∑ i ∈ s, f i * g i) '' {g | ∑ i ∈ s, g i ^ q ≤ 1})
tactic: constructor
Theorem: FreeAddGroup.Red.not_step_nil
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
⊢ ¬Step [] L
state_after: α : Type u
L L₁ L₂ L₃ L₄ L' : List (α × Bool)
h' : [] = L'
⊢ ¬Step L' L
tactic: generalize h' : [] = L'
state_before: α : Type u
L L₁ L₂ L₃ L₄ L' : List (α × Bool)
h' : [] = L'
⊢ ¬Step L' L
state_after: α : Type u
L L₁ L₂ L₃ L₄ L' : List (α × Bool)
h' : [] = L'
h : Step L' L
⊢ False
tactic: intro h
state_before: α : Type u
L L₁ L₂ L₃ L₄ L' : List (α × Bool)
h' : [] = L'
h : Step L' L
⊢ False
state_after: case not
α : Type u
L₁✝ L₂✝ L₃ L₄ L₁ L₂ : List (α × Bool)
x✝ : α
b✝ : Bool
h' : [] = L₁ ++ (x✝, b✝) :: (x✝, !b✝) :: L₂
⊢ False
tactic: cases' h with L₁ L₂
state_before: case not
α : Type u
L₁✝ L₂✝ L₃ L₄ L₁ L₂ : List (α × Bool)
x✝ : α
b✝ : Bool
h' : [] = L₁ ++ (x✝, b✝) :: (x✝, !b✝) :: L₂
⊢ False
state_after: no goals
tactic: simp [List.nil_eq_append] at h'
Theorem: MellinConvergent.const_smul
File: Mathlib/Analysis/MellinTransform.lean

Proof steps:
state_before: E : Type u_1
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℂ E
f : ℝ → E
s : ℂ
hf : MellinConvergent f s
𝕜 : Type u_2
inst✝² : NontriviallyNormedField 𝕜
inst✝¹ : NormedSpace 𝕜 E
inst✝ : SMulCommClass ℂ 𝕜 E
c : 𝕜
⊢ MellinConvergent (fun t => c • f t) s
state_after: no goals
tactic: simpa only [MellinConvergent, smul_comm] using hf.smul c
Theorem: chartedSpaceSelf_prod
File: Mathlib/Geometry/Manifold/ChartedSpace.lean

Proof steps:
state_before: H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
inst✝³ : ChartedSpace H M
inst✝² : TopologicalSpace H'
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
x : M × M'
⊢ prodChartedSpace H H H' H' = chartedSpaceSelf (H × H')
state_after: case atlas
H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
inst✝³ : ChartedSpace H M
inst✝² : TopologicalSpace H'
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
x : M × M'
⊢ ChartedSpace.atlas = ChartedSpace.atlas

case chartAt
H : Type u
H' : Type u_1
M : Type u_2
M' : Type u_3
M'' : Type u_4
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
inst✝³ : ChartedSpace H M
inst✝² : TopologicalSpace H'
inst✝¹ : TopologicalSpace M'
inst✝ : ChartedSpace H' M'
x : M × M'
⊢ ChartedSpace.chartAt = ChartedSpace.chartAt
tactic: ext1