ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: ENNReal.mul_inv
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a b : ℝ≥0∞
ha : a ≠ 0 ∨ b ≠ ⊤
hb : a ≠ ⊤ ∨ b ≠ 0
⊢ (a * b)⁻¹ = a⁻¹ * b⁻¹
state_after: case top
a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
ha : a ≠ 0 ∨ ⊤ ≠ ⊤
hb : a ≠ ⊤ ∨ ⊤ ≠ 0
⊢ (a * ⊤)⁻¹ = a⁻¹ * ⊤⁻¹

case coe
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
b : ℝ≥0
ha : a ≠ 0 ∨ ↑b ≠ ⊤
hb : a ≠ ⊤ ∨ ↑b ≠ 0
⊢ (a * ↑b)⁻¹ = a⁻¹ * (↑b)⁻¹
tactic: induction' b with b
state_before: case coe
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
b : ℝ≥0
ha : a ≠ 0 ∨ ↑b ≠ ⊤
hb : a ≠ ⊤ ∨ ↑b ≠ 0
⊢ (a * ↑b)⁻¹ = a⁻¹ * (↑b)⁻¹
state_after: case coe.top
a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
ha : ⊤ ≠ 0 ∨ ↑b ≠ ⊤
hb : ⊤ ≠ ⊤ ∨ ↑b ≠ 0
⊢ (⊤ * ↑b)⁻¹ = ⊤⁻¹ * (↑b)⁻¹

case coe.coe
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
ha : ↑a ≠ 0 ∨ ↑b ≠ ⊤
hb : ↑a ≠ ⊤ ∨ ↑b ≠ 0
⊢ (↑a * ↑b)⁻¹ = (↑a)⁻¹ * (↑b)⁻¹
tactic: induction' a with a
state_before: case coe.coe
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
ha : ↑a ≠ 0 ∨ ↑b ≠ ⊤
hb : ↑a ≠ ⊤ ∨ ↑b ≠ 0
⊢ (↑a * ↑b)⁻¹ = (↑a)⁻¹ * (↑b)⁻¹
state_after: case pos
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
ha : ↑a ≠ 0 ∨ ↑b ≠ ⊤
hb : ↑a ≠ ⊤ ∨ ↑b ≠ 0
h'a : a = 0
⊢ (↑a * ↑b)⁻¹ = (↑a)⁻¹ * (↑b)⁻¹

case neg
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
ha : ↑a ≠ 0 ∨ ↑b ≠ ⊤
hb : ↑a ≠ ⊤ ∨ ↑b ≠ 0
h'a : ¬a = 0
⊢ (↑a * ↑b)⁻¹ = (↑a)⁻¹ * (↑b)⁻¹
tactic: by_cases h'a : a = 0
state_before: case neg
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
ha : ↑a ≠ 0 ∨ ↑b ≠ ⊤
hb : ↑a ≠ ⊤ ∨ ↑b ≠ 0
h'a : ¬a = 0
⊢ (↑a * ↑b)⁻¹ = (↑a)⁻¹ * (↑b)⁻¹
state_after: case pos
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
ha : ↑a ≠ 0 ∨ ↑b ≠ ⊤
hb : ↑a ≠ ⊤ ∨ ↑b ≠ 0
h'a : ¬a = 0
h'b : b = 0
⊢ (↑a * ↑b)⁻¹ = (↑a)⁻¹ * (↑b)⁻¹

case neg
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
ha : ↑a ≠ 0 ∨ ↑b ≠ ⊤
hb : ↑a ≠ ⊤ ∨ ↑b ≠ 0
h'a : ¬a = 0
h'b : ¬b = 0
⊢ (↑a * ↑b)⁻¹ = (↑a)⁻¹ * (↑b)⁻¹
tactic: by_cases h'b : b = 0
state_before: case neg
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
ha : ↑a ≠ 0 ∨ ↑b ≠ ⊤
hb : ↑a ≠ ⊤ ∨ ↑b ≠ 0
h'a : ¬a = 0
h'b : ¬b = 0
⊢ (↑a * ↑b)⁻¹ = (↑a)⁻¹ * (↑b)⁻¹
state_after: case neg
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
ha : ↑a ≠ 0 ∨ ↑b ≠ ⊤
hb : ↑a ≠ ⊤ ∨ ↑b ≠ 0
h'a : ¬a = 0
h'b : ¬b = 0
⊢ a * b ≠ 0
tactic: rw [← ENNReal.coe_mul, ← ENNReal.coe_inv, ← ENNReal.coe_inv h'a, ← ENNReal.coe_inv h'b, ←
    ENNReal.coe_mul, mul_inv_rev, mul_comm]
state_before: case neg
a✝ b✝ c d : ℝ≥0∞
r p q b a : ℝ≥0
ha : ↑a ≠ 0 ∨ ↑b ≠ ⊤
hb : ↑a ≠ ⊤ ∨ ↑b ≠ 0
h'a : ¬a = 0
h'b : ¬b = 0
⊢ a * b ≠ 0
state_after: no goals
tactic: simp [h'a, h'b]
Theorem: UniqueProds.of_mulHom
File: Mathlib/Algebra/Group/UniqueProds.lean

Proof steps:
state_before: G : Type u
H : Type v
inst✝² : Mul G
inst✝¹ : Mul H
f : H →ₙ* G
hf : ∀ ⦃a b c d : H⦄, a * b = c * d → f a = f c ∧ f b = f d → a = c ∧ b = d
inst✝ : UniqueProds G
A B : Finset H
A0 : A.Nonempty
B0 : B.Nonempty
⊢ ∃ a0 ∈ A, ∃ b0 ∈ B, UniqueMul A B a0 b0
state_after: no goals
tactic: classical
    obtain ⟨a0, ha0, b0, hb0, h⟩ := uniqueMul_of_nonempty (A0.image f) (B0.image f)
    obtain ⟨a', ha', rfl⟩ := mem_image.mp ha0
    obtain ⟨b', hb', rfl⟩ := mem_image.mp hb0
    exact ⟨a', ha', b', hb', UniqueMul.of_mulHom_image f hf h⟩
Theorem: Int.fract_eq_fract
File: Mathlib/Algebra/Order/Floor.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
h : fract a = fract b
⊢ a - b = ↑(⌊a⌋ - ⌊b⌋)
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
h : a - ↑⌊a⌋ = b - ↑⌊b⌋
⊢ a - b = ↑(⌊a⌋ - ⌊b⌋)
tactic: unfold fract at h
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
h : a - ↑⌊a⌋ = b - ↑⌊b⌋
⊢ a - b = ↑(⌊a⌋ - ⌊b⌋)
state_after: no goals
tactic: rw [Int.cast_sub, sub_eq_sub_iff_sub_eq_sub.1 h]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a b : α
⊢ (∃ z, a - b = ↑z) → fract a = fract b
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
z : ℤ
hz : a - b = ↑z
⊢ fract a = fract b
tactic: rintro ⟨z, hz⟩
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
z : ℤ
hz : a - b = ↑z
⊢ fract a = fract b
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
z : ℤ
hz : a - b = ↑z
⊢ a - fract b = ↑(z + ⌊b⌋)
tactic: refine fract_eq_iff.2 ⟨fract_nonneg _, fract_lt_one _, z + ⌊b⌋, ?_⟩
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
z : ℤ
hz : a - b = ↑z
⊢ a - fract b = ↑(z + ⌊b⌋)
state_after: case intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
z : ℤ
hz : a - b = ↑z
⊢ b + ↑z - fract b = ↑z + ↑⌊b⌋
tactic: rw [eq_add_of_sub_eq hz, add_comm, Int.cast_add]
state_before: case intro
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z✝ : ℤ
a✝ a b : α
z : ℤ
hz : a - b = ↑z
⊢ b + ↑z - fract b = ↑z + ↑⌊b⌋
state_after: no goals
tactic: exact add_sub_sub_cancel _ _ _
Theorem: CategoryTheory.Limits.Types.colimit_eq
File: Mathlib/CategoryTheory/Limits/Types.lean

Proof steps:
state_before: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j j' : J
x : F.obj j
x' : F.obj j'
w : colimit.ι F j x = colimit.ι F j' x'
⊢ EqvGen (Quot.Rel F) ⟨j, x⟩ ⟨j', x'⟩
state_after: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j j' : J
x : F.obj j
x' : F.obj j'
w : colimit.ι F j x = colimit.ι F j' x'
⊢ Quot.mk (Quot.Rel F) ⟨j, x⟩ = Quot.mk (Quot.Rel F) ⟨j', x'⟩
tactic: apply Quot.eq.1
state_before: J : Type v
inst✝¹ : Category.{w, v} J
F : J ⥤ Type u
inst✝ : HasColimit F
j j' : J
x : F.obj j
x' : F.obj j'
w : colimit.ι F j x = colimit.ι F j' x'
⊢ Quot.mk (Quot.Rel F) ⟨j, x⟩ = Quot.mk (Quot.Rel F) ⟨j', x'⟩
state_after: no goals
tactic: simpa using congr_arg (colimitEquivQuot F) w
Theorem: CategoryTheory.Groupoid.vertexGroupIsomOfMap_apply
File: Mathlib/CategoryTheory/Groupoid/VertexGroup.lean

Proof steps:
state_before: C : Type u
inst✝ : Groupoid C
c d : C
f : c ⟶ d
γ : c ⟶ c
⊢ (fun δ => f ≫ δ ≫ inv f) ((fun γ => inv f ≫ γ ≫ f) γ) = γ
state_after: no goals
tactic: simp_rw [Category.assoc, comp_inv, Category.comp_id, ← Category.assoc, comp_inv,
      Category.id_comp]
state_before: C : Type u
inst✝ : Groupoid C
c d : C
f : c ⟶ d
δ : d ⟶ d
⊢ (fun γ => inv f ≫ γ ≫ f) ((fun δ => f ≫ δ ≫ inv f) δ) = δ
state_after: no goals
tactic: simp_rw [Category.assoc, inv_comp, ← Category.assoc, inv_comp, Category.id_comp,
      Category.comp_id]
state_before: C : Type u
inst✝ : Groupoid C
c d : C
f : c ⟶ d
γ₁ γ₂ : c ⟶ c
⊢ { toFun := fun γ => inv f ≫ γ ≫ f, invFun := fun δ => f ≫ δ ≫ inv f, left_inv := ⋯, right_inv := ⋯ }.toFun (γ₁ * γ₂) =
    { toFun := fun γ => inv f ≫ γ ≫ f, invFun := fun δ => f ≫ δ ≫ inv f, left_inv := ⋯, right_inv := ⋯ }.toFun γ₁ *
      { toFun := fun γ => inv f ≫ γ ≫ f, invFun := fun δ => f ≫ δ ≫ inv f, left_inv := ⋯, right_inv := ⋯ }.toFun γ₂
state_after: no goals
tactic: simp only [vertexGroup_mul, inv_eq_inv, Category.assoc, IsIso.hom_inv_id_assoc]
Theorem: Rat.mul_self_num
File: Mathlib/Data/Rat/Lemmas.lean

Proof steps:
state_before: q : ℚ
⊢ (q * q).num = q.num * q.num
state_after: q : ℚ
⊢ (q.num.natAbs * q.num.natAbs).Coprime (q.den * q.den)
tactic: rw [mul_num, Int.natAbs_mul, Nat.Coprime.gcd_eq_one, Int.ofNat_one, Int.ediv_one]
state_before: q : ℚ
⊢ (q.num.natAbs * q.num.natAbs).Coprime (q.den * q.den)
state_after: no goals
tactic: exact (q.reduced.mul_right q.reduced).mul (q.reduced.mul_right q.reduced)
Theorem: εNFA.mem_stepSet_iff
File: Mathlib/Computability/EpsilonNFA.lean

Proof steps:
state_before: α : Type u
σ σ' : Type v
M : εNFA α σ
S : Set σ
x : List α
s : σ
a : α
⊢ s ∈ M.stepSet S a ↔ ∃ t ∈ S, s ∈ M.εClosure (M.step t (some a))
state_after: no goals
tactic: simp_rw [stepSet, mem_iUnion₂, exists_prop]
Theorem: preNormEDS'_three
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
⊢ preNormEDS' b c d 3 = c
state_after: no goals
tactic: rw [preNormEDS']
Theorem: eq_neg_add_of_add_eq
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 : ℤ
h : b * a = c
⊢ a = b⁻¹ * c
state_after: no goals
tactic: simp [h.symm]
Theorem: _private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.quotient_mul_add_remainder_eq_aux
File: Mathlib/Algebra/Polynomial/FieldDivision.lean

Proof steps:
state_before: R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
⊢ q * p.div q + p.mod q = p
state_after: case pos
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
h : q = 0
⊢ q * p.div q + p.mod q = p

case neg
R : Type u
S : Type v
k : Type y
A : Type z
a b : R
n : ℕ
inst✝ : Field R
p✝ q✝ p q : R[X]
h : ¬q = 0
⊢ q * p.div q + p.mod q = p
tactic: by_cases h : q = 0
Theorem: GenContFract.second_contAux_eq
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

Proof steps:
state_before: K : Type u_1
g : GenContFract K
n : ℕ
inst✝ : DivisionRing K
gp : Pair K
zeroth_s_eq : g.s.get? 0 = some gp
⊢ g.contsAux 2 = { a := gp.b * g.h + gp.a, b := gp.b }
state_after: no goals
tactic: simp [zeroth_s_eq, contsAux, nextConts, nextDen, nextNum]
Theorem: SlimCheck.InjectiveFunction.List.applyId_cons
File: Mathlib/Testing/SlimCheck/Functions.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Sort w
inst✝ : DecidableEq α
xs : List (α × α)
x y z : α
⊢ applyId ((y, z) :: xs) x = if y = x then z else applyId xs x
state_after: α : Type u
β : Type v
γ : Sort w
inst✝ : DecidableEq α
xs : List (α × α)
x y z : α
⊢ (if h : y = x then some z else dlookup x (map Prod.toSigma xs)).getD x =
    if y = x then z else (dlookup x (map Prod.toSigma xs)).getD x
tactic: simp only [List.applyId, List.dlookup, eq_rec_constant, Prod.toSigma, List.map]
state_before: α : Type u
β : Type v
γ : Sort w
inst✝ : DecidableEq α
xs : List (α × α)
x y z : α
⊢ (if h : y = x then some z else dlookup x (map Prod.toSigma xs)).getD x =
    if y = x then z else (dlookup x (map Prod.toSigma xs)).getD x
state_after: no goals
tactic: split_ifs <;> rfl
Theorem: Finset.eq_empty_of_sym_eq_empty
File: Mathlib/Data/Finset/Sym.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
n : ℕ
h : s.sym n = ∅
⊢ s = ∅
state_after: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
n : ℕ
h : ¬(s.sym n).Nonempty
⊢ ¬s.Nonempty
tactic: rw [← not_nonempty_iff_eq_empty] at h ⊢
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
s t : Finset α
a b : α
n : ℕ
h : ¬(s.sym n).Nonempty
⊢ ¬s.Nonempty
state_after: no goals
tactic: exact fun hs ↦ h (hs.sym _)
Theorem: ONote.fastGrowing_one
File: Mathlib/SetTheory/Ordinal/Notation.lean

Proof steps:
state_before: ⊢ fastGrowing 1 = fun n => 2 * n
state_after: ⊢ (fun i => (fastGrowing 0)^[i] i) = fun n => 2 * n
tactic: rw [@fastGrowing_succ 1 0 rfl]
state_before: ⊢ (fun i => (fastGrowing 0)^[i] i) = fun n => 2 * n
state_after: case h
i : ℕ
⊢ (fastGrowing 0)^[i] i = 2 * i
tactic: funext i
state_before: case h
i : ℕ
⊢ (fastGrowing 0)^[i] i = 2 * i
state_after: case h
i : ℕ
⊢ Nat.succ^[i] i = i + i
tactic: rw [two_mul, fastGrowing_zero]
state_before: case h
i : ℕ
⊢ Nat.succ^[i] i = i + i
state_after: case h
i : ℕ
⊢ ∀ (a b : ℕ), Nat.succ^[a] b = b + a
tactic: suffices ∀ a b, Nat.succ^[a] b = b + a from this _ _
state_before: case h
i : ℕ
⊢ ∀ (a b : ℕ), Nat.succ^[a] b = b + a
state_after: case h
i a b : ℕ
⊢ Nat.succ^[a] b = b + a
tactic: intro a b
state_before: case h
i a b : ℕ
⊢ Nat.succ^[a] b = b + a
state_after: no goals
tactic: induction a <;> simp [*, Function.iterate_succ', Nat.add_assoc, -Function.iterate_succ]
Theorem: CategoryTheory.Functor.essSurj_of_surj
File: Mathlib/CategoryTheory/EssentialImage.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₂, u₂} D
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
h : Function.Surjective F.obj
Y : D
⊢ Y ∈ F.essImage
state_after: case intro
C : Type u₁
D : Type u₂
E : Type u₃
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₂, u₂} D
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
h : Function.Surjective F.obj
X : C
⊢ F.obj X ∈ F.essImage
tactic: obtain ⟨X, rfl⟩ := h Y
state_before: case intro
C : Type u₁
D : Type u₂
E : Type u₃
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₂, u₂} D
inst✝ : Category.{v₃, u₃} E
F : C ⥤ D
h : Function.Surjective F.obj
X : C
⊢ F.obj X ∈ F.essImage
state_after: no goals
tactic: apply obj_mem_essImage
Theorem: Int.coe_leastOfBdd_eq
File: Mathlib/Data/Int/LeastGreatest.lean

Proof steps:
state_before: P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
Hb' : ∀ (z : ℤ), P z → b' ≤ z
Hinh : ∃ z, P z
⊢ ↑(b.leastOfBdd Hb Hinh) = ↑(b'.leastOfBdd Hb' Hinh)
state_after: case mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
Hb' : ∀ (z : ℤ), P z → b' ≤ z
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → n ≤ z
⊢ ↑⟨n, ⋯⟩ = ↑(b'.leastOfBdd Hb' Hinh)
tactic: rcases leastOfBdd b Hb Hinh with ⟨n, hn, h2n⟩
state_before: case mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
Hb' : ∀ (z : ℤ), P z → b' ≤ z
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → n ≤ z
⊢ ↑⟨n, ⋯⟩ = ↑(b'.leastOfBdd Hb' Hinh)
state_after: case mk.intro.mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
Hb' : ∀ (z : ℤ), P z → b' ≤ z
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → n ≤ z
n' : ℤ
hn' : P n'
h2n' : ∀ (z : ℤ), P z → n' ≤ z
⊢ ↑⟨n, ⋯⟩ = ↑⟨n', ⋯⟩
tactic: rcases leastOfBdd b' Hb' Hinh with ⟨n', hn', h2n'⟩
state_before: case mk.intro.mk.intro
P : ℤ → Prop
inst✝ : DecidablePred P
b b' : ℤ
Hb : ∀ (z : ℤ), P z → b ≤ z
Hb' : ∀ (z : ℤ), P z → b' ≤ z
Hinh : ∃ z, P z
n : ℤ
hn : P n
h2n : ∀ (z : ℤ), P z → n ≤ z
n' : ℤ
hn' : P n'
h2n' : ∀ (z : ℤ), P z → n' ≤ z
⊢ ↑⟨n, ⋯⟩ = ↑⟨n', ⋯⟩
state_after: no goals
tactic: exact le_antisymm (h2n _ hn') (h2n' _ hn)
Theorem: Ordinal.nat_nadd
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

Proof steps:
state_before: a b c : Ordinal.{u}
n : ℕ
⊢ ↑n ♯ a = a + ↑n
state_after: no goals
tactic: rw [nadd_comm, nadd_nat]
Theorem: List.getElem_range'
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: n m step i : Nat
H : i < (range' n m step).length
⊢ i < m
state_after: no goals
tactic: simpa using H
Theorem: Lists'.subset_nil
File: Mathlib/SetTheory/Lists.lean

Proof steps:
state_before: α : Type u_1
l : Lists' α true
⊢ l ⊆ nil → l = nil
state_after: α : Type u_1
l : Lists' α true
⊢ ofList l.toList ⊆ nil → ofList l.toList = nil
tactic: rw [← of_toList l]
state_before: α : Type u_1
l : Lists' α true
⊢ ofList l.toList ⊆ nil → ofList l.toList = nil
state_after: case nil
α : Type u_1
l : Lists' α true
h : ofList [] ⊆ nil
⊢ ofList [] = nil

case cons
α : Type u_1
l : Lists' α true
head✝ : Lists α
tail✝ : List (Lists α)
tail_ih✝ : ofList tail✝ ⊆ nil → ofList tail✝ = nil
h : ofList (head✝ :: tail✝) ⊆ nil
⊢ ofList (head✝ :: tail✝) = nil
tactic: induction toList l <;> intro h
Theorem: Finset.sup'_inf_distrib_right
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✝ : DistribLattice α
s : Finset ι
t : Finset κ
hs : s.Nonempty
ht : t.Nonempty
f✝ : ι → α
g : κ → α
a✝ : α
f : ι → α
a : α
⊢ s.sup' hs f ⊓ a = s.sup' hs fun i => f i ⊓ a
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DistribLattice α
s : Finset ι
t : Finset κ
hs : s.Nonempty
ht : t.Nonempty
f✝ : ι → α
g : κ → α
a✝ : α
f : ι → α
a : α
⊢ (s.sup' hs fun i => a ⊓ f i) = s.sup' hs fun i => f i ⊓ a
tactic: rw [inf_comm, sup'_inf_distrib_left]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : DistribLattice α
s : Finset ι
t : Finset κ
hs : s.Nonempty
ht : t.Nonempty
f✝ : ι → α
g : κ → α
a✝ : α
f : ι → α
a : α
⊢ (s.sup' hs fun i => a ⊓ f i) = s.sup' hs fun i => f i ⊓ a
state_after: no goals
tactic: simp_rw [inf_comm]
Theorem: MeasureTheory.integral_indicator_const
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝³ : MeasurableSpace X
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
f g : X → E
s✝ t : Set X
μ ν : Measure X
l l' : Filter X
inst✝ : CompleteSpace E
e : E
s : Set X
s_meas : MeasurableSet s
⊢ ∫ (x : X), s.indicator (fun x => e) x ∂μ = (μ s).toReal • e
state_after: no goals
tactic: rw [integral_indicator s_meas, ← setIntegral_const]
Theorem: MeasureTheory.lintegral_edist_triangle
File: Mathlib/MeasureTheory/Function/L1Space.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g h : α → β
hf : AEStronglyMeasurable f μ
hh : AEStronglyMeasurable h μ
⊢ ∫⁻ (a : α), edist (f a) (g a) ∂μ ≤ ∫⁻ (a : α), edist (f a) (h a) ∂μ + ∫⁻ (a : α), edist (g a) (h a) ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g h : α → β
hf : AEStronglyMeasurable f μ
hh : AEStronglyMeasurable h μ
⊢ ∫⁻ (a : α), edist (f a) (g a) ∂μ ≤ ∫⁻ (a : α), edist (f a) (h a) + edist (g a) (h a) ∂μ
tactic: rw [← lintegral_add_left' (hf.edist hh)]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g h : α → β
hf : AEStronglyMeasurable f μ
hh : AEStronglyMeasurable h μ
⊢ ∫⁻ (a : α), edist (f a) (g a) ∂μ ≤ ∫⁻ (a : α), edist (f a) (h a) + edist (g a) (h a) ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g h : α → β
hf : AEStronglyMeasurable f μ
hh : AEStronglyMeasurable h μ
a : α
⊢ edist (f a) (g a) ≤ edist (f a) (h a) + edist (g a) (h a)
tactic: refine lintegral_mono fun a => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f g h : α → β
hf : AEStronglyMeasurable f μ
hh : AEStronglyMeasurable h μ
a : α
⊢ edist (f a) (g a) ≤ edist (f a) (h a) + edist (g a) (h a)
state_after: no goals
tactic: apply edist_triangle_right
Theorem: tendsto_ceil_right
File: Mathlib/Topology/Algebra/Order/Floor.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
n : ℤ
⊢ pure (IntCast.intCast (n + 1)) ≤ 𝓝[≥] (↑n + 1)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
n : ℤ
⊢ pure (IntCast.intCast (n + 1)) ≤ 𝓝[≥] ↑(n + 1)
tactic: rw [← @cast_one α, ← cast_add]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝³ : LinearOrderedRing α
inst✝² : FloorRing α
inst✝¹ : TopologicalSpace α
inst✝ : OrderClosedTopology α
n : ℤ
⊢ pure (IntCast.intCast (n + 1)) ≤ 𝓝[≥] ↑(n + 1)
state_after: no goals
tactic: exact pure_le_nhdsWithin le_rfl
Theorem: PiLp.norm_eq_of_L2
File: Mathlib/Analysis/Normed/Lp/PiLp.lean

Proof steps:
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ ‖x‖ = √(∑ i : ι, ‖x i‖ ^ 2)
state_after: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ (∑ i : ι, ‖x i‖ ^ 2) ^ (1 / ↑2) = √(∑ i : ι, ‖x i‖ ^ 2)
tactic: rw [norm_eq_of_nat 2 (by norm_cast) _]
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ (∑ i : ι, ‖x i‖ ^ 2) ^ (1 / ↑2) = √(∑ i : ι, ‖x i‖ ^ 2)
state_after: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ (∑ i : ι, ‖x i‖ ^ 2) ^ (1 / ↑2) = (∑ i : ι, ‖x i‖ ^ 2) ^ (1 / 2)
tactic: rw [Real.sqrt_eq_rpow]
state_before: p : ℝ≥0∞
𝕜 : Type u_1
ι : Type u_2
α : ι → Type u_3
β✝ : ι → Type u_4
inst✝² : Fact (1 ≤ p)
inst✝¹ : Fintype ι
β : ι → Type u_5
inst✝ : (i : ι) → SeminormedAddCommGroup (β i)
x : PiLp 2 β
⊢ (∑ i : ι, ‖x i‖ ^ 2) ^ (1 / ↑2) = (∑ i : ι, ‖x i‖ ^ 2) ^ (1 / 2)
state_after: no goals
tactic: norm_cast
Theorem: LinearMap.comp_zero
File: Mathlib/Algebra/Module/LinearMap/Defs.lean

Proof steps:
state_before: R : Type u_1
R₁ : Type u_2
R₂ : Type u_3
R₃ : Type u_4
k : Type u_5
S : Type u_6
S₃ : Type u_7
T : Type u_8
M : Type u_9
M₁ : Type u_10
M₂ : Type u_11
M₃ : Type u_12
N₁ : Type u_13
N₂ : Type u_14
N₃ : Type u_15
ι : Type u_16
inst✝¹⁵ : Semiring R₁
inst✝¹⁴ : Semiring R₂
inst✝¹³ : Semiring R₃
inst✝¹² : AddCommMonoid M
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommGroup N₁
inst✝⁸ : AddCommGroup N₂
inst✝⁷ : AddCommGroup N₃
inst✝⁶ : Module R₁ M
inst✝⁵ : Module R₂ M₂
inst✝⁴ : Module R₃ M₃
inst✝³ : Module R₁ N₁
inst✝² : Module R₂ N₂
inst✝¹ : Module R₃ N₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
inst✝ : RingHomCompTriple σ₁₂ σ₂₃ σ₁₃
g : M₂ →ₛₗ[σ₂₃] M₃
c : M
⊢ (g.comp 0) c = 0 c
state_after: no goals
tactic: rw [comp_apply, zero_apply, zero_apply, g.map_zero]
Theorem: mul_lt_iff_lt_one_left'
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : MulOneClass α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
⊢ a * b < a ↔ a * b < a * 1
state_after: no goals
tactic: rw [mul_one]
Theorem: essSup_comp_le_essSup_map_measure
File: Mathlib/MeasureTheory/Function/EssSup.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
γ : Type u_3
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
hf : AEMeasurable f μ
⊢ essSup (g ∘ f) μ ≤ essSup g (Measure.map f μ)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
γ : Type u_3
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
hf : AEMeasurable f μ
⊢ map (g ∘ f) (ae μ) ≤ map g (ae (Measure.map f μ))
tactic: refine limsSup_le_limsSup_of_le ?_
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
γ : Type u_3
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
hf : AEMeasurable f μ
⊢ map (g ∘ f) (ae μ) ≤ map g (ae (Measure.map f μ))
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
γ : Type u_3
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
hf : AEMeasurable f μ
⊢ map g (map f (ae μ)) ≤ map g (ae (Measure.map f μ))
tactic: rw [← Filter.map_map]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
inst✝ : CompleteLattice β
γ : Type u_3
mγ : MeasurableSpace γ
f : α → γ
g : γ → β
hf : AEMeasurable f μ
⊢ map g (map f (ae μ)) ≤ map g (ae (Measure.map f μ))
state_after: no goals
tactic: exact Filter.map_mono (Measure.tendsto_ae_map hf)
Theorem: IsLocalization.coeSubmodule_top
File: Mathlib/RingTheory/Localization/Submodule.lean

Proof steps:
state_before: R : Type u_1
inst✝³ : CommRing R
M : Submonoid R
S : Type u_2
inst✝² : CommRing S
inst✝¹ : Algebra R S
P : Type u_3
inst✝ : CommRing P
⊢ coeSubmodule S ⊤ = 1
state_after: no goals
tactic: rw [coeSubmodule, Submodule.map_top, Submodule.one_eq_range]