Theorem: BoxIntegral.HasIntegral.of_bRiemann_eq_false_of_forall_isLittleO
File: Mathlib/Analysis/BoxIntegral/Basic.lean

tactic: refine' ((l.hasBasis_toFilteriUnion_top _).tendsto_iff Metric.nhds_basis_closedBall).2 _
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
H₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        ε > 0 →
          ∃ δ,
            δ > 0 ∧
              ∀ (J : Box ι),
                J ≤ I →
                  ↑Box.Icc J ⊆ closedBall x δ →
                    x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
H₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        ε > 0 →
          ∃ δ,
            δ > 0 ∧
              ∀ (J : Box ι),
                J ≤ I →
                  ↑Box.Icc J ⊆ closedBall x δ →
                    (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                      (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
⊢ HasIntegral I l f vol (↑g I)

tactic: intro ε ε0
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
H₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        ε > 0 →
          ∃ δ,
            δ > 0 ∧
              ∀ (J : Box ι),
                J ≤ I →
                  ↑Box.Icc J ⊆ closedBall x δ →
                    x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
H₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        ε > 0 →
          ∃ δ,
            δ > 0 ∧
              ∀ (J : Box ι),
                J ≤ I →
                  ↑Box.Icc J ⊆ closedBall x δ →
                    (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                      (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
⊢ ∀ (ib : ℝ),
    0 < ib →
      ∃ ia,
        (∀ (c : ℝ≥0), RCond l (ia c)) ∧
          ∀ (x : TaggedPrepartition I),
            x ∈ {π | ∃ c, MemBaseSet l I c (ia c) π ∧ IsPartition π} → integralSum f vol x ∈ closedBall (↑g I) ib

tactic: simp only [← exists_prop, gt_iff_lt, Subtype.exists'] at H₁ H₂
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
H₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        ε > 0 →
          ∃ δ,
            δ > 0 ∧
              ∀ (J : Box ι),
                J ≤ I →
                  ↑Box.Icc J ⊆ closedBall x δ →
                    x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
H₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        ε > 0 →
          ∃ δ,
            δ > 0 ∧
              ∀ (J : Box ι),
                J ≤ I →
                  ↑Box.Icc J ⊆ closedBall x δ →
                    (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                      (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε : ℝ
ε0 : 0 < ε
⊢ ∃ ia,
    (∀ (c : ℝ≥0), RCond l (ia c)) ∧
      ∀ (x : TaggedPrepartition I),
        x ∈ {π | ∃ c, MemBaseSet l I c (ia c) π ∧ IsPartition π} → integralSum f vol x ∈ closedBall (↑g I) ε

tactic: choose! δ₁ Hδ₁ using H₁
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
H₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∃ x_1,
            ∀ (J : Box ι),
              J ≤ I →
                ↑Box.Icc J ⊆ closedBall x ↑x_1 →
                  x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
H₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∃ x_1,
            ∀ (J : Box ι),
              J ≤ I →
                ↑Box.Icc J ⊆ closedBall x ↑x_1 →
                  (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                    (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
⊢ ∃ ia,
    (∀ (c : ℝ≥0), RCond l (ia c)) ∧
      ∀ (x : TaggedPrepartition I),
        x ∈ {π | ∃ c, MemBaseSet l I c (ia c) π ∧ IsPartition π} → integralSum f vol x ∈ closedBall (↑g I) ε

tactic: choose! δ₂ Hδ₂ using H₂
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
H₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∃ x_1,
            ∀ (J : Box ι),
              J ≤ I →
                ↑Box.Icc J ⊆ closedBall x ↑x_1 →
                  (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                    (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
⊢ ∃ ia,
    (∀ (c : ℝ≥0), RCond l (ia c)) ∧
      ∀ (x : TaggedPrepartition I),
        x ∈ {π | ∃ c, MemBaseSet l I c (ia c) π ∧ IsPartition π} → integralSum f vol x ∈ closedBall (↑g I) ε

tactic: have ε0' := half_pos ε0
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
⊢ ∃ ia,
    (∀ (c : ℝ≥0), RCond l (ia c)) ∧
      ∀ (x : TaggedPrepartition I),
        x ∈ {π | ∃ c, MemBaseSet l I c (ia c) π ∧ IsPartition π} → integralSum f vol x ∈ closedBall (↑g I) ε

tactic: have H0 : 0 < (2 : ℝ) ^ Fintype.card ι := pow_pos zero_lt_two _
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
⊢ ∃ ia,
    (∀ (c : ℝ≥0), RCond l (ia c)) ∧
      ∀ (x : TaggedPrepartition I),
        x ∈ {π | ∃ c, MemBaseSet l I c (ia c) π ∧ IsPartition π} → integralSum f vol x ∈ closedBall (↑g I) ε

tactic: rcases hs.exists_pos_forall_sum_le (div_pos ε0' H0) with ⟨εs, hεs0, hεs⟩
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
⊢ ∃ ia,
    (∀ (c : ℝ≥0), RCond l (ia c)) ∧
      ∀ (x : TaggedPrepartition I),
        x ∈ {π | ∃ c, MemBaseSet l I c (ia c) π ∧ IsPartition π} → integralSum f vol x ∈ closedBall (↑g I) ε

tactic: simp only [le_div_iff' H0, mul_sum] at hεs
state_before: case intro.intro
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ i in t, εs i ≤ ε / 2 / 2 ^ Fintype.card ι
⊢ ∃ ia,
    (∀ (c : ℝ≥0), RCond l (ia c)) ∧
      ∀ (x : TaggedPrepartition I),
        x ∈ {π | ∃ c, MemBaseSet l I c (ia c) π ∧ IsPartition π} → integralSum f vol x ∈ closedBall (↑g I) ε

tactic: rcases exists_pos_mul_lt ε0' (B I) with ⟨ε', ε'0, hεI⟩
state_before: case intro.intro
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
⊢ ∃ ia,
    (∀ (c : ℝ≥0), RCond l (ia c)) ∧
      ∀ (x : TaggedPrepartition I),
        x ∈ {π | ∃ c, MemBaseSet l I c (ia c) π ∧ IsPartition π} → integralSum f vol x ∈ closedBall (↑g I) ε

tactic: set δ : ℝ≥0 → ℝⁿ → Ioi (0 : ℝ) := fun c x => if x ∈ s then δ₁ c x (εs x) else (δ₂ c) x ε'
state_before: case intro.intro.intro.intro
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
⊢ ∃ ia,
    (∀ (c : ℝ≥0), RCond l (ia c)) ∧
      ∀ (x : TaggedPrepartition I),
        x ∈ {π | ∃ c, MemBaseSet l I c (ia c) π ∧ IsPartition π} → integralSum f vol x ∈ closedBall (↑g I) ε

tactic: refine' ⟨δ, fun c => l.rCond_of_bRiemann_eq_false hl, _⟩
state_before: case intro.intro.intro.intro
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
⊢ ∃ ia,
    (∀ (c : ℝ≥0), RCond l (ia c)) ∧
      ∀ (x : TaggedPrepartition I),
        x ∈ {π | ∃ c, MemBaseSet l I c (ia c) π ∧ IsPartition π} → integralSum f vol x ∈ closedBall (↑g I) ε

tactic: simp only [Set.mem_iUnion, mem_inter_iff, mem_setOf_eq]
state_before: case intro.intro.intro.intro
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
⊢ ∀ (x : TaggedPrepartition I),
    x ∈ {π | ∃ c, MemBaseSet l I c (δ c) π ∧ IsPartition π} → integralSum f vol x ∈ closedBall (↑g I) ε

tactic: rintro π ⟨c, hπδ, hπp⟩
state_before: case intro.intro.intro.intro
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
⊢ ∀ (x : TaggedPrepartition I),
    (∃ c, MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') x ∧ IsPartition x) →
      integralSum f vol x ∈ closedBall (↑g I) ε

tactic: rw [← g.sum_partition_boxes le_rfl hπp, mem_closedBall, integralSum,
  ← sum_filter_add_sum_filter_not π.boxes fun J => π.tag J ∈ s,
  ← sum_filter_add_sum_filter_not π.boxes fun J => π.tag J ∈ s, ← add_halves ε]
state_before: case intro.intro.intro.intro.intro.intro
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
⊢ integralSum f vol π ∈ closedBall (↑g I) ε

tactic: refine' dist_add_add_le_of_le _ _
state_before: case intro.intro.intro.intro.intro.intro
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
⊢ dist
      (∑ x in Finset.filter (fun J => tag π J ∈ s) π.boxes, ↑(↑vol x) (f (tag π x)) +
        ∑ x in Finset.filter (fun x => ¬tag π x ∈ s) π.boxes, ↑(↑vol x) (f (tag π x)))
      (∑ x in Finset.filter (fun J => tag π J ∈ s) π.boxes, ↑g x +
        ∑ x in Finset.filter (fun x => ¬tag π x ∈ s) π.boxes, ↑g x) ≤
    ε / 2 + ε / 2

tactic: rcases s.eq_empty_or_nonempty with (rfl | hsne)
state_before: case intro.intro.intro.intro.intro.intro.refine'_1
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
⊢ dist (∑ x in Finset.filter (fun J => tag π J ∈ s) π.boxes, ↑(↑vol x) (f (tag π x)))
      (∑ x in Finset.filter (fun J => tag π J ∈ s) π.boxes, ↑g x) ≤
    ε / 2

tactic: specialize hlH hsne
state_before: case intro.intro.intro.intro.intro.intro.refine'_1.inr
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
⊢ dist (∑ x in Finset.filter (fun J => tag π J ∈ s) π.boxes, ↑(↑vol x) (f (tag π x)))
      (∑ x in Finset.filter (fun J => tag π J ∈ s) π.boxes, ↑g x) ≤
    ε / 2

tactic: have : ∀ J ∈ π.boxes.filter fun J => π.tag J ∈ s,
    dist (vol J (f <| π.tag J)) (g J) ≤ εs (π.tag J) := fun J hJ ↦ by
  rw [Finset.mem_filter] at hJ ; cases' hJ with hJ hJs
  refine' Hδ₁ c _ ⟨π.tag_mem_Icc _, hJs⟩ _ (hεs0 _) _ (π.le_of_mem' _ hJ) _
    (hπδ.2 hlH J hJ) fun hD => (Finset.le_sup hJ).trans (hπδ.3 hD)
  convert hπδ.1 J hJ using 3; exact (if_pos hJs).symm
state_before: case intro.intro.intro.intro.intro.intro.refine'_1.inr
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
⊢ dist (∑ x in Finset.filter (fun J => tag π J ∈ s) π.boxes, ↑(↑vol x) (f (tag π x)))
      (∑ x in Finset.filter (fun J => tag π J ∈ s) π.boxes, ↑g x) ≤
    ε / 2

tactic: refine' (dist_sum_sum_le_of_le _ this).trans _
state_before: case intro.intro.intro.intro.intro.intro.refine'_1.inr
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
this :
  ∀ (J : Box ι), J ∈ Finset.filter (fun J => tag π J ∈ s) π.boxes → dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ εs (tag π J)
⊢ dist (∑ x in Finset.filter (fun J => tag π J ∈ s) π.boxes, ↑(↑vol x) (f (tag π x)))
      (∑ x in Finset.filter (fun J => tag π J ∈ s) π.boxes, ↑g x) ≤
    ε / 2

tactic: rw [sum_comp]
state_before: case intro.intro.intro.intro.intro.intro.refine'_1.inr
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
this :
  ∀ (J : Box ι), J ∈ Finset.filter (fun J => tag π J ∈ s) π.boxes → dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ εs (tag π J)
⊢ ∑ b in Finset.filter (fun J => tag π J ∈ s) π.boxes, εs (tag π b) ≤ ε / 2

tactic: refine' (sum_le_sum _).trans (hεs _ _)
state_before: case intro.intro.intro.intro.intro.intro.refine'_1.inr
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
this :
  ∀ (J : Box ι), J ∈ Finset.filter (fun J => tag π J ∈ s) π.boxes → dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ εs (tag π J)
⊢ ∑ b in Finset.image (fun b => tag π b) (Finset.filter (fun J => tag π J ∈ s) π.boxes),
      card (Finset.filter (fun a => tag π a = b) (Finset.filter (fun J => tag π J ∈ s) π.boxes)) • εs b ≤
    ε / 2

tactic: simp [ε0'.le]
state_before: case intro.intro.intro.intro.intro.intro.refine'_1.inl
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
ε : ℝ
ε0 : 0 < ε
δ₁ δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
π : TaggedPrepartition I
c : ℝ≥0
hπp : IsPartition π
hs : Set.Countable ∅
hlH : Set.Nonempty ∅ → l.bHenstock = true
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ ∅ →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ ∅ →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ ∅ → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ ∅ then δ₁ c x (εs x) else δ₂ c x ε'
hπδ : MemBaseSet l I c (fun x => if x ∈ ∅ then δ₁ c x (εs x) else δ₂ c x ε') π
⊢ dist (∑ x in Finset.filter (fun J => tag π J ∈ ∅) π.boxes, ↑(↑vol x) (f (tag π x)))
      (∑ x in Finset.filter (fun J => tag π J ∈ ∅) π.boxes, ↑g x) ≤
    ε / 2

tactic: rw [Finset.mem_filter] at hJ
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J✝ : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
J : Box ι
hJ : J ∈ Finset.filter (fun J => tag π J ∈ s) π.boxes
⊢ dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ εs (tag π J)

tactic: cases' hJ with hJ hJs
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J✝ : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
J : Box ι
hJ : J ∈ π.boxes ∧ tag π J ∈ s
⊢ dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ εs (tag π J)

tactic: refine' Hδ₁ c _ ⟨π.tag_mem_Icc _, hJs⟩ _ (hεs0 _) _ (π.le_of_mem' _ hJ) _
  (hπδ.2 hlH J hJ) fun hD => (Finset.le_sup hJ).trans (hπδ.3 hD)
state_before: case intro
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J✝ : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
J : Box ι
hJ : J ∈ π.boxes
hJs : tag π J ∈ s
⊢ dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ εs (tag π J)

tactic: convert hπδ.1 J hJ using 3
state_before: case intro
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J✝ : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
J : Box ι
hJ : J ∈ π.boxes
hJs : tag π J ∈ s
⊢ ↑Box.Icc J ⊆ closedBall (tag π J) ↑(δ₁ c (tag π J) (εs (tag π J)))

tactic: exact (if_pos hJs).symm
state_before: case h.e'_4.h.e'_4.h.e'_3.h
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J✝ : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
J : Box ι
hJ : J ∈ π.boxes
hJs : tag π J ∈ s
e_2✝ : (fun a => 0 < a) = fun x => x ∈ Set.Ioi 0
⊢ δ₁ c (tag π J) (εs (tag π J)) = (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') (tag π J)

tactic: rintro b -
state_before: case intro.intro.intro.intro.intro.intro.refine'_1.inr.refine'_1
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
this :
  ∀ (J : Box ι), J ∈ Finset.filter (fun J => tag π J ∈ s) π.boxes → dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ εs (tag π J)
⊢ ∀ (i : ι → ℝ),
    i ∈ Finset.image (fun b => tag π b) (Finset.filter (fun J => tag π J ∈ s) π.boxes) →
      card (Finset.filter (fun a => tag π a = i) (Finset.filter (fun J => tag π J ∈ s) π.boxes)) • εs i ≤
        2 ^ Fintype.card ι * εs i

tactic: rw [← Nat.cast_two, ← Nat.cast_pow, ← nsmul_eq_mul]
state_before: case intro.intro.intro.intro.intro.intro.refine'_1.inr.refine'_1
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
this :
  ∀ (J : Box ι), J ∈ Finset.filter (fun J => tag π J ∈ s) π.boxes → dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ εs (tag π J)
b : ι → ℝ
⊢ card (Finset.filter (fun a => tag π a = b) (Finset.filter (fun J => tag π J ∈ s) π.boxes)) • εs b ≤
    2 ^ Fintype.card ι * εs b

tactic: refine' nsmul_le_nsmul (hεs0 _).le _
state_before: case intro.intro.intro.intro.intro.intro.refine'_1.inr.refine'_1
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
this :
  ∀ (J : Box ι), J ∈ Finset.filter (fun J => tag π J ∈ s) π.boxes → dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ εs (tag π J)
b : ι → ℝ
⊢ card (Finset.filter (fun a => tag π a = b) (Finset.filter (fun J => tag π J ∈ s) π.boxes)) • εs b ≤
    2 ^ Fintype.card ι • εs b

tactic: refine' (Finset.card_le_of_subset _).trans ((hπδ.isHenstock hlH).card_filter_tag_eq_le b)
state_before: case intro.intro.intro.intro.intro.intro.refine'_1.inr.refine'_1
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
this :
  ∀ (J : Box ι), J ∈ Finset.filter (fun J => tag π J ∈ s) π.boxes → dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ εs (tag π J)
b : ι → ℝ
⊢ card (Finset.filter (fun a => tag π a = b) (Finset.filter (fun J => tag π J ∈ s) π.boxes)) ≤ 2 ^ Fintype.card ι

tactic: exact filter_subset_filter _ (filter_subset _ _)
state_before: case intro.intro.intro.intro.intro.intro.refine'_1.inr.refine'_1
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
this :
  ∀ (J : Box ι), J ∈ Finset.filter (fun J => tag π J ∈ s) π.boxes → dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ εs (tag π J)
b : ι → ℝ
⊢ Finset.filter (fun a => tag π a = b) (Finset.filter (fun J => tag π J ∈ s) π.boxes) ⊆
    Finset.filter (fun J => tag π J = b) π.boxes

tactic: rw [Finset.coe_image, Set.image_subset_iff]
state_before: case intro.intro.intro.intro.intro.intro.refine'_1.inr.refine'_2
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
this :
  ∀ (J : Box ι), J ∈ Finset.filter (fun J => tag π J ∈ s) π.boxes → dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ εs (tag π J)
⊢ ↑(Finset.image (fun b => tag π b) (Finset.filter (fun J => tag π J ∈ s) π.boxes)) ⊆ s

tactic: exact fun J hJ => (Finset.mem_filter.1 hJ).2
state_before: case intro.intro.intro.intro.intro.intro.refine'_1.inr.refine'_2
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
hsne : Set.Nonempty s
hlH : l.bHenstock = true
this :
  ∀ (J : Box ι), J ∈ Finset.filter (fun J => tag π J ∈ s) π.boxes → dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ εs (tag π J)
⊢ ↑(Finset.filter (fun J => tag π J ∈ s) π.boxes) ⊆ (fun b => tag π b) ⁻¹' s

tactic: rw [Finset.mem_filter] at hJ
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J✝ : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
J : Box ι
hJ : J ∈ Finset.filter (fun x => ¬tag π x ∈ s) π.boxes
⊢ dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ ε' * ↑B J

tactic: cases' hJ with hJ hJs
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J✝ : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
J : Box ι
hJ : J ∈ π.boxes ∧ ¬tag π J ∈ s
⊢ dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ ε' * ↑B J

tactic: refine' Hδ₂ c _ ⟨π.tag_mem_Icc _, hJs⟩ _ ε'0 _ (π.le_of_mem' _ hJ) _ (fun hH => hπδ.2 hH J hJ)
  fun hD => (Finset.le_sup hJ).trans (hπδ.3 hD)
state_before: case intro
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J✝ : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
J : Box ι
hJ : J ∈ π.boxes
hJs : ¬tag π J ∈ s
⊢ dist (↑(↑vol J) (f (tag π J))) (↑g J) ≤ ε' * ↑B J

tactic: convert hπδ.1 J hJ using 3
state_before: case intro
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J✝ : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
J : Box ι
hJ : J ∈ π.boxes
hJs : ¬tag π J ∈ s
⊢ ↑Box.Icc J ⊆ closedBall (tag π J) ↑(δ₂ c (tag π J) ε')

tactic: exact (if_neg hJs).symm
state_before: case h.e'_4.h.e'_4.h.e'_3.h
ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J✝ : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
J : Box ι
hJ : J ∈ π.boxes
hJs : ¬tag π J ∈ s
e_2✝ : (fun a => 0 < a) = fun x => x ∈ Set.Ioi 0
⊢ δ₂ c (tag π J) ε' = (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') (tag π J)

tactic: rw [← mul_sum, B.sum_partition_boxes le_rfl hπp, mul_comm]
state_before: ι : Type u
E : Type v
F : Type w
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
I J : Box ι
π✝ : TaggedPrepartition I
inst✝ : Fintype ι
l : IntegrationParams
f g✝ : (ι → ℝ) → E
vol : ι →ᵇᵃ[⊤] E →L[ℝ] F
y y' : F
hl : l.bRiemann = false
B : ι →ᵇᵃ[↑I] ℝ
hB0 : ∀ (J : Box ι), 0 ≤ ↑B J
g : ι →ᵇᵃ[↑I] F
s : Set (ι → ℝ)
hs : Set.Countable s
hlH : Set.Nonempty s → l.bHenstock = true
ε : ℝ
ε0 : 0 < ε
δ₁ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₁ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I ∩ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₁ c x ε) →
                x ∈ ↑Box.Icc J → (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε
δ₂ : ℝ≥0 → (ι → ℝ) → ℝ → { a // 0 < a }
Hδ₂ :
  ∀ (c : ℝ≥0) (x : ι → ℝ),
    x ∈ ↑Box.Icc I \ s →
      ∀ (ε : ℝ),
        0 < ε →
          ∀ (J : Box ι),
            J ≤ I →
              ↑Box.Icc J ⊆ closedBall x ↑(δ₂ c x ε) →
                (l.bHenstock = true → x ∈ ↑Box.Icc J) →
                  (l.bDistortion = true → Box.distortion J ≤ c) → dist (↑(↑vol J) (f x)) (↑g J) ≤ ε * ↑B J
ε0' : 0 < ε / 2
H0 : 0 < 2 ^ Fintype.card ι
εs : (ι → ℝ) → ℝ
hεs0 : ∀ (i : ι → ℝ), 0 < εs i
hεs : ∀ (t : Finset (ι → ℝ)), ↑t ⊆ s → ∑ x in t, 2 ^ Fintype.card ι * εs x ≤ ε / 2
ε' : ℝ
ε'0 : 0 < ε'
hεI : ↑B I * ε' < ε / 2
δ : ℝ≥0 → (ι → ℝ) → ↑(Set.Ioi 0) := fun c x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε'
π : TaggedPrepartition I
c : ℝ≥0
hπδ : MemBaseSet l I c (fun x => if x ∈ s then δ₁ c x (εs x) else δ₂ c x ε') π
hπp : IsPartition π
⊢ ∑ J in π.boxes, ε' * ↑B J = ↑B I * ε'