ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: intervalIntegral.integral_comp_smul_deriv''
File: Mathlib/MeasureTheory/Integral/FundThmCalculus.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
f✝¹ : ℝ → E
g' g✝ φ : ℝ → ℝ
a b : ℝ
inst✝² : CompleteSpace E
f✝ f'✝ : ℝ → E
G : Type u_6
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f f' : ℝ → ℝ
g : ℝ → G
hf : ContinuousOn f [[a, b]]
hff' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt f (f' x) (Ioi x) x
hf' : ContinuousOn f' [[a, b]]
hg : ContinuousOn g (f '' [[a, b]])
⊢ ∫ (x : ℝ) in a..b, f' x • (g ∘ f) x = ∫ (u : ℝ) in f a..f b, g u
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
f✝¹ : ℝ → E
g' g✝ φ : ℝ → ℝ
a b : ℝ
inst✝² : CompleteSpace E
f✝ f'✝ : ℝ → E
G : Type u_6
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f f' : ℝ → ℝ
g : ℝ → G
hf : ContinuousOn f [[a, b]]
hff' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt f (f' x) (Ioi x) x
hf' : ContinuousOn f' [[a, b]]
hg : ContinuousOn g (f '' [[a, b]])
⊢ IntegrableOn g (f '' [[a, b]]) volume
tactic: refine
    integral_comp_smul_deriv''' hf hff' (hg.mono <| image_subset _ Ioo_subset_Icc_self) ?_
      (hf'.smul (hg.comp hf <| subset_preimage_image f _)).integrableOn_Icc
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
f✝¹ : ℝ → E
g' g✝ φ : ℝ → ℝ
a b : ℝ
inst✝² : CompleteSpace E
f✝ f'✝ : ℝ → E
G : Type u_6
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f f' : ℝ → ℝ
g : ℝ → G
hf : ContinuousOn f [[a, b]]
hff' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt f (f' x) (Ioi x) x
hf' : ContinuousOn f' [[a, b]]
hg : ContinuousOn g (f '' [[a, b]])
⊢ IntegrableOn g (f '' [[a, b]]) volume
state_after: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
f✝¹ : ℝ → E
g' g✝ φ : ℝ → ℝ
a b : ℝ
inst✝² : CompleteSpace E
f✝ f'✝ : ℝ → E
G : Type u_6
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f f' : ℝ → ℝ
g : ℝ → G
hf : ContinuousOn f [[a, b]]
hff' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt f (f' x) (Ioi x) x
hf' : ContinuousOn f' [[a, b]]
hg : ContinuousOn g [[sInf (f '' [[a, b]]), sSup (f '' [[a, b]])]]
⊢ IntegrableOn g [[sInf (f '' [[a, b]]), sSup (f '' [[a, b]])]] volume
tactic: rw [hf.image_uIcc] at hg ⊢
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
f✝¹ : ℝ → E
g' g✝ φ : ℝ → ℝ
a b : ℝ
inst✝² : CompleteSpace E
f✝ f'✝ : ℝ → E
G : Type u_6
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f f' : ℝ → ℝ
g : ℝ → G
hf : ContinuousOn f [[a, b]]
hff' : ∀ x ∈ Ioo (min a b) (max a b), HasDerivWithinAt f (f' x) (Ioi x) x
hf' : ContinuousOn f' [[a, b]]
hg : ContinuousOn g [[sInf (f '' [[a, b]]), sSup (f '' [[a, b]])]]
⊢ IntegrableOn g [[sInf (f '' [[a, b]]), sSup (f '' [[a, b]])]] volume
state_after: no goals
tactic: exact hg.integrableOn_Icc
Theorem: Function.Embedding.sumSet_range
File: Mathlib/Logic/Embedding/Set.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
s✝ t✝ r s t : Set α
h : Disjoint s t
⊢ range ⇑(sumSet h) = s ∪ t
state_after: no goals
tactic: simp [Set.ext_iff]
Theorem: CategoryTheory.Grpd.piIsoPi_hom_π
File: Mathlib/CategoryTheory/Category/Grpd.lean

Proof steps:
state_before: J : Type u
f : J → Grpd
j : J
⊢ (piIsoPi J f).hom ≫ Limits.Pi.π f j = Pi.eval (fun i => ↑(f i)) j
state_after: J : Type u
f : J → Grpd
j : J
⊢ (piLimitFan f).π.app { as := j } = Pi.eval (fun i => ↑(f i)) j
tactic: simp [piIsoPi]
state_before: J : Type u
f : J → Grpd
j : J
⊢ (piLimitFan f).π.app { as := j } = Pi.eval (fun i => ↑(f i)) j
state_after: no goals
tactic: rfl
Theorem: Distrib.ext_iff
File: Mathlib/Algebra/Ring/Ext.lean

Proof steps:
state_before: R : Type u
inst₁ inst₂ : Distrib R
⊢ inst₁ = inst₂ → HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: R : Type u
inst₁ : Distrib R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
tactic: rintro rfl
state_before: R : Type u
inst₁ : Distrib R
⊢ HAdd.hAdd = HAdd.hAdd ∧ HMul.hMul = HMul.hMul
state_after: no goals
tactic: constructor <;> rfl
Theorem: Set.range_comp
File: Mathlib/Data/Set/Image.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
ι' : Sort u_5
f✝ : ι → α
s t : Set α
g : α → β
f : ι → α
⊢ range (g ∘ f) = g '' range f
state_after: no goals
tactic: aesop
Theorem: MeasureTheory.limsup_measure_closed_le_iff_liminf_measure_open_ge
File: Mathlib/MeasureTheory/Measure/Portmanteau.lean

Proof steps:
state_before: Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
inst✝³ : TopologicalSpace Ω
inst✝² : OpensMeasurableSpace Ω
ι : Type u_2
L : Filter ι
μ : Measure Ω
μs : ι → Measure Ω
inst✝¹ : IsProbabilityMeasure μ
inst✝ : ∀ (i : ι), IsProbabilityMeasure (μs i)
⊢ (∀ (F : Set Ω), IsClosed F → limsup (fun i => (μs i) F) L ≤ μ F) ↔
    ∀ (G : Set Ω), IsOpen G → μ G ≤ liminf (fun i => (μs i) G) L
state_after: case mp
Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
inst✝³ : TopologicalSpace Ω
inst✝² : OpensMeasurableSpace Ω
ι : Type u_2
L : Filter ι
μ : Measure Ω
μs : ι → Measure Ω
inst✝¹ : IsProbabilityMeasure μ
inst✝ : ∀ (i : ι), IsProbabilityMeasure (μs i)
⊢ (∀ (F : Set Ω), IsClosed F → limsup (fun i => (μs i) F) L ≤ μ F) →
    ∀ (G : Set Ω), IsOpen G → μ G ≤ liminf (fun i => (μs i) G) L

case mpr
Ω : Type u_1
inst✝⁴ : MeasurableSpace Ω
inst✝³ : TopologicalSpace Ω
inst✝² : OpensMeasurableSpace Ω
ι : Type u_2
L : Filter ι
μ : Measure Ω
μs : ι → Measure Ω
inst✝¹ : IsProbabilityMeasure μ
inst✝ : ∀ (i : ι), IsProbabilityMeasure (μs i)
⊢ (∀ (G : Set Ω), IsOpen G → μ G ≤ liminf (fun i => (μs i) G) L) →
    ∀ (F : Set Ω), IsClosed F → limsup (fun i => (μs i) F) L ≤ μ F
tactic: constructor
Theorem: Int.toNat_add_toNat_neg_eq_nnnorm
File: Mathlib/Analysis/NormedSpace/Int.lean

Proof steps:
state_before: n : ℤ
⊢ ↑n.toNat + ↑(-n).toNat = ‖n‖₊
state_after: no goals
tactic: rw [← Nat.cast_add, toNat_add_toNat_neg_eq_natAbs, NNReal.natCast_natAbs]
Theorem: Polynomial.induction_on
File: Mathlib/Algebra/Polynomial/Induction.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A✝ : Type z
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
M : R[X] → Prop
p : R[X]
h_C : ∀ (a : R), M (C a)
h_add : ∀ (p q : R[X]), M p → M q → M (p + q)
h_monomial : ∀ (n : ℕ) (a : R), M (C a * X ^ n) → M (C a * X ^ (n + 1))
A : ∀ {n : ℕ} {a : R}, M (C a * X ^ n)
B : ∀ (s : Finset ℕ), M (∑ n ∈ s, C (p.coeff n) * X ^ n)
⊢ M p
state_after: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A✝ : Type z
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
M : R[X] → Prop
p : R[X]
h_C : ∀ (a : R), M (C a)
h_add : ∀ (p q : R[X]), M p → M q → M (p + q)
h_monomial : ∀ (n : ℕ) (a : R), M (C a * X ^ n) → M (C a * X ^ (n + 1))
A : ∀ {n : ℕ} {a : R}, M (C a * X ^ n)
B : ∀ (s : Finset ℕ), M (∑ n ∈ s, C (p.coeff n) * X ^ n)
⊢ M (∑ n ∈ p.support, C (p.coeff n) * X ^ n)
tactic: rw [← sum_C_mul_X_pow_eq p, Polynomial.sum]
state_before: R : Type u
S : Type v
T : Type w
ι : Type x
k : Type y
A✝ : Type z
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q r : R[X]
M : R[X] → Prop
p : R[X]
h_C : ∀ (a : R), M (C a)
h_add : ∀ (p q : R[X]), M p → M q → M (p + q)
h_monomial : ∀ (n : ℕ) (a : R), M (C a * X ^ n) → M (C a * X ^ (n + 1))
A : ∀ {n : ℕ} {a : R}, M (C a * X ^ n)
B : ∀ (s : Finset ℕ), M (∑ n ∈ s, C (p.coeff n) * X ^ n)
⊢ M (∑ n ∈ p.support, C (p.coeff n) * X ^ n)
state_after: no goals
tactic: exact B (support p)
Theorem: CoxeterSystem.getD_leftInvSeq_mul_wordProd
File: Mathlib/GroupTheory/Coxeter/Inversion.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
j : ℕ
⊢ (cs.leftInvSeq ω).getD j 1 * cs.wordProd ω = cs.wordProd (ω.eraseIdx j)
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
j : ℕ
⊢ cs.wordProd (take j ω) * (Option.map cs.simple (ω.get? j)).getD 1 * (cs.wordProd (take j ω))⁻¹ * cs.wordProd ω =
    cs.wordProd (take j ω ++ drop (j + 1) ω)
tactic: rw [getD_leftInvSeq, eraseIdx_eq_take_drop_succ]
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
j : ℕ
⊢ cs.wordProd (take j ω) * (Option.map cs.simple (ω.get? j)).getD 1 * (cs.wordProd (take j ω))⁻¹ * cs.wordProd ω =
    cs.wordProd (take j ω ++ drop (j + 1) ω)
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
j : ℕ
⊢ cs.wordProd (take j ω) * (Option.map cs.simple (ω.get? j)).getD 1 * (cs.wordProd (take j ω))⁻¹ *
      cs.wordProd (take (j + 1) ω ++ drop (j + 1) ω) =
    cs.wordProd (take j ω ++ drop (j + 1) ω)
tactic: nth_rw 4 [← take_append_drop (j + 1) ω]
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
j : ℕ
⊢ cs.wordProd (take j ω) * (Option.map cs.simple (ω.get? j)).getD 1 * (cs.wordProd (take j ω))⁻¹ *
      cs.wordProd (take (j + 1) ω ++ drop (j + 1) ω) =
    cs.wordProd (take j ω ++ drop (j + 1) ω)
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
j : ℕ
⊢ cs.wordProd (take j ω) * (Option.map cs.simple (ω.get? j)).getD 1 * (cs.wordProd (take j ω))⁻¹ *
      cs.wordProd (take j ω ++ ω[j]?.toList ++ drop (j + 1) ω) =
    cs.wordProd (take j ω ++ drop (j + 1) ω)
tactic: rw [take_succ]
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
j : ℕ
⊢ cs.wordProd (take j ω) * (Option.map cs.simple (ω.get? j)).getD 1 * (cs.wordProd (take j ω))⁻¹ *
      cs.wordProd (take j ω ++ ω[j]?.toList ++ drop (j + 1) ω) =
    cs.wordProd (take j ω ++ drop (j + 1) ω)
state_after: case inl
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
j : ℕ
lt : j < ω.length
⊢ cs.wordProd (take j ω) * (Option.map cs.simple (ω.get? j)).getD 1 * (cs.wordProd (take j ω))⁻¹ *
      cs.wordProd (take j ω ++ ω[j]?.toList ++ drop (j + 1) ω) =
    cs.wordProd (take j ω ++ drop (j + 1) ω)

case inr
B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
ω : List B
j : ℕ
le : ω.length ≤ j
⊢ cs.wordProd (take j ω) * (Option.map cs.simple (ω.get? j)).getD 1 * (cs.wordProd (take j ω))⁻¹ *
      cs.wordProd (take j ω ++ ω[j]?.toList ++ drop (j + 1) ω) =
    cs.wordProd (take j ω ++ drop (j + 1) ω)
tactic: obtain lt | le := lt_or_le j ω.length
Theorem: HurwitzZeta.hasSum_int_sinZeta
File: Mathlib/NumberTheory/LSeries/HurwitzZetaOdd.lean

Proof steps:
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
⊢ HasSum (fun n => -I * ↑n.sign * cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2) (sinZeta (↑a) s)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
⊢ HasSum (fun n => -I * ↑n.sign * cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2) (completedSinZeta (↑a) s / (s + 1).Gammaℝ)
tactic: rw [sinZeta]
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
⊢ HasSum (fun n => -I * ↑n.sign * cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2) (completedSinZeta (↑a) s / (s + 1).Gammaℝ)
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℤ
⊢ -I * ↑n.sign * cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2 =
    (s + 1).Gammaℝ * -I * ↑n.sign * cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2 / (s + 1).Gammaℝ
tactic: refine ((hasSum_int_completedSinZeta a hs).div_const (Gammaℝ (s + 1))).congr_fun fun n ↦ ?_
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℤ
⊢ -I * ↑n.sign * cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2 =
    (s + 1).Gammaℝ * -I * ↑n.sign * cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2 / (s + 1).Gammaℝ
state_after: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℤ
this : 0 < (s + 1).re
⊢ -I * ↑n.sign * cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2 =
    (s + 1).Gammaℝ * -I * ↑n.sign * cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2 / (s + 1).Gammaℝ
tactic: have : 0 < re (s + 1) := by rw [add_re, one_re]; positivity
state_before: a : ℝ
s : ℂ
hs : 1 < s.re
n : ℤ
this : 0 < (s + 1).re
⊢ -I * ↑n.sign * cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2 =
    (s + 1).Gammaℝ * -I * ↑n.sign * cexp (2 * ↑π * I * ↑a * ↑n) / ↑|n| ^ s / 2 / (s + 1).Gammaℝ
state_after: no goals
tactic: simp only [mul_assoc, div_right_comm _ _ (Gammaℝ _),
    mul_div_cancel_left₀ _ (Gammaℝ_ne_zero_of_re_pos this)]
Theorem: Matrix.Commute.zpow_right
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

Proof steps:
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A B : M
h : Commute A B
m : ℤ
⊢ Commute A (B ^ m)
state_after: case inl.intro
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A B : M
h : Commute A B
m : ℤ
hB : B⁻¹ * B = 1
right✝ : B * B⁻¹ = 1
⊢ Commute A (B ^ m)

case inr
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A B : M
h : Commute A B
m : ℤ
hB : B⁻¹ = 0
⊢ Commute A (B ^ m)
tactic: rcases nonsing_inv_cancel_or_zero B with (⟨hB, _⟩ | hB)
Theorem: MeasureTheory.SignedMeasure.singularPart_sub
File: Mathlib/MeasureTheory/Decomposition/SignedLebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν : Measure α
s✝ t✝ s t : SignedMeasure α
μ : Measure α
inst✝¹ : s.HaveLebesgueDecomposition μ
inst✝ : t.HaveLebesgueDecomposition μ
⊢ (s - t).singularPart μ = s.singularPart μ - t.singularPart μ
state_after: no goals
tactic: rw [sub_eq_add_neg, sub_eq_add_neg, singularPart_add, singularPart_neg]
Theorem: Ordinal.type_subrel_lt
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
⊢ type (Subrel (fun x x_1 => x < x_1) {o' | o' < o}) = lift.{u + 1, u} o
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
⊢ ∀ (a : WellOrder), type (Subrel (fun x x_1 => x < x_1) {o' | o' < ⟦a⟧}) = lift.{u + 1, u} ⟦a⟧
tactic: refine Quotient.inductionOn o ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
⊢ ∀ (a : WellOrder), type (Subrel (fun x x_1 => x < x_1) {o' | o' < ⟦a⟧}) = lift.{u + 1, u} ⟦a⟧
state_after: case mk
α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo : IsWellOrder α r
⊢ type (Subrel (fun x x_1 => x < x_1) {o' | o' < ⟦{ α := α, r := r, wo := wo }⟧}) =
    lift.{u + 1, u} ⟦{ α := α, r := r, wo := wo }⟧
tactic: rintro ⟨α, r, wo⟩
state_before: case mk
α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo : IsWellOrder α r
⊢ type (Subrel (fun x x_1 => x < x_1) {o' | o' < ⟦{ α := α, r := r, wo := wo }⟧}) =
    lift.{u + 1, u} ⟦{ α := α, r := r, wo := wo }⟧
state_after: case mk.a
α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo : IsWellOrder α r
⊢ { α := ↑{o' | o' < ⟦{ α := α, r := r, wo := wo }⟧},
      r := Subrel (fun x x_1 => x < x_1) {o' | o' < ⟦{ α := α, r := r, wo := wo }⟧}, wo := ⋯ } ≈
    { α := ULift.{u + 1, u} { α := α, r := r, wo := wo }.α, r := ULift.down ⁻¹'o { α := α, r := r, wo := wo }.r,
      wo := ⋯ }
tactic: apply Quotient.sound
state_before: case mk.a
α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo : IsWellOrder α r
⊢ { α := ↑{o' | o' < ⟦{ α := α, r := r, wo := wo }⟧},
      r := Subrel (fun x x_1 => x < x_1) {o' | o' < ⟦{ α := α, r := r, wo := wo }⟧}, wo := ⋯ } ≈
    { α := ULift.{u + 1, u} { α := α, r := r, wo := wo }.α, r := ULift.down ⁻¹'o { α := α, r := r, wo := wo }.r,
      wo := ⋯ }
state_after: case mk.a.val
α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo : IsWellOrder α r
⊢ Subrel (fun x x_1 => x < x_1) {o' | o' < ⟦{ α := α, r := r, wo := wo }⟧} ≃r
    ULift.down ⁻¹'o { α := α, r := r, wo := wo }.r
tactic: constructor
state_before: case mk.a.val
α✝ : Type u_1
β : Type u_2
γ : Type u_3
r✝ : α✝ → α✝ → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
α : Type u
r : α → α → Prop
wo : IsWellOrder α r
⊢ Subrel (fun x x_1 => x < x_1) {o' | o' < ⟦{ α := α, r := r, wo := wo }⟧} ≃r
    ULift.down ⁻¹'o { α := α, r := r, wo := wo }.r
state_after: no goals
tactic: refine ((RelIso.preimage Equiv.ulift r).trans (enumIso r).symm).symm
Theorem: ENNReal.add_thirds
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ a / 3 + a / 3 + a / 3 = a
state_after: no goals
tactic: rw [div_eq_mul_inv, ← mul_add, ← mul_add, inv_three_add_inv_three, mul_one]
Theorem: Mathlib.Tactic.Ring.neg_zero
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a a' a₁ a₂ a₃ b b' b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : Ring R
⊢ -0 = 0
state_after: no goals
tactic: simp
Theorem: List.splitOn_intercalate
File: Mathlib/Data/List/Basic.lean

Proof steps:
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
inst✝ : DecidableEq α
x : α
hx : ∀ (l : List α), l ∈ ls → ¬x ∈ l
hls : ls ≠ []
⊢ splitOn x ([x].intercalate ls) = ls
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
inst✝ : DecidableEq α
x : α
hx : ∀ (l : List α), l ∈ ls → ¬x ∈ l
hls : ls ≠ []
⊢ splitOn x (intersperse [x] ls).join = ls
tactic: simp only [intercalate]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
inst✝ : DecidableEq α
x : α
hx : ∀ (l : List α), l ∈ ls → ¬x ∈ l
hls : ls ≠ []
⊢ splitOn x (intersperse [x] ls).join = ls
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
inst✝ : DecidableEq α
x : α
hx : ∀ (l : List α), l ∈ [] → ¬x ∈ l
hls : [] ≠ []
⊢ splitOn x (intersperse [x] []).join = []

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
inst✝ : DecidableEq α
x : α
hd : List α
tl : List (List α)
ih : (∀ (l : List α), l ∈ tl → ¬x ∈ l) → tl ≠ [] → splitOn x (intersperse [x] tl).join = tl
hx : ∀ (l : List α), l ∈ hd :: tl → ¬x ∈ l
hls : hd :: tl ≠ []
⊢ splitOn x (intersperse [x] (hd :: tl)).join = hd :: tl
tactic: induction' ls with hd tl ih
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
inst✝ : DecidableEq α
x : α
hd : List α
tl : List (List α)
ih : (∀ (l : List α), l ∈ tl → ¬x ∈ l) → tl ≠ [] → splitOn x (intersperse [x] tl).join = tl
hx : ∀ (l : List α), l ∈ hd :: tl → ¬x ∈ l
hls : hd :: tl ≠ []
⊢ splitOn x (intersperse [x] (hd :: tl)).join = hd :: tl
state_after: case cons.nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
inst✝ : DecidableEq α
x : α
hd : List α
ih : (∀ (l : List α), l ∈ [] → ¬x ∈ l) → [] ≠ [] → splitOn x (intersperse [x] []).join = []
hx : ∀ (l : List α), l ∈ [hd] → ¬x ∈ l
hls : [hd] ≠ []
⊢ splitOn x (intersperse [x] [hd]).join = [hd]

case cons.cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
p : α → Bool
xs ys : List α
ls : List (List α)
f : List α → List α
inst✝ : DecidableEq α
x : α
hd head✝ : List α
tail✝ : List (List α)
ih :
  (∀ (l : List α), l ∈ head✝ :: tail✝ → ¬x ∈ l) →
    head✝ :: tail✝ ≠ [] → splitOn x (intersperse [x] (head✝ :: tail✝)).join = head✝ :: tail✝
hx : ∀ (l : List α), l ∈ hd :: head✝ :: tail✝ → ¬x ∈ l
hls : hd :: head✝ :: tail✝ ≠ []
⊢ splitOn x (intersperse [x] (hd :: head✝ :: tail✝)).join = hd :: head✝ :: tail✝
tactic: cases tl
Theorem: ite_prop_iff_or
File: Mathlib/Logic/Basic.lean

Proof steps:
state_before: α : Sort u_1
σ : α → Sort u_2
P Q R : Prop
inst✝¹ : Decidable P
inst✝ : Decidable Q
a b c : α
A : P → α
B : ¬P → α
⊢ (if P then Q else R) ↔ P ∧ Q ∨ ¬P ∧ R
state_after: no goals
tactic: by_cases p : P <;> simp [p]
Theorem: ProbabilityTheory.Kernel.withDensity_add_right
File: Mathlib/Probability/Kernel/WithDensity.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
f✝ : α → β → ℝ≥0∞
inst✝ : IsSFiniteKernel κ
f g : α → β → ℝ≥0∞
hf : Measurable (Function.uncurry f)
hg : Measurable (Function.uncurry g)
⊢ κ.withDensity (f + g) = κ.withDensity f + κ.withDensity g
state_after: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
f✝ : α → β → ℝ≥0∞
inst✝ : IsSFiniteKernel κ
f g : α → β → ℝ≥0∞
hf : Measurable (Function.uncurry f)
hg : Measurable (Function.uncurry g)
a : α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ ((κ.withDensity (f + g)) a) s✝ = ((κ.withDensity f + κ.withDensity g) a) s✝
tactic: ext a
state_before: case h.h
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
f✝ : α → β → ℝ≥0∞
inst✝ : IsSFiniteKernel κ
f g : α → β → ℝ≥0∞
hf : Measurable (Function.uncurry f)
hg : Measurable (Function.uncurry g)
a : α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ ((κ.withDensity (f + g)) a) s✝ = ((κ.withDensity f + κ.withDensity g) a) s✝
state_after: case h.h.hg
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
f✝ : α → β → ℝ≥0∞
inst✝ : IsSFiniteKernel κ
f g : α → β → ℝ≥0∞
hf : Measurable (Function.uncurry f)
hg : Measurable (Function.uncurry g)
a : α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ Measurable (g a)

case h.h.hf
α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α β
f✝ : α → β → ℝ≥0∞
inst✝ : IsSFiniteKernel κ
f g : α → β → ℝ≥0∞
hf : Measurable (Function.uncurry f)
hg : Measurable (Function.uncurry g)
a : α
s✝ : Set β
a✝ : MeasurableSet s✝
⊢ Measurable (Function.uncurry (f + g))
tactic: rw [coe_add, Pi.add_apply, Kernel.withDensity_apply _ hf, Kernel.withDensity_apply _ hg,
    Kernel.withDensity_apply, Pi.add_apply, MeasureTheory.withDensity_add_right]
Theorem: EMetric.isOpen_iff
File: Mathlib/Topology/EMetricSpace/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
⊢ IsOpen s ↔ ∀ x ∈ s, ∃ ε > 0, ball x ε ⊆ s
state_after: no goals
tactic: simp [isOpen_iff_nhds, mem_nhds_iff]