ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Ordinal.mul_omega_opow_opow
File: Mathlib/SetTheory/Ordinal/Principal.lean

Proof steps:
state_before: a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
⊢ a * ω ^ ω ^ b = ω ^ ω ^ b
state_after: case pos
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : b = 0
⊢ a * ω ^ ω ^ b = ω ^ ω ^ b

case neg
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
⊢ a * ω ^ ω ^ b = ω ^ ω ^ b
tactic: by_cases b0 : b = 0
state_before: case neg
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
⊢ a * ω ^ ω ^ b = ω ^ ω ^ b
state_after: case neg
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
⊢ a * ω ^ ω ^ b ≤ ω ^ ω ^ b
tactic: refine
    le_antisymm ?_
      (by simpa only [one_mul] using mul_le_mul_right' (one_le_iff_pos.2 a0) (omega^omega^b))
state_before: case neg
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
⊢ a * ω ^ ω ^ b ≤ ω ^ ω ^ b
state_after: case neg.intro.intro
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
x : Ordinal.{u_1}
xb : x < ω ^ b
ax : a < ω ^ x
⊢ a * ω ^ ω ^ b ≤ ω ^ ω ^ b
tactic: rcases (lt_opow_of_limit omega_ne_zero (opow_isLimit_left omega_isLimit b0)).1 h with ⟨x, xb, ax⟩
state_before: case neg.intro.intro
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
x : Ordinal.{u_1}
xb : x < ω ^ b
ax : a < ω ^ x
⊢ a * ω ^ ω ^ b ≤ ω ^ ω ^ b
state_after: case neg.intro.intro
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
x : Ordinal.{u_1}
xb : x < ω ^ b
ax : a < ω ^ x
⊢ ω ^ x * ω ^ ω ^ b ≤ ω ^ ω ^ b
tactic: apply (mul_le_mul_right' (le_of_lt ax) _).trans
state_before: case neg.intro.intro
a b : Ordinal.{u_1}
a0 : 0 < a
h : a < ω ^ ω ^ b
b0 : ¬b = 0
x : Ordinal.{u_1}
xb : x < ω ^ b
ax : a < ω ^ x
⊢ ω ^ x * ω ^ ω ^ b ≤ ω ^ ω ^ b
state_after: no goals
tactic: rw [← opow_add, add_omega_opow xb]
Theorem: AddCommute.addOrderOf_add_dvd_lcm
File: Mathlib/GroupTheory/OrderOfElement.lean

Proof steps:
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : Commute x y
⊢ orderOf (x * y) ∣ (orderOf x).lcm (orderOf y)
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : Commute x y
⊢ minimalPeriod ((fun x_1 => x * x_1) ∘ fun x => y * x) 1 ∣ (orderOf x).lcm (orderOf y)
tactic: rw [orderOf, ← comp_mul_left]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝ : Monoid G
a b x y : G
n m : ℕ
h : Commute x y
⊢ minimalPeriod ((fun x_1 => x * x_1) ∘ fun x => y * x) 1 ∣ (orderOf x).lcm (orderOf y)
state_after: no goals
tactic: exact Function.Commute.minimalPeriod_of_comp_dvd_lcm h.function_commute_mul_left
Theorem: WeierstrassCurve.baseChange_ΨSq
File: Mathlib/AlgebraicGeometry/EllipticCurve/DivisionPolynomial/Basic.lean

Proof steps:
state_before: R : Type r
S : Type s
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing S
W : WeierstrassCurve R
inst✝⁸ : Algebra R S
A : Type u
inst✝⁷ : CommRing A
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra S A
inst✝⁴ : IsScalarTower R S A
B : Type v
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra S B
inst✝ : IsScalarTower R S B
f : A →ₐ[S] B
n : ℤ
⊢ (W.baseChange B).ΨSq n = Polynomial.map (↑f) ((W.baseChange A).ΨSq n)
state_after: no goals
tactic: rw [← map_ΨSq, map_baseChange]
Theorem: CategoryTheory.Equivalence.invFunIdAssoc_inv_app
File: Mathlib/CategoryTheory/Equivalence.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
F : D ⥤ E
X : D
⊢ (e.invFunIdAssoc F).inv.app X = F.map (e.counitInv.app X)
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
F : D ⥤ E
X : D
⊢ (𝟙 (F.obj X) ≫ F.map (e.counitIso.inv.app X)) ≫ 𝟙 (F.obj (e.functor.obj (e.inverse.obj X))) =
    F.map (e.counitInv.app X)
tactic: dsimp [invFunIdAssoc]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E : Type u₃
inst✝ : Category.{v₃, u₃} E
e : C ≌ D
F : D ⥤ E
X : D
⊢ (𝟙 (F.obj X) ≫ F.map (e.counitIso.inv.app X)) ≫ 𝟙 (F.obj (e.functor.obj (e.inverse.obj X))) =
    F.map (e.counitInv.app X)
state_after: no goals
tactic: aesop_cat
Theorem: ContinuousOn.preimage_isClosed_of_isClosed
File: Mathlib/Topology/ContinuousOn.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
hf : ContinuousOn f s
hs : IsClosed s
ht : IsClosed t
⊢ IsClosed (s ∩ f ⁻¹' t)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
hf : ContinuousOn f s
hs : IsClosed s
ht : IsClosed t
u : Set α
hu : IsClosed u ∧ f ⁻¹' t ∩ s = u ∩ s
⊢ IsClosed (s ∩ f ⁻¹' t)
tactic: rcases continuousOn_iff_isClosed.1 hf t ht with ⟨u, hu⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
hf : ContinuousOn f s
hs : IsClosed s
ht : IsClosed t
u : Set α
hu : IsClosed u ∧ f ⁻¹' t ∩ s = u ∩ s
⊢ IsClosed (s ∩ f ⁻¹' t)
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
hf : ContinuousOn f s
hs : IsClosed s
ht : IsClosed t
u : Set α
hu : IsClosed u ∧ f ⁻¹' t ∩ s = u ∩ s
⊢ IsClosed (u ∩ s)
tactic: rw [inter_comm, hu.2]
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝⁴ : TopologicalSpace α
ι : Type u_5
π : ι → Type u_6
inst✝³ : (i : ι) → TopologicalSpace (π i)
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
s : Set α
t : Set β
hf : ContinuousOn f s
hs : IsClosed s
ht : IsClosed t
u : Set α
hu : IsClosed u ∧ f ⁻¹' t ∩ s = u ∩ s
⊢ IsClosed (u ∩ s)
state_after: no goals
tactic: apply IsClosed.inter hu.1 hs
Theorem: Units.divp_add_divp
File: Mathlib/Algebra/Ring/Units.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : CommRing α
a b : α
u₁ u₂ : αˣ
⊢ a /ₚ u₁ + b /ₚ u₂ = (a * ↑u₂ + ↑u₁ * b) /ₚ (u₁ * u₂)
state_after: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : CommRing α
a b : α
u₁ u₂ : αˣ
⊢ a * ↑u₁⁻¹ + b * ↑u₂⁻¹ = a * ↑u₂ * (↑u₂⁻¹ * ↑u₁⁻¹) + ↑u₁ * b * (↑u₂⁻¹ * ↑u₁⁻¹)
tactic: simp only [divp, add_mul, mul_inv_rev, val_mul]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : CommRing α
a b : α
u₁ u₂ : αˣ
⊢ a * ↑u₁⁻¹ + b * ↑u₂⁻¹ = a * ↑u₂ * (↑u₂⁻¹ * ↑u₁⁻¹) + ↑u₁ * b * (↑u₂⁻¹ * ↑u₁⁻¹)
state_after: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : CommRing α
a b : α
u₁ u₂ : αˣ
⊢ a * ↑u₁⁻¹ + ↑u₂⁻¹ * b = a * ↑u₂ * (↑u₂⁻¹ * ↑u₁⁻¹) + ↑u₂⁻¹ * ↑u₁⁻¹ * (↑u₁ * b)
tactic: rw [mul_comm (↑u₁ * b), mul_comm b]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝ : CommRing α
a b : α
u₁ u₂ : αˣ
⊢ a * ↑u₁⁻¹ + ↑u₂⁻¹ * b = a * ↑u₂ * (↑u₂⁻¹ * ↑u₁⁻¹) + ↑u₂⁻¹ * ↑u₁⁻¹ * (↑u₁ * b)
state_after: no goals
tactic: rw [← mul_assoc, ← mul_assoc, mul_assoc a, mul_assoc (↑u₂⁻¹ : α), mul_inv, inv_mul, mul_one,
    mul_one]
Theorem: TruncatedWittVector.truncate_surjective
File: Mathlib/RingTheory/WittVector/Truncated.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
⊢ Surjective ⇑(truncate hm)
state_after: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : TruncatedWittVector p n R
⊢ ∃ a, (truncate hm) a = x
tactic: intro x
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : TruncatedWittVector p n R
⊢ ∃ a, (truncate hm) a = x
state_after: case intro
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : 𝕎 R
⊢ ∃ a, (truncate hm) a = (WittVector.truncate n) x
tactic: obtain ⟨x, rfl⟩ := @WittVector.truncate_surjective p _ _ R _ x
state_before: case intro
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
m : ℕ
hm : n ≤ m
x : 𝕎 R
⊢ ∃ a, (truncate hm) a = (WittVector.truncate n) x
state_after: no goals
tactic: exact ⟨WittVector.truncate _ x, truncate_wittVector_truncate _ _⟩
Theorem: FractionalIdeal.invertible_iff_generator_nonzero
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

Proof steps:
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : Field K
R₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : IsDomain R₁
inst✝⁵ : Algebra R₁ K
inst✝⁴ : IsFractionRing R₁ K
I✝ J : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝³ : Field K'
inst✝² : Algebra R₁ K'
inst✝¹ : IsFractionRing R₁ K'
I : FractionalIdeal R₁⁰ K
inst✝ : (↑I).IsPrincipal
⊢ I * I⁻¹ = 1 ↔ generator ↑I ≠ 0
state_after: case mp
R : Type u_1
A : Type u_2
K : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : Field K
R₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : IsDomain R₁
inst✝⁵ : Algebra R₁ K
inst✝⁴ : IsFractionRing R₁ K
I✝ J : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝³ : Field K'
inst✝² : Algebra R₁ K'
inst✝¹ : IsFractionRing R₁ K'
I : FractionalIdeal R₁⁰ K
inst✝ : (↑I).IsPrincipal
⊢ I * I⁻¹ = 1 → generator ↑I ≠ 0

case mpr
R : Type u_1
A : Type u_2
K : Type u_3
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : Field K
R₁ : Type u_4
inst✝⁷ : CommRing R₁
inst✝⁶ : IsDomain R₁
inst✝⁵ : Algebra R₁ K
inst✝⁴ : IsFractionRing R₁ K
I✝ J : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝³ : Field K'
inst✝² : Algebra R₁ K'
inst✝¹ : IsFractionRing R₁ K'
I : FractionalIdeal R₁⁰ K
inst✝ : (↑I).IsPrincipal
⊢ generator ↑I ≠ 0 → I * I⁻¹ = 1
tactic: constructor
Theorem: Complex.norm_log_one_add_sub_self_le
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

Proof steps:
state_before: z : ℂ
hz : ‖z‖ < 1
⊢ ‖log (1 + z) - z‖ ≤ ‖z‖ ^ 2 * (1 - ‖z‖)⁻¹ / 2
state_after: case h.e'_3.h.e'_3
z : ℂ
hz : ‖z‖ < 1
⊢ log (1 + z) - z = log (1 + z) - logTaylor (1 + 1) z

case h.e'_4.h.e'_6
z : ℂ
hz : ‖z‖ < 1
⊢ 2 = ↑1 + 1
tactic: convert norm_log_sub_logTaylor_le 1 hz using 2
Theorem: neg_sub_neg
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✝ : DivisionCommMonoid α
a b c d : α
⊢ a⁻¹ / b⁻¹ = b / a
state_after: no goals
tactic: simp
Theorem: SimpleGraph.incidenceFinset_eq_filter
File: Mathlib/Combinatorics/SimpleGraph/Finite.lean

Proof steps:
state_before: V : Type u_1
G : SimpleGraph V
e : Sym2 V
v : V
inst✝² : Fintype ↑(G.neighborSet v)
inst✝¹ : DecidableEq V
inst✝ : Fintype ↑G.edgeSet
⊢ G.incidenceFinset v = filter (Membership.mem v) G.edgeFinset
state_after: case a
V : Type u_1
G : SimpleGraph V
e✝ : Sym2 V
v : V
inst✝² : Fintype ↑(G.neighborSet v)
inst✝¹ : DecidableEq V
inst✝ : Fintype ↑G.edgeSet
e : Sym2 V
⊢ e ∈ G.incidenceFinset v ↔ e ∈ filter (Membership.mem v) G.edgeFinset
tactic: ext e
state_before: case a
V : Type u_1
G : SimpleGraph V
e✝ : Sym2 V
v : V
inst✝² : Fintype ↑(G.neighborSet v)
inst✝¹ : DecidableEq V
inst✝ : Fintype ↑G.edgeSet
e : Sym2 V
⊢ e ∈ G.incidenceFinset v ↔ e ∈ filter (Membership.mem v) G.edgeFinset
state_after: case a.h
V : Type u_1
G : SimpleGraph V
e : Sym2 V
v : V
inst✝² : Fintype ↑(G.neighborSet v)
inst✝¹ : DecidableEq V
inst✝ : Fintype ↑G.edgeSet
x✝ y✝ : V
⊢ s(x✝, y✝) ∈ G.incidenceFinset v ↔ s(x✝, y✝) ∈ filter (Membership.mem v) G.edgeFinset
tactic: induction e
state_before: case a.h
V : Type u_1
G : SimpleGraph V
e : Sym2 V
v : V
inst✝² : Fintype ↑(G.neighborSet v)
inst✝¹ : DecidableEq V
inst✝ : Fintype ↑G.edgeSet
x✝ y✝ : V
⊢ s(x✝, y✝) ∈ G.incidenceFinset v ↔ s(x✝, y✝) ∈ filter (Membership.mem v) G.edgeFinset
state_after: no goals
tactic: simp [mk'_mem_incidenceSet_iff]
Theorem: Equiv.Perm.isCycle_swap_mul_aux₂
File: Mathlib/GroupTheory/Perm/Cycle/Basic.lean

Proof steps:
state_before: ι : Type u_1
α✝ : Type u_2
β : Type u_3
f g : Perm α✝
x y : α✝
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_4
inst✝ : DecidableEq α
⊢ ∀ (n : ℤ) {b x : α} {f : Perm α},
    (swap x (f x) * f) b ≠ b → (f ^ n) (f x) = b → ∃ i, ((swap x (f x) * f) ^ i) (f x) = b
state_after: ι : Type u_1
α✝ : Type u_2
β : Type u_3
f g : Perm α✝
x y : α✝
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_4
inst✝ : DecidableEq α
n : ℤ
⊢ ∀ {b x : α} {f : Perm α}, (swap x (f x) * f) b ≠ b → (f ^ n) (f x) = b → ∃ i, ((swap x (f x) * f) ^ i) (f x) = b
tactic: intro n
state_before: ι : Type u_1
α✝ : Type u_2
β : Type u_3
f g : Perm α✝
x y : α✝
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_4
inst✝ : DecidableEq α
n : ℤ
⊢ ∀ {b x : α} {f : Perm α}, (swap x (f x) * f) b ≠ b → (f ^ n) (f x) = b → ∃ i, ((swap x (f x) * f) ^ i) (f x) = b
state_after: case ofNat
ι : Type u_1
α✝ : Type u_2
β : Type u_3
f g : Perm α✝
x y : α✝
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_4
inst✝ : DecidableEq α
n : ℕ
⊢ ∀ {b x : α} {f : Perm α},
    (swap x (f x) * f) b ≠ b → (f ^ Int.ofNat n) (f x) = b → ∃ i, ((swap x (f x) * f) ^ i) (f x) = b

case negSucc
ι : Type u_1
α✝ : Type u_2
β : Type u_3
f g : Perm α✝
x y : α✝
inst✝² : DecidableEq α✝
inst✝¹ : Fintype α✝
α : Type u_4
inst✝ : DecidableEq α
n : ℕ
⊢ ∀ {b x : α} {f : Perm α},
    (swap x (f x) * f) b ≠ b → (f ^ Int.negSucc n) (f x) = b → ∃ i, ((swap x (f x) * f) ^ i) (f x) = b
tactic: induction' n with n n
Theorem: intervalIntegral.intervalIntegrable_rpow'
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

Proof steps:
state_before: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d r : ℝ
h : -1 < r
⊢ IntervalIntegrable (fun x => x ^ r) volume a b
state_after: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d r : ℝ
h : -1 < r
⊢ ∀ (c : ℝ), IntervalIntegrable (fun x => x ^ r) volume 0 c
tactic: suffices ∀ c : ℝ, IntervalIntegrable (fun x => x ^ r) volume 0 c by
    exact IntervalIntegrable.trans (this a).symm (this b)
state_before: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d r : ℝ
h : -1 < r
this : ∀ (c : ℝ), 0 ≤ c → IntervalIntegrable (fun x => x ^ r) volume 0 c
⊢ ∀ (c : ℝ), IntervalIntegrable (fun x => x ^ r) volume 0 c
state_after: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c✝ d r : ℝ
h : -1 < r
this : ∀ (c : ℝ), 0 ≤ c → IntervalIntegrable (fun x => x ^ r) volume 0 c
c : ℝ
⊢ IntervalIntegrable (fun x => x ^ r) volume 0 c
tactic: intro c
state_before: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c✝ d r : ℝ
h : -1 < r
this : ∀ (c : ℝ), 0 ≤ c → IntervalIntegrable (fun x => x ^ r) volume 0 c
c : ℝ
⊢ IntervalIntegrable (fun x => x ^ r) volume 0 c
state_after: case inl
a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c✝ d r : ℝ
h : -1 < r
this : ∀ (c : ℝ), 0 ≤ c → IntervalIntegrable (fun x => x ^ r) volume 0 c
c : ℝ
hc : 0 ≤ c
⊢ IntervalIntegrable (fun x => x ^ r) volume 0 c

case inr
a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c✝ d r : ℝ
h : -1 < r
this : ∀ (c : ℝ), 0 ≤ c → IntervalIntegrable (fun x => x ^ r) volume 0 c
c : ℝ
hc : c ≤ 0
⊢ IntervalIntegrable (fun x => x ^ r) volume 0 c
tactic: rcases le_total 0 c with (hc | hc)
Theorem: rotationOf_coe
File: Mathlib/Analysis/Complex/Isometry.lean

Proof steps:
state_before: e : ℂ ≃ₗᵢ[ℝ] ℂ
⊢ e 1 / ↑(Complex.abs (e 1)) ∈ circle
state_after: no goals
tactic: simp
Theorem: List.inter_reverse
File: Mathlib/Data/List/Lattice.lean

Proof steps:
state_before: α : Type u_1
l l₁ l₂ : List α
p : α → Prop
a : α
inst✝ : DecidableEq α
xs ys : List α
⊢ xs.inter ys.reverse = xs.inter ys
state_after: no goals
tactic: simp only [List.inter, elem_eq_mem, mem_reverse]
Theorem: Cardinal.exists_finset_le_card
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
⊢ ∃ s, n ≤ s.card
state_after: case inl
α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
hα : Finite α
⊢ ∃ s, n ≤ s.card

case inr
α✝ β : Type u
α : Type u_1
n : ℕ
h : ↑n ≤ #α
hα : Infinite α
⊢ ∃ s, n ≤ s.card
tactic: obtain hα|hα := finite_or_infinite α
Theorem: CategoryTheory.kernel.ι_op
File: Mathlib/CategoryTheory/Abelian/Opposite.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
A B : Cᵒᵖ
g : A ⟶ B
⊢ (kernel.ι f.op).unop = eqToHom ⋯ ≫ cokernel.π f ≫ (kernelOpUnop f).inv
state_after: no goals
tactic: simp [kernelOpUnop]
Theorem: Finset.card_mono
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t : Finset α
a b : α
⊢ Monotone card
state_after: no goals
tactic: apply card_le_card
Theorem: Ideal.Quotient.lift_surjective_of_surjective
File: Mathlib/RingTheory/Ideal/Quotient.lean

Proof steps:
state_before: R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x y : R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : ∀ a ∈ I, f a = 0
hf : Function.Surjective ⇑f
⊢ Function.Surjective ⇑(lift I f H)
state_after: R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x y✝ : R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : ∀ a ∈ I, f a = 0
hf : Function.Surjective ⇑f
y : S
⊢ ∃ a, (lift I f H) a = y
tactic: intro y
state_before: R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x y✝ : R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : ∀ a ∈ I, f a = 0
hf : Function.Surjective ⇑f
y : S
⊢ ∃ a, (lift I f H) a = y
state_after: case intro
R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x✝ y : R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : ∀ a ∈ I, f a = 0
hf : Function.Surjective ⇑f
x : R
⊢ ∃ a, (lift I f H) a = f x
tactic: obtain ⟨x, rfl⟩ := hf y
state_before: case intro
R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x✝ y : R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : ∀ a ∈ I, f a = 0
hf : Function.Surjective ⇑f
x : R
⊢ ∃ a, (lift I f H) a = f x
state_after: case h
R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x✝ y : R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : ∀ a ∈ I, f a = 0
hf : Function.Surjective ⇑f
x : R
⊢ (lift I f H) ((mk I) x) = f x
tactic: use Ideal.Quotient.mk I x
state_before: case h
R : Type u
inst✝¹ : CommRing R
I✝ : Ideal R
a b : R
S : Type v
x✝ y : R
inst✝ : Semiring S
I : Ideal R
f : R →+* S
H : ∀ a ∈ I, f a = 0
hf : Function.Surjective ⇑f
x : R
⊢ (lift I f H) ((mk I) x) = f x
state_after: no goals
tactic: simp only [Ideal.Quotient.lift_mk]
Theorem: MeasureTheory.OuterMeasure.comap_top
File: Mathlib/MeasureTheory/OuterMeasure/Operations.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : OuterMeasure α
f : α → β
s : Set α
hs : s.Nonempty
⊢ ((comap f) ⊤) s = ⊤ s
state_after: no goals
tactic: rw [comap_apply, top_apply hs, top_apply (hs.image _)]
Theorem: ContinuousLinearEquiv.comp_differentiableAt_iff
File: Mathlib/Analysis/Calculus/FDeriv/Equiv.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type u_4
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
G' : Type u_5
inst✝¹ : NormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
f✝ f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x✝ : E
s t : Set E
L L₁ L₂ : Filter E
iso : E ≃L[𝕜] F
f : G → E
x : G
⊢ DifferentiableAt 𝕜 (⇑iso ∘ f) x ↔ DifferentiableAt 𝕜 f x
state_after: no goals
tactic: rw [← differentiableWithinAt_univ, ← differentiableWithinAt_univ,
    iso.comp_differentiableWithinAt_iff]
Theorem: ENNReal.exists_nnreal_pos_mul_lt
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
⊢ ∃ n > 0, ↑n * a < b
state_after: case intro.intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
n : ℕ
npos : 0 < n
hn : (↑n)⁻¹ * a < b
⊢ ∃ n > 0, ↑n * a < b
tactic: rcases exists_nat_pos_inv_mul_lt ha hb with ⟨n, npos : 0 < n, hn⟩
state_before: case intro.intro
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
n : ℕ
npos : 0 < n
hn : (↑n)⁻¹ * a < b
⊢ ∃ n > 0, ↑n * a < b
state_after: case h
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
n : ℕ
npos : 0 < n
hn : (↑n)⁻¹ * a < b
⊢ (↑n)⁻¹ > 0 ∧ ↑(↑n)⁻¹ * a < b
tactic: use (n : ℝ≥0)⁻¹
state_before: case h
a b c d : ℝ≥0∞
r p q : ℝ≥0
ha : a ≠ ⊤
hb : b ≠ 0
n : ℕ
npos : 0 < n
hn : (↑n)⁻¹ * a < b
⊢ (↑n)⁻¹ > 0 ∧ ↑(↑n)⁻¹ * a < b
state_after: no goals
tactic: simp [*, npos.ne', zero_lt_one]
Theorem: CharTwo.list_sum_mul_self
File: Mathlib/Algebra/CharP/Two.lean

Proof steps:
state_before: R : Type u_1
ι : Type u_2
inst✝¹ : CommSemiring R
inst✝ : CharP R 2
l : List R
⊢ l.sum * l.sum = (List.map (fun x => x * x) l).sum
state_after: no goals
tactic: simp_rw [← pow_two, list_sum_sq]
Theorem: MeasureTheory.lpMeasSubgroupToLpTrim_sub
File: Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean

Proof steps:
state_before: α : Type u_1
E' : Type u_2
F : Type u_3
F' : Type u_4
𝕜 : Type u_5
p : ℝ≥0∞
inst✝¹⁰ : RCLike 𝕜
inst✝⁹ : NormedAddCommGroup E'
inst✝⁸ : InnerProductSpace 𝕜 E'
inst✝⁷ : CompleteSpace E'
inst✝⁶ : NormedSpace ℝ E'
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace 𝕜 F'
inst✝¹ : NormedSpace ℝ F'
inst✝ : CompleteSpace F'
ι : Type u_6
m m0 : MeasurableSpace α
μ : Measure α
hm : m ≤ m0
f g : ↥(lpMeasSubgroup F m p μ)
⊢ lpMeasSubgroupToLpTrim F p μ hm (f - g) = lpMeasSubgroupToLpTrim F p μ hm f - lpMeasSubgroupToLpTrim F p μ hm g
state_after: no goals
tactic: rw [sub_eq_add_neg, sub_eq_add_neg, lpMeasSubgroupToLpTrim_add,
    lpMeasSubgroupToLpTrim_neg]
Theorem: TopCat.toLightCondSet_val_obj
File: Mathlib/Condensed/Light/TopComparison.lean

Proof steps:
state_before: X : TopCat
⊢ EqualizerCondition (yonedaPresheaf LightProfinite.toTopCat ↑X)
state_after: X : TopCat
⊢ ∀ (Z B : LightProfinite) (π : Z ⟶ B) [inst : EffectiveEpi π], QuotientMap ⇑(LightProfinite.toTopCat.map π)
tactic: apply equalizerCondition_yonedaPresheaf LightProfinite.toTopCat.{u} X
state_before: X : TopCat
⊢ ∀ (Z B : LightProfinite) (π : Z ⟶ B) [inst : EffectiveEpi π], QuotientMap ⇑(LightProfinite.toTopCat.map π)
state_after: X : TopCat
Z B : LightProfinite
π : Z ⟶ B
he : EffectiveEpi π
⊢ QuotientMap ⇑(LightProfinite.toTopCat.map π)
tactic: intro Z B π he
state_before: X : TopCat
Z B : LightProfinite
π : Z ⟶ B
he : EffectiveEpi π
⊢ QuotientMap ⇑(LightProfinite.toTopCat.map π)
state_after: X : TopCat
Z B : LightProfinite
π : Z ⟶ B
he : Function.Surjective ⇑π
⊢ QuotientMap ⇑(LightProfinite.toTopCat.map π)
tactic: rw [LightProfinite.effectiveEpi_iff_surjective] at he
state_before: X : TopCat
Z B : LightProfinite
π : Z ⟶ B
he : Function.Surjective ⇑π
⊢ QuotientMap ⇑(LightProfinite.toTopCat.map π)
state_after: no goals
tactic: apply QuotientMap.of_surjective_continuous he π.continuous
Theorem: List.reverse_join
File: Mathlib/Data/List/Join.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
L : List (List α)
⊢ L.join.reverse = (map reverse L).reverse.join
state_after: case nil
α : Type u_1
β : Type u_2
⊢ [].join.reverse = (map reverse []).reverse.join

case cons
α : Type u_1
β : Type u_2
head✝ : List α
tail✝ : List (List α)
ih : tail✝.join.reverse = (map reverse tail✝).reverse.join
⊢ (head✝ :: tail✝).join.reverse = (map reverse (head✝ :: tail✝)).reverse.join
tactic: induction' L with _ _ ih