zzhisthebest/LeanBenchmark huggingface dataset:
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_105.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} {μ : Measure Ω} [inst_1 : IsProbabilityMeasure μ] [inst_2 : Countable ι] {X : Ω → Z}
  (hf : ∀ (i : ι), Measurable (f i ∘ X)) {b : ℝ} (hb : 0 ≤ b) (hf' : ∀ (i : ι) (z : Z), |f i z| ≤ b)
  (ω : (Fin n → Ω) × (Fin n → Ω)) (h_original_goal : |∑ σ, ⨆ i, |∑ k, ↑↑(σ k) * f i (X (ω.1 k))|| ≤ ↑n * b * 2 ^ n) :
  2 ^ n * (↑n * b) ≤ ↑n * b * 2 ^ n := sorry

Tactic state before:
case h
Ω : Type u
inst✝² : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
μ : Measure Ω
inst✝¹ : IsProbabilityMeasure μ
inst✝ : Countable ι
X : Ω → Z
hf : ∀ (i : ι), Measurable (f i ∘ X)
b : ℝ
hb : 0 ≤ b
hf' : ∀ (i : ι) (z : Z), |f i z| ≤ b
ω : (Fin n → Ω) × (Fin n → Ω)
⊢ |∑ σ, ⨆ i, |∑ k, ↑↑(σ k) * f i (X (ω.1 k))|| ≤ ↑n * b * 2 ^ n

Tactic:
apply le_trans (integrable_aux2_aux hb hf' _)

Tactic state after:
[case h
 Ω : Type u
 inst✝² : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 μ : Measure Ω
 inst✝¹ : IsProbabilityMeasure μ
 inst✝ : Countable ι
 X : Ω → Z
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 b : ℝ
 hb : 0 ≤ b
 hf' : ∀ (i : ι) (z : Z), |f i z| ≤ b
 ω : (Fin n → Ω) × (Fin n → Ω)
 ⊢ 2 ^ n * (↑n * b) ≤ ↑n * b * 2 ^ n]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_106.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} {μ : Measure Ω} [inst_1 : IsProbabilityMeasure μ] [inst_2 : Countable ι] {X : Ω → Z}
  (hf : ∀ (i : ι), Measurable (f i ∘ X)) {b : ℝ} (hb : 0 ≤ b) (hf' : ∀ (i : ι) (z : Z), |f i z| ≤ b)
  (h_original_goal : 2 ^ n * (↑n * b) ≤ ↑n * b * 2 ^ n) : 2 ^ n * (↑n * b) = ↑n * b * 2 ^ n := sorry

Tactic state before:
case h
Ω : Type u
inst✝² : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
μ : Measure Ω
inst✝¹ : IsProbabilityMeasure μ
inst✝ : Countable ι
X : Ω → Z
hf : ∀ (i : ι), Measurable (f i ∘ X)
b : ℝ
hb : 0 ≤ b
hf' : ∀ (i : ι) (z : Z), |f i z| ≤ b
ω : (Fin n → Ω) × (Fin n → Ω)
⊢ 2 ^ n * (↑n * b) ≤ ↑n * b * 2 ^ n

Tactic:
apply le_of_eq

Tactic state after:
[case h.hab
 Ω : Type u
 inst✝² : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 μ : Measure Ω
 inst✝¹ : IsProbabilityMeasure μ
 inst✝ : Countable ι
 X : Ω → Z
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 b : ℝ
 hb : 0 ≤ b
 hf' : ∀ (i : ι) (z : Z), |f i z| ≤ b
 ω : (Fin n → Ω) × (Fin n → Ω)
 ⊢ 2 ^ n * (↑n * b) = ↑n * b * 2 ^ n]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_107.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} {μ : Measure Ω} [inst_1 : IsProbabilityMeasure μ] {X : Ω → Z} [inst_3 : Countable ι]
  (hf : ∀ (i : ι), Measurable (f i ∘ X))
  (h_original_goal :
    Measurable fun ω => ⨆ i, |∫ (x : Fin n → Ω), ∑ k, (f i (X (ω k)) - f i (X (x k))) ∂Measure.pi fun x => μ|)
  (i : ι) :
  Measurable fun b => |∫ (x : Fin n → Ω), ∑ k, (f i (X (b k)) - f i (X (x k))) ∂Measure.pi fun x => μ| := sorry

Tactic state before:
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
μ : Measure Ω
inst✝ : IsProbabilityMeasure μ
X : Ω → Z
inst_3 : Countable ι
hf : ∀ (i : ι), Measurable (f i ∘ X)
⊢ Measurable fun ω => ⨆ i, |∫ (x : Fin n → Ω), ∑ k, (f i (X (ω k)) - f i (X (x k))) ∂Measure.pi fun x => μ|

Tactic:
apply Measurable.iSup

Tactic state after:
[case hf
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 μ : Measure Ω
 inst✝ : IsProbabilityMeasure μ
 X : Ω → Z
 inst_3 : Countable ι
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 ⊢ ∀ (i : ι), Measurable fun b => |∫ (x : Fin n → Ω), ∑ k, (f i (X (b k)) - f i (X (x k))) ∂Measure.pi fun x => μ|]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_108.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} {μ : Measure Ω} [inst_1 : IsProbabilityMeasure μ] {X : Ω → Z} [inst_3 : Countable ι]
  (hf : ∀ (i : ι), Measurable (f i ∘ X)) (i : ι)
  (h_original_goal :
    Measurable fun b => -∫ (x : Fin n → Ω), ∑ k, (f i (X (b k)) - f i (X (x k))) ∂Measure.pi fun x => μ) :
  Measurable fun x => ∫ (x_1 : Fin n → Ω), ∑ k, (f i (X (x k)) - f i (X (x_1 k))) ∂Measure.pi fun x => μ := sorry

Tactic state before:
case hf.left.hf.hf.hg
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
μ : Measure Ω
inst✝ : IsProbabilityMeasure μ
X : Ω → Z
inst_3 : Countable ι
hf : ∀ (i : ι), Measurable (f i ∘ X)
i : ι
⊢ Measurable fun b => -∫ (x : Fin n → Ω), ∑ k, (f i (X (b k)) - f i (X (x k))) ∂Measure.pi fun x => μ

Tactic:
apply Measurable.neg

Tactic state after:
[case hf.left.hf.hf.hg.hf
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 μ : Measure Ω
 inst✝ : IsProbabilityMeasure μ
 X : Ω → Z
 inst_3 : Countable ι
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 i : ι
 ⊢ Measurable fun x => ∫ (x_1 : Fin n → Ω), ∑ k, (f i (X (x k)) - f i (X (x_1 k))) ∂Measure.pi fun x => μ]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_109.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} {μ : Measure Ω} [inst_1 : IsProbabilityMeasure μ] {X : Ω → Z} [inst_3 : Countable ι]
  (hf : ∀ (i : ι), Measurable (f i ∘ X)) (i : ι)
  (h_original_goal :
    Measurable fun x => ∫ (x_1 : Fin n → Ω), ∑ k, (f i (X (x k)) - f i (X (x_1 k))) ∂Measure.pi fun x => μ) :
  StronglyMeasurable fun x =>
    ∫ (x_1 : Fin n → Ω), ∑ k, (f i (X (x k)) - f i (X (x_1 k))) ∂Measure.pi fun x => μ := sorry

Tactic state before:
case hf.left.hf.hf.hg.hf
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
μ : Measure Ω
inst✝ : IsProbabilityMeasure μ
X : Ω → Z
inst_3 : Countable ι
hf : ∀ (i : ι), Measurable (f i ∘ X)
i : ι
⊢ Measurable fun x => ∫ (x_1 : Fin n → Ω), ∑ k, (f i (X (x k)) - f i (X (x_1 k))) ∂Measure.pi fun x => μ

Tactic:
apply MeasureTheory.StronglyMeasurable.measurable

Tactic state after:
[case hf.left.hf.hf.hg.hf.hf
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 μ : Measure Ω
 inst✝ : IsProbabilityMeasure μ
 X : Ω → Z
 inst_3 : Countable ι
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 i : ι
 ⊢ StronglyMeasurable fun x => ∫ (x_1 : Fin n → Ω), ∑ k, (f i (X (x k)) - f i (X (x_1 k))) ∂Measure.pi fun x => μ]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_110.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} {μ : Measure Ω} [inst_1 : IsProbabilityMeasure μ] {X : Ω → Z} [inst_3 : Countable ι]
  (hf : ∀ (i : ι), Measurable (f i ∘ X)) (i : ι)
  (h_original_goal :
    StronglyMeasurable fun x => ∫ (x_1 : Fin n → Ω), ∑ k, (f i (X (x k)) - f i (X (x_1 k))) ∂Measure.pi fun x => μ) :
  StronglyMeasurable (Function.uncurry fun x y => ∑ k, (f i (X (y k)) - f i (X (x k)))) := sorry

Tactic state before:
case hf.left.hf.hf.hg.hf.hf
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
μ : Measure Ω
inst✝ : IsProbabilityMeasure μ
X : Ω → Z
inst_3 : Countable ι
hf : ∀ (i : ι), Measurable (f i ∘ X)
i : ι
⊢ StronglyMeasurable fun x => ∫ (x_1 : Fin n → Ω), ∑ k, (f i (X (x k)) - f i (X (x_1 k))) ∂Measure.pi fun x => μ

Tactic:
apply MeasureTheory.StronglyMeasurable.integral_prod_left

Tactic state after:
[case hf.left.hf.hf.hg.hf.hf.hf
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 μ : Measure Ω
 inst✝ : IsProbabilityMeasure μ
 X : Ω → Z
 inst_3 : Countable ι
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 i : ι
 ⊢ StronglyMeasurable (Function.uncurry fun x y => ∑ k, (f i (X (y k)) - f i (X (x k))))]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_111.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} {μ : Measure Ω} [inst_1 : IsProbabilityMeasure μ] {X : Ω → Z} [inst_3 : Countable ι]
  (hf : ∀ (i : ι), Measurable (f i ∘ X)) (i : ι)
  (h_original_goal : StronglyMeasurable (Function.uncurry fun x y => ∑ k, (f i (X (y k)) - f i (X (x k))))) :
  Measurable (Function.uncurry fun x y => ∑ k, (f i (X (y k)) - f i (X (x k)))) := sorry

Tactic state before:
case hf.left.hf.hf.hg.hf.hf.hf
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
μ : Measure Ω
inst✝ : IsProbabilityMeasure μ
X : Ω → Z
inst_3 : Countable ι
hf : ∀ (i : ι), Measurable (f i ∘ X)
i : ι
⊢ StronglyMeasurable (Function.uncurry fun x y => ∑ k, (f i (X (y k)) - f i (X (x k))))

Tactic:
apply Measurable.stronglyMeasurable

Tactic state after:
[case hf.left.hf.hf.hg.hf.hf.hf.hf
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 μ : Measure Ω
 inst✝ : IsProbabilityMeasure μ
 X : Ω → Z
 inst_3 : Countable ι
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 i : ι
 ⊢ Measurable (Function.uncurry fun x y => ∑ k, (f i (X (y k)) - f i (X (x k))))]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_112.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} {μ : Measure Ω} [inst_1 : IsProbabilityMeasure μ] {X : Ω → Z} [inst_3 : Countable ι]
  (hf : ∀ (i : ι), Measurable (f i ∘ X)) (i : ι) (i' : Fin n) (hi : i' ∈ Finset.univ)
  (h_original_goal : Measurable fun a => f i (X (a.2 i')) - f i (X (a.1 i'))) :
  Measurable fun a => f i (X (a.2 i')) := sorry

Tactic state before:
case hf.left.hf.hf.hg.hf.hf.hf.hf
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
μ : Measure Ω
inst✝ : IsProbabilityMeasure μ
X : Ω → Z
inst_3 : Countable ι
hf : ∀ (i : ι), Measurable (f i ∘ X)
i : ι
i' : Fin n
hi : i' ∈ Finset.univ
⊢ Measurable fun a => f i (X (a.2 i')) - f i (X (a.1 i'))

Tactic:
apply Measurable.sub

Tactic state after:
[case hf.left.hf.hf.hg.hf.hf.hf.hf.hf
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 μ : Measure Ω
 inst✝ : IsProbabilityMeasure μ
 X : Ω → Z
 inst_3 : Countable ι
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 i : ι
 i' : Fin n
 hi : i' ∈ Finset.univ
 ⊢ Measurable fun a => f i (X (a.2 i')),
 case hf.left.hf.hf.hg.hf.hf.hf.hf.hg
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 μ : Measure Ω
 inst✝ : IsProbabilityMeasure μ
 X : Ω → Z
 inst_3 : Countable ι
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 i : ι
 i' : Fin n
 hi : i' ∈ Finset.univ
 ⊢ Measurable fun a => f i (X (a.1 i'))]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_113.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} {μ : Measure Ω} [inst_1 : IsProbabilityMeasure μ] {X : Ω → Z} [inst_3 : Countable ι]
  (hf : ∀ (i : ι), Measurable (f i ∘ X)) (i : ι) (i' : Fin n) (hi : i' ∈ Finset.univ)
  (h_original_goal : Measurable fun a => f i (X (a.2 i')) - f i (X (a.1 i'))) :
  Measurable fun a => f i (X (a.1 i')) := sorry

Tactic state before:
case hf.left.hf.hf.hg.hf.hf.hf.hf
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
μ : Measure Ω
inst✝ : IsProbabilityMeasure μ
X : Ω → Z
inst_3 : Countable ι
hf : ∀ (i : ι), Measurable (f i ∘ X)
i : ι
i' : Fin n
hi : i' ∈ Finset.univ
⊢ Measurable fun a => f i (X (a.2 i')) - f i (X (a.1 i'))

Tactic:
apply Measurable.sub

Tactic state after:
[case hf.left.hf.hf.hg.hf.hf.hf.hf.hf
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 μ : Measure Ω
 inst✝ : IsProbabilityMeasure μ
 X : Ω → Z
 inst_3 : Countable ι
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 i : ι
 i' : Fin n
 hi : i' ∈ Finset.univ
 ⊢ Measurable fun a => f i (X (a.2 i')),
 case hf.left.hf.hf.hg.hf.hf.hf.hf.hg
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 μ : Measure Ω
 inst✝ : IsProbabilityMeasure μ
 X : Ω → Z
 inst_3 : Countable ι
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 i : ι
 i' : Fin n
 hi : i' ∈ Finset.univ
 ⊢ Measurable fun a => f i (X (a.1 i'))]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_114.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} {μ : Measure Ω} [inst_1 : IsProbabilityMeasure μ] {X : Ω → Z} [inst_3 : Countable ι]
  (hf : ∀ (i : ι), Measurable (f i ∘ X)) (i : ι) (i' : Fin n) (hi : i' ∈ Finset.univ) :
  Measurable fun a => f i (X (a.1 i')) := sorry

Tactic state before:
case hf.left.hf.hf.hg.hf.hf.hf.hf.hg
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
μ : Measure Ω
inst✝ : IsProbabilityMeasure μ
X : Ω → Z
inst_3 : Countable ι
hf : ∀ (i : ι), Measurable (f i ∘ X)
i : ι
i' : Fin n
hi : i' ∈ Finset.univ
⊢ Measurable fun a => f i (X (a.1 i'))

Tactic:
apply (hf i).comp measurable_fst.eval

Tactic state after:
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_115.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {ι : Type u_1}
  [inst_1 : AddCommMonoid Z] [inst_2 : MeasurableSpace Z] [inst_3 : MeasurableAdd₂ Z] {X : Ω → Z} (hX : Measurable X)
  (s : Finset ι) (h_original_goal : Measurable fun ω => ∑ k ∈ s, X (ω k)) (i : ι) :
  i ∈ s → Measurable fun a => X (a i) := sorry

Tactic state before:
Ω : Type u
inst✝³ : MeasurableSpace Ω
Z : Type w
ι : Type u_1
inst✝² : AddCommMonoid Z
inst✝¹ : MeasurableSpace Z
inst✝ : MeasurableAdd₂ Z
X : Ω → Z
hX : Measurable X
s : Finset ι
⊢ Measurable fun ω => ∑ k ∈ s, X (ω k)

Tactic:
apply s.measurable_sum

Tactic state after:
[Ω : Type u
 inst✝³ : MeasurableSpace Ω
 Z : Type w
 ι : Type u_1
 inst✝² : AddCommMonoid Z
 inst✝¹ : MeasurableSpace Z
 inst✝ : MeasurableAdd₂ Z
 X : Ω → Z
 hX : Measurable X
 s : Finset ι
 ⊢ ∀ i ∈ s, Measurable fun a => X (a i)]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_116.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {ι : Type u_1}
  [inst_1 : AddCommMonoid Z] [inst_2 : MeasurableSpace Z] [inst_3 : MeasurableAdd₂ Z] {X : Ω → Z} (hX : Measurable X)
  (s : Finset ι) (k : ι) (a : k ∈ s) : Measurable fun a => X (a k) := sorry

Tactic state before:
Ω : Type u
inst✝³ : MeasurableSpace Ω
Z : Type w
ι : Type u_1
inst✝² : AddCommMonoid Z
inst✝¹ : MeasurableSpace Z
inst✝ : MeasurableAdd₂ Z
X : Ω → Z
hX : Measurable X
s : Finset ι
k : ι
a✝ : k ∈ s
⊢ Measurable fun a => X (a k)

Tactic:
apply hX.comp (measurable_pi_apply k)

Tactic state after:
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_117.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} [inst_1 : Countable ι] {X : Ω → Z} (hf : ∀ (i : ι), Measurable (f i ∘ X))
  (h_original_goal :
    Measurable fun ω =>
      (↑(Fintype.card (Signs n)))⁻¹ * ∑ σ, ⨆ i, |∑ k, ↑↑(σ k) * (f i (X (ω k).1) - f i (X (ω k).2))|) :
  Measurable fun a => ∑ σ, ⨆ i, |∑ k, ↑↑(σ k) * (f i (X (a k).1) - f i (X (a k).2))| := sorry

Tactic state before:
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
inst✝ : Countable ι
X : Ω → Z
hf : ∀ (i : ι), Measurable (f i ∘ X)
⊢ Measurable fun ω => (↑(Fintype.card (Signs n)))⁻¹ * ∑ σ, ⨆ i, |∑ k, ↑↑(σ k) * (f i (X (ω k).1) - f i (X (ω k).2))|

Tactic:
apply Measurable.mul measurable_const

Tactic state after:
[Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 inst✝ : Countable ι
 X : Ω → Z
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 ⊢ Measurable fun a => ∑ σ, ⨆ i, |∑ k, ↑↑(σ k) * (f i (X (a k).1) - f i (X (a k).2))|]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_118.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} [inst_1 : Countable ι] {X : Ω → Z} (hf : ∀ (i : ι), Measurable (f i ∘ X))
  (h_original_goal : Measurable fun a => ∑ σ, ⨆ i, |∑ k, ↑↑(σ k) * (f i (X (a k).1) - f i (X (a k).2))|) (i : Signs n) :
  i ∈ Finset.univ → Measurable fun a => ⨆ i_1, |∑ k, ↑↑(i k) * (f i_1 (X (a k).1) - f i_1 (X (a k).2))| := sorry

Tactic state before:
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
inst✝ : Countable ι
X : Ω → Z
hf : ∀ (i : ι), Measurable (f i ∘ X)
⊢ Measurable fun a => ∑ σ, ⨆ i, |∑ k, ↑↑(σ k) * (f i (X (a k).1) - f i (X (a k).2))|

Tactic:
apply Finset.univ.measurable_sum

Tactic state after:
[Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 inst✝ : Countable ι
 X : Ω → Z
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 ⊢ ∀ i ∈ Finset.univ, Measurable fun a => ⨆ i_1, |∑ k, ↑↑(i k) * (f i_1 (X (a k).1) - f i_1 (X (a k).2))|]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_119.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} [inst_1 : Countable ι] {X : Ω → Z} (hf : ∀ (i : ι), Measurable (f i ∘ X)) (σ : Signs n)
  (a : σ ∈ Finset.univ)
  (h_original_goal : Measurable fun a => ⨆ i, |∑ k, ↑↑(σ k) * (f i (X (a k).1) - f i (X (a k).2))|) (i : ι) :
  Measurable fun b => |∑ k, ↑↑(σ k) * (f i (X (b k).1) - f i (X (b k).2))| := sorry

Tactic state before:
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
inst✝ : Countable ι
X : Ω → Z
hf : ∀ (i : ι), Measurable (f i ∘ X)
σ : Signs n
a✝ : σ ∈ Finset.univ
⊢ Measurable fun a => ⨆ i, |∑ k, ↑↑(σ k) * (f i (X (a k).1) - f i (X (a k).2))|

Tactic:
apply Measurable.iSup

Tactic state after:
[case hf
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 inst✝ : Countable ι
 X : Ω → Z
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 σ : Signs n
 a✝ : σ ∈ Finset.univ
 ⊢ ∀ (i : ι), Measurable fun b => |∑ k, ↑↑(σ k) * (f i (X (b k).1) - f i (X (b k).2))|]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_120.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} [inst_1 : Countable ι] {X : Ω → Z} (hf : ∀ (i : ι), Measurable (f i ∘ X)) (σ : Signs n)
  (a : σ ∈ Finset.univ) (i : ι)
  (h_original_goal : Measurable fun b => |∑ k, ↑↑(σ k) * (f i (X (b k).1) - f i (X (b k).2))|) :
  Measurable fun x => ∑ k, ↑↑(σ k) * (f i (X (x k).1) - f i (X (x k).2)) := sorry

Tactic state before:
case hf
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
inst✝ : Countable ι
X : Ω → Z
hf : ∀ (i : ι), Measurable (f i ∘ X)
σ : Signs n
a✝ : σ ∈ Finset.univ
i : ι
⊢ Measurable fun b => |∑ k, ↑↑(σ k) * (f i (X (b k).1) - f i (X (b k).2))|

Tactic:
apply Measurable.abs

Tactic state after:
[case hf.hf
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 inst✝ : Countable ι
 X : Ω → Z
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 σ : Signs n
 a✝ : σ ∈ Finset.univ
 i : ι
 ⊢ Measurable fun x => ∑ k, ↑↑(σ k) * (f i (X (x k).1) - f i (X (x k).2))]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_121.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} [inst_1 : Countable ι] {X : Ω → Z} (hf : ∀ (i : ι), Measurable (f i ∘ X)) (σ : Signs n)
  (a : σ ∈ Finset.univ) (i : ι) (k : Fin n) (a_1 : k ∈ Finset.univ)
  (h_original_goal : Measurable fun a => ↑↑(σ k) * (f i (X (a k).1) - f i (X (a k).2))) :
  Measurable fun a => f i (X (a k).1) - f i (X (a k).2) := sorry

Tactic state before:
case hf.hf
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
inst✝ : Countable ι
X : Ω → Z
hf : ∀ (i : ι), Measurable (f i ∘ X)
σ : Signs n
a✝¹ : σ ∈ Finset.univ
i : ι
k : Fin n
a✝ : k ∈ Finset.univ
⊢ Measurable fun a => ↑↑(σ k) * (f i (X (a k).1) - f i (X (a k).2))

Tactic:
apply measurable_const.mul

Tactic state after:
[case hf.hf
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 inst✝ : Countable ι
 X : Ω → Z
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 σ : Signs n
 a✝¹ : σ ∈ Finset.univ
 i : ι
 k : Fin n
 a✝ : k ∈ Finset.univ
 ⊢ Measurable fun a => f i (X (a k).1) - f i (X (a k).2)]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_122.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} [inst_1 : Countable ι] {X : Ω → Z} (hf : ∀ (i : ι), Measurable (f i ∘ X)) (σ : Signs n)
  (a : σ ∈ Finset.univ) (i : ι) (k : Fin n) (a_1 : k ∈ Finset.univ)
  (h_original_goal : Measurable fun a => f i (X (a k).1) - f i (X (a k).2)) :
  Measurable fun a => f i (X (a k).1) := sorry

Tactic state before:
case hf.hf
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
inst✝ : Countable ι
X : Ω → Z
hf : ∀ (i : ι), Measurable (f i ∘ X)
σ : Signs n
a✝¹ : σ ∈ Finset.univ
i : ι
k : Fin n
a✝ : k ∈ Finset.univ
⊢ Measurable fun a => f i (X (a k).1) - f i (X (a k).2)

Tactic:
apply Measurable.sub

Tactic state after:
[case hf.hf.hf
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 inst✝ : Countable ι
 X : Ω → Z
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 σ : Signs n
 a✝¹ : σ ∈ Finset.univ
 i : ι
 k : Fin n
 a✝ : k ∈ Finset.univ
 ⊢ Measurable fun a => f i (X (a k).1),
 case hf.hf.hg
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 inst✝ : Countable ι
 X : Ω → Z
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 σ : Signs n
 a✝¹ : σ ∈ Finset.univ
 i : ι
 k : Fin n
 a✝ : k ∈ Finset.univ
 ⊢ Measurable fun a => f i (X (a k).2)]
import Mathlib
import FoML


open MeasureTheory ProbabilityTheory Real

open scoped ENNReal

theorem extracted_formal_statement_123.{u_1, w, u} {Ω : Type u} [inst : MeasurableSpace Ω] {Z : Type w} {n : ℕ}
  {ι : Type u_1} {f : ι → Z → ℝ} [inst_1 : Countable ι] {X : Ω → Z} (hf : ∀ (i : ι), Measurable (f i ∘ X)) (σ : Signs n)
  (a : σ ∈ Finset.univ) (i : ι) (k : Fin n) (a_1 : k ∈ Finset.univ)
  (h_original_goal : Measurable fun a => f i (X (a k).1) - f i (X (a k).2)) :
  Measurable fun a => f i (X (a k).2) := sorry

Tactic state before:
case hf.hf
Ω : Type u
inst✝¹ : MeasurableSpace Ω
Z : Type w
n : ℕ
ι : Type u_1
f : ι → Z → ℝ
inst✝ : Countable ι
X : Ω → Z
hf : ∀ (i : ι), Measurable (f i ∘ X)
σ : Signs n
a✝¹ : σ ∈ Finset.univ
i : ι
k : Fin n
a✝ : k ∈ Finset.univ
⊢ Measurable fun a => f i (X (a k).1) - f i (X (a k).2)

Tactic:
apply Measurable.sub

Tactic state after:
[case hf.hf.hf
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 inst✝ : Countable ι
 X : Ω → Z
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 σ : Signs n
 a✝¹ : σ ∈ Finset.univ
 i : ι
 k : Fin n
 a✝ : k ∈ Finset.univ
 ⊢ Measurable fun a => f i (X (a k).1),
 case hf.hf.hg
 Ω : Type u
 inst✝¹ : MeasurableSpace Ω
 Z : Type w
 n : ℕ
 ι : Type u_1
 f : ι → Z → ℝ
 inst✝ : Countable ι
 X : Ω → Z
 hf : ∀ (i : ι), Measurable (f i ∘ X)
 σ : Signs n
 a✝¹ : σ ∈ Finset.univ
 i : ι
 k : Fin n
 a✝ : k ∈ Finset.univ
 ⊢ Measurable fun a => f i (X (a k).2)]