analysis.box_integral.partition.filter ⟷ Mathlib.Analysis.BoxIntegral.Partition.Filter

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -408,7 +408,7 @@ theorem MemBaseSet.exists_common_compl (h₁ : l.MemBaseSet I c₁ r₁ π₁) (
         (l.bDistortion → π.distortion ≤ c₁) ∧ (l.bDistortion → π.distortion ≤ c₂) :=
   by
   wlog hc : c₁ ≤ c₂
-  · simpa [hU, and_comm'] using this h₂ h₁ hU.symm (le_of_not_le hc)
+  · simpa [hU, and_comm] using this h₂ h₁ hU.symm (le_of_not_le hc)
   by_cases hD : (l.bDistortion : Prop)
   · rcases h₁.4 hD with ⟨π, hπU, hπc⟩
     exact ⟨π, hπU, fun _ => hπc, fun _ => hπc.trans hc⟩

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

@@ -578,7 +578,7 @@ theorem tendsto_embedBox_toFilteriUnion_top (l : IntegrationParams) (h : I ≤ J
           (l.has_basis_to_filter_distortion_Union J _ _)).2
       fun r hr => _
   refine' ⟨r, hr, fun π hπ => _⟩
-  rw [mem_set_of_eq, prepartition.Union_top] at hπ 
+  rw [mem_set_of_eq, prepartition.Union_top] at hπ
   refine' ⟨⟨hπ.1.1, hπ.1.2, fun hD => le_trans (hπ.1.3 hD) (le_max_left _ _), fun hD => _⟩, _⟩
   · refine' ⟨_, π₀.Union_compl.trans _, le_max_right _ _⟩; congr 1
     exact (prepartition.Union_single h).trans hπ.2.symm
@@ -601,7 +601,7 @@ theorem exists_memBaseSet_le_iUnion_eq (l : IntegrationParams) (π₀ : Preparti
 theorem exists_memBaseSet_isPartition (l : IntegrationParams) (I : Box ι) (hc : I.distortion ≤ c)
     (r : (ι → ℝ) → Ioi (0 : ℝ)) : ∃ π, l.MemBaseSet I c r π ∧ π.IsPartition :=
   by
-  rw [← prepartition.distortion_top] at hc 
+  rw [← prepartition.distortion_top] at hc
   have hc' : (⊤ : prepartition I).compl.distortion ≤ c := by simp
   simpa [is_partition_iff_Union_eq] using l.exists_mem_base_set_le_Union_eq ⊤ hc hc' r
 #align box_integral.integration_params.exists_mem_base_set_is_partition BoxIntegral.IntegrationParams.exists_memBaseSet_isPartition

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

@@ -3,8 +3,8 @@ Copyright (c) 2021 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 -/
-import Mathbin.Analysis.BoxIntegral.Partition.SubboxInduction
-import Mathbin.Analysis.BoxIntegral.Partition.Split
+import Analysis.BoxIntegral.Partition.SubboxInduction
+import Analysis.BoxIntegral.Partition.Split
 
 #align_import analysis.box_integral.partition.filter from "leanprover-community/mathlib"@"0b7c740e25651db0ba63648fbae9f9d6f941e31b"
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module analysis.box_integral.partition.filter
-! leanprover-community/mathlib commit 0b7c740e25651db0ba63648fbae9f9d6f941e31b
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Analysis.BoxIntegral.Partition.SubboxInduction
 import Mathbin.Analysis.BoxIntegral.Partition.Split
 
+#align_import analysis.box_integral.partition.filter from "leanprover-community/mathlib"@"0b7c740e25651db0ba63648fbae9f9d6f941e31b"
+
 /-!
 # Filters used in box-based integrals
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

@@ -223,10 +223,12 @@ def equivProd : IntegrationParams ≃ Bool × Boolᵒᵈ × Boolᵒᵈ
 instance : PartialOrder IntegrationParams :=
   PartialOrder.lift equivProd equivProd.Injective
 
+#print BoxIntegral.IntegrationParams.isoProd /-
 /-- Auxiliary `order_iso` with a product type used to lift a `bounded_order` structure. -/
 def isoProd : IntegrationParams ≃o Bool × Boolᵒᵈ × Boolᵒᵈ :=
   ⟨equivProd, fun ⟨x, y, z⟩ => Iff.rfl⟩
 #align box_integral.integration_params.iso_prod BoxIntegral.IntegrationParams.isoProd
+-/
 
 instance : BoundedOrder IntegrationParams :=
   isoProd.symm.toGaloisInsertion.liftBoundedOrder
@@ -284,16 +286,23 @@ def GP : IntegrationParams :=
 #align box_integral.integration_params.GP BoxIntegral.IntegrationParams.GP
 -/
 
+#print BoxIntegral.IntegrationParams.henstock_le_riemann /-
 theorem henstock_le_riemann : Henstock ≤ Riemann := by decide
 #align box_integral.integration_params.Henstock_le_Riemann BoxIntegral.IntegrationParams.henstock_le_riemann
+-/
 
+#print BoxIntegral.IntegrationParams.henstock_le_mcShane /-
 theorem henstock_le_mcShane : Henstock ≤ McShane := by decide
 #align box_integral.integration_params.Henstock_le_McShane BoxIntegral.IntegrationParams.henstock_le_mcShane
+-/
 
+#print BoxIntegral.IntegrationParams.gp_le /-
 theorem gp_le : GP ≤ l :=
   bot_le
 #align box_integral.integration_params.GP_le BoxIntegral.IntegrationParams.gp_le
+-/
 
+#print BoxIntegral.IntegrationParams.MemBaseSet /-
 /-- The predicate corresponding to a base set of the filter defined by an
 `integration_params`. It says that
 
@@ -317,11 +326,14 @@ structure MemBaseSet (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) (r : (ι
   distortion_le : l.bDistortion → π.distortion ≤ c
   exists_compl : l.bDistortion → ∃ π' : Prepartition I, π'.iUnion = I \ π.iUnion ∧ π'.distortion ≤ c
 #align box_integral.integration_params.mem_base_set BoxIntegral.IntegrationParams.MemBaseSet
+-/
 
+#print BoxIntegral.IntegrationParams.RCond /-
 /-- A predicate saying that in case `l.bRiemann = tt`, the function `r` is a constant. -/
 def RCond {ι : Type _} (l : IntegrationParams) (r : (ι → ℝ) → Ioi (0 : ℝ)) : Prop :=
   l.bRiemann → ∀ x, r x = r 0
 #align box_integral.integration_params.r_cond BoxIntegral.IntegrationParams.RCond
+-/
 
 #print BoxIntegral.IntegrationParams.toFilterDistortion /-
 /-- A set `s : set (tagged_prepartition I)` belongs to `l.to_filter_distortion I c` if there exists
@@ -360,15 +372,20 @@ def toFilteriUnion (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I)
 #align box_integral.integration_params.to_filter_Union BoxIntegral.IntegrationParams.toFilteriUnion
 -/
 
+#print BoxIntegral.IntegrationParams.rCond_of_bRiemann_eq_false /-
 theorem rCond_of_bRiemann_eq_false {ι} (l : IntegrationParams) (hl : l.bRiemann = false)
     {r : (ι → ℝ) → Ioi (0 : ℝ)} : l.RCond r := by simp [r_cond, hl]
 #align box_integral.integration_params.r_cond_of_bRiemann_eq_ff BoxIntegral.IntegrationParams.rCond_of_bRiemann_eq_false
+-/
 
+#print BoxIntegral.IntegrationParams.toFilter_inf_iUnion_eq /-
 theorem toFilter_inf_iUnion_eq (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
     l.toFilter I ⊓ 𝓟 {π | π.iUnion = π₀.iUnion} = l.toFilteriUnion I π₀ :=
   (iSup_inf_principal _ _).symm
 #align box_integral.integration_params.to_filter_inf_Union_eq BoxIntegral.IntegrationParams.toFilter_inf_iUnion_eq
+-/
 
+#print BoxIntegral.IntegrationParams.MemBaseSet.mono' /-
 theorem MemBaseSet.mono' (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {π : TaggedPrepartition I}
     (hr : ∀ J ∈ π, r₁ (π.Tag J) ≤ r₂ (π.Tag J)) (hπ : l₁.MemBaseSet I c₁ r₁ π) :
     l₂.MemBaseSet I c₂ r₂ π :=
@@ -376,13 +393,17 @@ theorem MemBaseSet.mono' (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {
     (hπ.3 (le_iff_imp.1 h.2.2 hD)).trans hc, fun hD =>
     (hπ.4 (le_iff_imp.1 h.2.2 hD)).imp fun π hπ => ⟨hπ.1, hπ.2.trans hc⟩⟩
 #align box_integral.integration_params.mem_base_set.mono' BoxIntegral.IntegrationParams.MemBaseSet.mono'
+-/
 
+#print BoxIntegral.IntegrationParams.MemBaseSet.mono /-
 @[mono]
 theorem MemBaseSet.mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {π : TaggedPrepartition I}
     (hr : ∀ x ∈ I.Icc, r₁ x ≤ r₂ x) (hπ : l₁.MemBaseSet I c₁ r₁ π) : l₂.MemBaseSet I c₂ r₂ π :=
   hπ.mono' I h hc fun J hJ => hr _ <| π.tag_mem_Icc J
 #align box_integral.integration_params.mem_base_set.mono BoxIntegral.IntegrationParams.MemBaseSet.mono
+-/
 
+#print BoxIntegral.IntegrationParams.MemBaseSet.exists_common_compl /-
 theorem MemBaseSet.exists_common_compl (h₁ : l.MemBaseSet I c₁ r₁ π₁) (h₂ : l.MemBaseSet I c₂ r₂ π₂)
     (hU : π₁.iUnion = π₂.iUnion) :
     ∃ π : Prepartition I,
@@ -399,7 +420,9 @@ theorem MemBaseSet.exists_common_compl (h₁ : l.MemBaseSet I c₁ r₁ π₁) (
       ⟨π₁.to_prepartition.compl, π₁.to_prepartition.Union_compl, fun h => (hD h).elim, fun h =>
         (hD h).elim⟩
 #align box_integral.integration_params.mem_base_set.exists_common_compl BoxIntegral.IntegrationParams.MemBaseSet.exists_common_compl
+-/
 
+#print BoxIntegral.IntegrationParams.MemBaseSet.unionComplToSubordinate /-
 protected theorem MemBaseSet.unionComplToSubordinate (hπ₁ : l.MemBaseSet I c r₁ π₁)
     (hle : ∀ x ∈ I.Icc, r₂ x ≤ r₁ x) {π₂ : Prepartition I} (hU : π₂.iUnion = I \ π₁.iUnion)
     (hc : l.bDistortion → π₂.distortion ≤ c) :
@@ -409,7 +432,9 @@ protected theorem MemBaseSet.unionComplToSubordinate (hπ₁ : l.MemBaseSet I c
     (distortion_unionComplToSubordinate _ _ _ _).trans_le (max_le (hπ₁.3 h) (hc h)), fun _ =>
     ⟨⊥, by simp⟩⟩
 #align box_integral.integration_params.mem_base_set.union_compl_to_subordinate BoxIntegral.IntegrationParams.MemBaseSet.unionComplToSubordinate
+-/
 
+#print BoxIntegral.IntegrationParams.MemBaseSet.filter /-
 protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι → Prop) :
     l.MemBaseSet I c r (π.filterₓ p) :=
   by
@@ -431,7 +456,9 @@ protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι 
   · have : (π.filter fun J => ¬p J).distortion ≤ c := (distortion_filter_le _ _).trans (hπ.3 hD)
     simpa [hc]
 #align box_integral.integration_params.mem_base_set.filter BoxIntegral.IntegrationParams.MemBaseSet.filter
+-/
 
+#print BoxIntegral.IntegrationParams.biUnionTagged_memBaseSet /-
 theorem biUnionTagged_memBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepartition J}
     (h : ∀ J ∈ π, l.MemBaseSet J c r (πi J)) (hp : ∀ J ∈ π, (πi J).IsPartition)
     (hc : l.bDistortion → π.compl.distortion ≤ c) : l.MemBaseSet I c r (π.biUnionTagged πi) :=
@@ -445,16 +472,22 @@ theorem biUnionTagged_memBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepa
   · refine' ⟨_, _, hc hD⟩
     rw [π.Union_compl, ← π.Union_bUnion_partition hp]; rfl
 #align box_integral.integration_params.bUnion_tagged_mem_base_set BoxIntegral.IntegrationParams.biUnionTagged_memBaseSet
+-/
 
+#print BoxIntegral.IntegrationParams.RCond.mono /-
 @[mono]
 theorem RCond.mono {ι : Type _} {r : (ι → ℝ) → Ioi (0 : ℝ)} (h : l₁ ≤ l₂) (hr : l₂.RCond r) :
     l₁.RCond r := fun hR => hr (le_iff_imp.1 h.1 hR)
 #align box_integral.integration_params.r_cond.mono BoxIntegral.IntegrationParams.RCond.mono
+-/
 
+#print BoxIntegral.IntegrationParams.RCond.min /-
 theorem RCond.min {ι : Type _} {r₁ r₂ : (ι → ℝ) → Ioi (0 : ℝ)} (h₁ : l.RCond r₁) (h₂ : l.RCond r₂) :
     l.RCond fun x => min (r₁ x) (r₂ x) := fun hR x => congr_arg₂ min (h₁ hR x) (h₂ hR x)
 #align box_integral.integration_params.r_cond.min BoxIntegral.IntegrationParams.RCond.min
+-/
 
+#print BoxIntegral.IntegrationParams.toFilterDistortion_mono /-
 @[mono]
 theorem toFilterDistortion_mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) :
     l₁.toFilterDistortion I c₁ ≤ l₂.toFilterDistortion I c₂ :=
@@ -462,18 +495,23 @@ theorem toFilterDistortion_mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤
     iInf_mono' fun hr =>
       ⟨hr.mono h, principal_mono.2 fun _ => MemBaseSet.mono I h hc fun _ _ => le_rfl⟩
 #align box_integral.integration_params.to_filter_distortion_mono BoxIntegral.IntegrationParams.toFilterDistortion_mono
+-/
 
+#print BoxIntegral.IntegrationParams.toFilter_mono /-
 @[mono]
 theorem toFilter_mono (I : Box ι) {l₁ l₂ : IntegrationParams} (h : l₁ ≤ l₂) :
     l₁.toFilter I ≤ l₂.toFilter I :=
   iSup_mono fun c => toFilterDistortion_mono I h le_rfl
 #align box_integral.integration_params.to_filter_mono BoxIntegral.IntegrationParams.toFilter_mono
+-/
 
+#print BoxIntegral.IntegrationParams.toFilteriUnion_mono /-
 @[mono]
 theorem toFilteriUnion_mono (I : Box ι) {l₁ l₂ : IntegrationParams} (h : l₁ ≤ l₂)
     (π₀ : Prepartition I) : l₁.toFilteriUnion I π₀ ≤ l₂.toFilteriUnion I π₀ :=
   iSup_mono fun c => inf_le_inf_right _ <| toFilterDistortion_mono _ h le_rfl
 #align box_integral.integration_params.to_filter_Union_mono BoxIntegral.IntegrationParams.toFilteriUnion_mono
+-/
 
 #print BoxIntegral.IntegrationParams.toFilteriUnion_congr /-
 theorem toFilteriUnion_congr (I : Box ι) (l : IntegrationParams) {π₁ π₂ : Prepartition I}
@@ -482,6 +520,7 @@ theorem toFilteriUnion_congr (I : Box ι) (l : IntegrationParams) {π₁ π₂ :
 #align box_integral.integration_params.to_filter_Union_congr BoxIntegral.IntegrationParams.toFilteriUnion_congr
 -/
 
+#print BoxIntegral.IntegrationParams.hasBasis_toFilterDistortion /-
 theorem hasBasis_toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) :
     (l.toFilterDistortion I c).HasBasis l.RCond fun r => {π | l.MemBaseSet I c r π} :=
   hasBasis_biInf_principal'
@@ -490,14 +529,18 @@ theorem hasBasis_toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : 
         fun _ => MemBaseSet.mono _ le_rfl le_rfl fun x hx => min_le_right _ _⟩)
     ⟨fun _ => ⟨1, zero_lt_one⟩, fun _ _ => rfl⟩
 #align box_integral.integration_params.has_basis_to_filter_distortion BoxIntegral.IntegrationParams.hasBasis_toFilterDistortion
+-/
 
+#print BoxIntegral.IntegrationParams.hasBasis_toFilterDistortioniUnion /-
 theorem hasBasis_toFilterDistortioniUnion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0)
     (π₀ : Prepartition I) :
     (l.toFilterDistortioniUnion I c π₀).HasBasis l.RCond fun r =>
       {π | l.MemBaseSet I c r π ∧ π.iUnion = π₀.iUnion} :=
   (l.hasBasis_toFilterDistortion I c).inf_principal _
 #align box_integral.integration_params.has_basis_to_filter_distortion_Union BoxIntegral.IntegrationParams.hasBasis_toFilterDistortioniUnion
+-/
 
+#print BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion /-
 theorem hasBasis_toFilteriUnion (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
     (l.toFilteriUnion I π₀).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
       fun r => {π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.iUnion = π₀.iUnion} :=
@@ -505,7 +548,9 @@ theorem hasBasis_toFilteriUnion (l : IntegrationParams) (I : Box ι) (π₀ : Pr
   have := fun c => l.hasBasis_toFilterDistortioniUnion I c π₀
   simpa only [set_of_and, set_of_exists] using has_basis_supr this
 #align box_integral.integration_params.has_basis_to_filter_Union BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion
+-/
 
+#print BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion_top /-
 theorem hasBasis_toFilteriUnion_top (l : IntegrationParams) (I : Box ι) :
     (l.toFilteriUnion I ⊤).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
       fun r => {π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.IsPartition} :=
@@ -513,12 +558,15 @@ theorem hasBasis_toFilteriUnion_top (l : IntegrationParams) (I : Box ι) :
   simpa only [tagged_prepartition.is_partition_iff_Union_eq, prepartition.Union_top] using
     l.has_basis_to_filter_Union I ⊤
 #align box_integral.integration_params.has_basis_to_filter_Union_top BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion_top
+-/
 
+#print BoxIntegral.IntegrationParams.hasBasis_toFilter /-
 theorem hasBasis_toFilter (l : IntegrationParams) (I : Box ι) :
     (l.toFilter I).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c)) fun r =>
       {π | ∃ c, l.MemBaseSet I c (r c) π} :=
   by simpa only [set_of_exists] using has_basis_supr (l.has_basis_to_filter_distortion I)
 #align box_integral.integration_params.has_basis_to_filter BoxIntegral.IntegrationParams.hasBasis_toFilter
+-/
 
 #print BoxIntegral.IntegrationParams.tendsto_embedBox_toFilteriUnion_top /-
 theorem tendsto_embedBox_toFilteriUnion_top (l : IntegrationParams) (h : I ≤ J) :
@@ -541,6 +589,7 @@ theorem tendsto_embedBox_toFilteriUnion_top (l : IntegrationParams) (h : I ≤ J
 #align box_integral.integration_params.tendsto_embed_box_to_filter_Union_top BoxIntegral.IntegrationParams.tendsto_embedBox_toFilteriUnion_top
 -/
 
+#print BoxIntegral.IntegrationParams.exists_memBaseSet_le_iUnion_eq /-
 theorem exists_memBaseSet_le_iUnion_eq (l : IntegrationParams) (π₀ : Prepartition I)
     (hc₁ : π₀.distortion ≤ c) (hc₂ : π₀.compl.distortion ≤ c) (r : (ι → ℝ) → Ioi (0 : ℝ)) :
     ∃ π, l.MemBaseSet I c r π ∧ π.toPrepartition ≤ π₀ ∧ π.iUnion = π₀.iUnion :=
@@ -549,7 +598,9 @@ theorem exists_memBaseSet_le_iUnion_eq (l : IntegrationParams) (π₀ : Preparti
   refine' ⟨π, ⟨hr, fun _ => hH, fun _ => hd.trans_le hc₁, fun hD => ⟨π₀.compl, _, hc₂⟩⟩, ⟨hle, hU⟩⟩
   exact prepartition.compl_congr hU ▸ π.to_prepartition.Union_compl
 #align box_integral.integration_params.exists_mem_base_set_le_Union_eq BoxIntegral.IntegrationParams.exists_memBaseSet_le_iUnion_eq
+-/
 
+#print BoxIntegral.IntegrationParams.exists_memBaseSet_isPartition /-
 theorem exists_memBaseSet_isPartition (l : IntegrationParams) (I : Box ι) (hc : I.distortion ≤ c)
     (r : (ι → ℝ) → Ioi (0 : ℝ)) : ∃ π, l.MemBaseSet I c r π ∧ π.IsPartition :=
   by
@@ -557,6 +608,7 @@ theorem exists_memBaseSet_isPartition (l : IntegrationParams) (I : Box ι) (hc :
   have hc' : (⊤ : prepartition I).compl.distortion ≤ c := by simp
   simpa [is_partition_iff_Union_eq] using l.exists_mem_base_set_le_Union_eq ⊤ hc hc' r
 #align box_integral.integration_params.exists_mem_base_set_is_partition BoxIntegral.IntegrationParams.exists_memBaseSet_isPartition
+-/
 
 #print BoxIntegral.IntegrationParams.toFilterDistortioniUnion_neBot /-
 theorem toFilterDistortioniUnion_neBot (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I)

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

@@ -329,7 +329,7 @@ a function `r : ℝⁿ → (0, ∞)` (or a constant `r` if `l.bRiemann = tt`) su
 prepartition `π` such that `l.mem_base_set I c r π`. -/
 def toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) :
     Filter (TaggedPrepartition I) :=
-  ⨅ (r : (ι → ℝ) → Ioi (0 : ℝ)) (hr : l.RCond r), 𝓟 { π | l.MemBaseSet I c r π }
+  ⨅ (r : (ι → ℝ) → Ioi (0 : ℝ)) (hr : l.RCond r), 𝓟 {π | l.MemBaseSet I c r π}
 #align box_integral.integration_params.to_filter_distortion BoxIntegral.IntegrationParams.toFilterDistortion
 -/
 
@@ -347,7 +347,7 @@ def toFilter (l : IntegrationParams) (I : Box ι) : Filter (TaggedPrepartition I
 there exists a function `r : ℝⁿ → (0, ∞)` (or a constant `r` if `l.bRiemann = tt`) such that `s`
 contains each prepartition `π` such that `l.mem_base_set I c r π` and `π.Union = π₀.Union`. -/
 def toFilterDistortioniUnion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) (π₀ : Prepartition I) :=
-  l.toFilterDistortion I c ⊓ 𝓟 { π | π.iUnion = π₀.iUnion }
+  l.toFilterDistortion I c ⊓ 𝓟 {π | π.iUnion = π₀.iUnion}
 #align box_integral.integration_params.to_filter_distortion_Union BoxIntegral.IntegrationParams.toFilterDistortioniUnion
 -/
 
@@ -365,7 +365,7 @@ theorem rCond_of_bRiemann_eq_false {ι} (l : IntegrationParams) (hl : l.bRiemann
 #align box_integral.integration_params.r_cond_of_bRiemann_eq_ff BoxIntegral.IntegrationParams.rCond_of_bRiemann_eq_false
 
 theorem toFilter_inf_iUnion_eq (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
-    l.toFilter I ⊓ 𝓟 { π | π.iUnion = π₀.iUnion } = l.toFilteriUnion I π₀ :=
+    l.toFilter I ⊓ 𝓟 {π | π.iUnion = π₀.iUnion} = l.toFilteriUnion I π₀ :=
   (iSup_inf_principal _ _).symm
 #align box_integral.integration_params.to_filter_inf_Union_eq BoxIntegral.IntegrationParams.toFilter_inf_iUnion_eq
 
@@ -483,7 +483,7 @@ theorem toFilteriUnion_congr (I : Box ι) (l : IntegrationParams) {π₁ π₂ :
 -/
 
 theorem hasBasis_toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) :
-    (l.toFilterDistortion I c).HasBasis l.RCond fun r => { π | l.MemBaseSet I c r π } :=
+    (l.toFilterDistortion I c).HasBasis l.RCond fun r => {π | l.MemBaseSet I c r π} :=
   hasBasis_biInf_principal'
     (fun r₁ hr₁ r₂ hr₂ =>
       ⟨_, hr₁.min hr₂, fun _ => MemBaseSet.mono _ le_rfl le_rfl fun x hx => min_le_left _ _,
@@ -494,13 +494,13 @@ theorem hasBasis_toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : 
 theorem hasBasis_toFilterDistortioniUnion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0)
     (π₀ : Prepartition I) :
     (l.toFilterDistortioniUnion I c π₀).HasBasis l.RCond fun r =>
-      { π | l.MemBaseSet I c r π ∧ π.iUnion = π₀.iUnion } :=
+      {π | l.MemBaseSet I c r π ∧ π.iUnion = π₀.iUnion} :=
   (l.hasBasis_toFilterDistortion I c).inf_principal _
 #align box_integral.integration_params.has_basis_to_filter_distortion_Union BoxIntegral.IntegrationParams.hasBasis_toFilterDistortioniUnion
 
 theorem hasBasis_toFilteriUnion (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
     (l.toFilteriUnion I π₀).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
-      fun r => { π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.iUnion = π₀.iUnion } :=
+      fun r => {π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.iUnion = π₀.iUnion} :=
   by
   have := fun c => l.hasBasis_toFilterDistortioniUnion I c π₀
   simpa only [set_of_and, set_of_exists] using has_basis_supr this
@@ -508,7 +508,7 @@ theorem hasBasis_toFilteriUnion (l : IntegrationParams) (I : Box ι) (π₀ : Pr
 
 theorem hasBasis_toFilteriUnion_top (l : IntegrationParams) (I : Box ι) :
     (l.toFilteriUnion I ⊤).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
-      fun r => { π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.IsPartition } :=
+      fun r => {π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.IsPartition} :=
   by
   simpa only [tagged_prepartition.is_partition_iff_Union_eq, prepartition.Union_top] using
     l.has_basis_to_filter_Union I ⊤
@@ -516,7 +516,7 @@ theorem hasBasis_toFilteriUnion_top (l : IntegrationParams) (I : Box ι) :
 
 theorem hasBasis_toFilter (l : IntegrationParams) (I : Box ι) :
     (l.toFilter I).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c)) fun r =>
-      { π | ∃ c, l.MemBaseSet I c (r c) π } :=
+      {π | ∃ c, l.MemBaseSet I c (r c) π} :=
   by simpa only [set_of_exists] using has_basis_supr (l.has_basis_to_filter_distortion I)
 #align box_integral.integration_params.has_basis_to_filter BoxIntegral.IntegrationParams.hasBasis_toFilter
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/cca40788df1b8755d5baf17ab2f27dacc2e17acb

@@ -311,7 +311,7 @@ It is also automatically satisfied for any `c > 1`, see TODO section of the modu
 details. -/
 @[protect_proj]
 structure MemBaseSet (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) (r : (ι → ℝ) → Ioi (0 : ℝ))
-  (π : TaggedPrepartition I) : Prop where
+    (π : TaggedPrepartition I) : Prop where
   IsSubordinate : π.IsSubordinate r
   IsHenstock : l.bHenstock → π.IsHenstock
   distortion_le : l.bDistortion → π.distortion ≤ c
@@ -425,9 +425,9 @@ protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι 
     have : (π.filter p).iUnion ⊆ π.Union := bUnion_subset_bUnion_left (Finset.filter_subset _ _)
     ext x; fconstructor
     · rintro (⟨hxI, hxπ⟩ | ⟨hxπ, hxp⟩)
-      exacts[⟨hxI, mt (@this x) hxπ⟩, ⟨π.Union_subset hxπ, hxp⟩]
+      exacts [⟨hxI, mt (@this x) hxπ⟩, ⟨π.Union_subset hxπ, hxp⟩]
     · rintro ⟨hxI, hxp⟩; by_cases hxπ : x ∈ π.Union
-      exacts[Or.inr ⟨hxπ, hxp⟩, Or.inl ⟨hxI, hxπ⟩]
+      exacts [Or.inr ⟨hxπ, hxp⟩, Or.inl ⟨hxI, hxπ⟩]
   · have : (π.filter fun J => ¬p J).distortion ≤ c := (distortion_filter_le _ _).trans (hπ.3 hD)
     simpa [hc]
 #align box_integral.integration_params.mem_base_set.filter BoxIntegral.IntegrationParams.MemBaseSet.filter
@@ -533,7 +533,7 @@ theorem tendsto_embedBox_toFilteriUnion_top (l : IntegrationParams) (h : I ≤ J
           (l.has_basis_to_filter_distortion_Union J _ _)).2
       fun r hr => _
   refine' ⟨r, hr, fun π hπ => _⟩
-  rw [mem_set_of_eq, prepartition.Union_top] at hπ
+  rw [mem_set_of_eq, prepartition.Union_top] at hπ 
   refine' ⟨⟨hπ.1.1, hπ.1.2, fun hD => le_trans (hπ.1.3 hD) (le_max_left _ _), fun hD => _⟩, _⟩
   · refine' ⟨_, π₀.Union_compl.trans _, le_max_right _ _⟩; congr 1
     exact (prepartition.Union_single h).trans hπ.2.symm
@@ -553,7 +553,7 @@ theorem exists_memBaseSet_le_iUnion_eq (l : IntegrationParams) (π₀ : Preparti
 theorem exists_memBaseSet_isPartition (l : IntegrationParams) (I : Box ι) (hc : I.distortion ≤ c)
     (r : (ι → ℝ) → Ioi (0 : ℝ)) : ∃ π, l.MemBaseSet I c r π ∧ π.IsPartition :=
   by
-  rw [← prepartition.distortion_top] at hc
+  rw [← prepartition.distortion_top] at hc 
   have hc' : (⊤ : prepartition I).compl.distortion ≤ c := by simp
   simpa [is_partition_iff_Union_eq] using l.exists_mem_base_set_le_Union_eq ⊤ hc hc' r
 #align box_integral.integration_params.exists_mem_base_set_is_partition BoxIntegral.IntegrationParams.exists_memBaseSet_isPartition

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -172,7 +172,7 @@ integral, rectangular box, partition, filter
 
 open Set Function Filter Metric Finset Bool
 
-open Classical Topology Filter NNReal
+open scoped Classical Topology Filter NNReal
 
 noncomputable section
 
@@ -558,12 +558,14 @@ theorem exists_memBaseSet_isPartition (l : IntegrationParams) (I : Box ι) (hc :
   simpa [is_partition_iff_Union_eq] using l.exists_mem_base_set_le_Union_eq ⊤ hc hc' r
 #align box_integral.integration_params.exists_mem_base_set_is_partition BoxIntegral.IntegrationParams.exists_memBaseSet_isPartition
 
+#print BoxIntegral.IntegrationParams.toFilterDistortioniUnion_neBot /-
 theorem toFilterDistortioniUnion_neBot (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I)
     (hc₁ : π₀.distortion ≤ c) (hc₂ : π₀.compl.distortion ≤ c) :
     (l.toFilterDistortioniUnion I c π₀).ne_bot :=
   ((l.hasBasis_toFilterDistortion I _).inf_principal _).neBot_iff.2 fun r hr =>
     (l.exists_memBaseSet_le_iUnion_eq π₀ hc₁ hc₂ r).imp fun π hπ => ⟨hπ.1, hπ.2.2⟩
 #align box_integral.integration_params.to_filter_distortion_Union_ne_bot BoxIntegral.IntegrationParams.toFilterDistortioniUnion_neBot
+-/
 
 #print BoxIntegral.IntegrationParams.toFilterDistortioniUnion_neBot' /-
 instance toFilterDistortioniUnion_neBot' (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -223,12 +223,6 @@ def equivProd : IntegrationParams ≃ Bool × Boolᵒᵈ × Boolᵒᵈ
 instance : PartialOrder IntegrationParams :=
   PartialOrder.lift equivProd equivProd.Injective
 
-/- warning: box_integral.integration_params.iso_prod -> BoxIntegral.IntegrationParams.isoProd is a dubious translation:
-lean 3 declaration is
-  OrderIso.{0, 0} BoxIntegral.IntegrationParams (Prod.{0, 0} Bool (Prod.{0, 0} (OrderDual.{0} Bool) (OrderDual.{0} Bool))) (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) (Prod.hasLe.{0, 0} Bool (Prod.{0, 0} (OrderDual.{0} Bool) (OrderDual.{0} Bool)) (Preorder.toHasLe.{0} Bool (PartialOrder.toPreorder.{0} Bool (SemilatticeInf.toPartialOrder.{0} Bool (Lattice.toSemilatticeInf.{0} Bool (GeneralizedCoheytingAlgebra.toLattice.{0} Bool (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{0} Bool (BooleanAlgebra.toGeneralizedBooleanAlgebra.{0} Bool Bool.booleanAlgebra))))))) (Prod.hasLe.{0, 0} (OrderDual.{0} Bool) (OrderDual.{0} Bool) (OrderDual.hasLe.{0} Bool (Preorder.toHasLe.{0} Bool (PartialOrder.toPreorder.{0} Bool (SemilatticeInf.toPartialOrder.{0} Bool (Lattice.toSemilatticeInf.{0} Bool (GeneralizedCoheytingAlgebra.toLattice.{0} Bool (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{0} Bool (BooleanAlgebra.toGeneralizedBooleanAlgebra.{0} Bool Bool.booleanAlgebra)))))))) (OrderDual.hasLe.{0} Bool (Preorder.toHasLe.{0} Bool (PartialOrder.toPreorder.{0} Bool (SemilatticeInf.toPartialOrder.{0} Bool (Lattice.toSemilatticeInf.{0} Bool (GeneralizedCoheytingAlgebra.toLattice.{0} Bool (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{0} Bool (BooleanAlgebra.toGeneralizedBooleanAlgebra.{0} Bool Bool.booleanAlgebra))))))))))
-but is expected to have type
-  OrderIso.{0, 0} BoxIntegral.IntegrationParams (Prod.{0, 0} Bool (Prod.{0, 0} (OrderDual.{0} Bool) (OrderDual.{0} Bool))) (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) (Prod.instLEProd.{0, 0} Bool (Prod.{0, 0} (OrderDual.{0} Bool) (OrderDual.{0} Bool)) (Preorder.toLE.{0} Bool (PartialOrder.toPreorder.{0} Bool (SemilatticeInf.toPartialOrder.{0} Bool (Lattice.toSemilatticeInf.{0} Bool (GeneralizedCoheytingAlgebra.toLattice.{0} Bool (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{0} Bool (BiheytingAlgebra.toCoheytingAlgebra.{0} Bool (BooleanAlgebra.toBiheytingAlgebra.{0} Bool instBooleanAlgebraBool)))))))) (Prod.instLEProd.{0, 0} (OrderDual.{0} Bool) (OrderDual.{0} Bool) (OrderDual.instLEOrderDual.{0} Bool (Preorder.toLE.{0} Bool (PartialOrder.toPreorder.{0} Bool (SemilatticeInf.toPartialOrder.{0} Bool (Lattice.toSemilatticeInf.{0} Bool (GeneralizedCoheytingAlgebra.toLattice.{0} Bool (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{0} Bool (BiheytingAlgebra.toCoheytingAlgebra.{0} Bool (BooleanAlgebra.toBiheytingAlgebra.{0} Bool instBooleanAlgebraBool))))))))) (OrderDual.instLEOrderDual.{0} Bool (Preorder.toLE.{0} Bool (PartialOrder.toPreorder.{0} Bool (SemilatticeInf.toPartialOrder.{0} Bool (Lattice.toSemilatticeInf.{0} Bool (GeneralizedCoheytingAlgebra.toLattice.{0} Bool (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{0} Bool (BiheytingAlgebra.toCoheytingAlgebra.{0} Bool (BooleanAlgebra.toBiheytingAlgebra.{0} Bool instBooleanAlgebraBool)))))))))))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.iso_prod BoxIntegral.IntegrationParams.isoProdₓ'. -/
 /-- Auxiliary `order_iso` with a product type used to lift a `bounded_order` structure. -/
 def isoProd : IntegrationParams ≃o Bool × Boolᵒᵈ × Boolᵒᵈ :=
   ⟨equivProd, fun ⟨x, y, z⟩ => Iff.rfl⟩
@@ -290,40 +284,16 @@ def GP : IntegrationParams :=
 #align box_integral.integration_params.GP BoxIntegral.IntegrationParams.GP
 -/
 
-/- warning: box_integral.integration_params.Henstock_le_Riemann -> BoxIntegral.IntegrationParams.henstock_le_riemann is a dubious translation:
-lean 3 declaration is
-  LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) BoxIntegral.IntegrationParams.Henstock BoxIntegral.IntegrationParams.Riemann
-but is expected to have type
-  LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) BoxIntegral.IntegrationParams.Henstock BoxIntegral.IntegrationParams.Riemann
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.Henstock_le_Riemann BoxIntegral.IntegrationParams.henstock_le_riemannₓ'. -/
 theorem henstock_le_riemann : Henstock ≤ Riemann := by decide
 #align box_integral.integration_params.Henstock_le_Riemann BoxIntegral.IntegrationParams.henstock_le_riemann
 
-/- warning: box_integral.integration_params.Henstock_le_McShane -> BoxIntegral.IntegrationParams.henstock_le_mcShane is a dubious translation:
-lean 3 declaration is
-  LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) BoxIntegral.IntegrationParams.Henstock BoxIntegral.IntegrationParams.McShane
-but is expected to have type
-  LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) BoxIntegral.IntegrationParams.Henstock BoxIntegral.IntegrationParams.McShane
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.Henstock_le_McShane BoxIntegral.IntegrationParams.henstock_le_mcShaneₓ'. -/
 theorem henstock_le_mcShane : Henstock ≤ McShane := by decide
 #align box_integral.integration_params.Henstock_le_McShane BoxIntegral.IntegrationParams.henstock_le_mcShane
 
-/- warning: box_integral.integration_params.GP_le -> BoxIntegral.IntegrationParams.gp_le is a dubious translation:
-lean 3 declaration is
-  forall {l : BoxIntegral.IntegrationParams}, LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) BoxIntegral.IntegrationParams.GP l
-but is expected to have type
-  forall {l : BoxIntegral.IntegrationParams}, LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) BoxIntegral.IntegrationParams.GP l
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.GP_le BoxIntegral.IntegrationParams.gp_leₓ'. -/
 theorem gp_le : GP ≤ l :=
   bot_le
 #align box_integral.integration_params.GP_le BoxIntegral.IntegrationParams.gp_le
 
-/- warning: box_integral.integration_params.mem_base_set -> BoxIntegral.IntegrationParams.MemBaseSet is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι], BoxIntegral.IntegrationParams -> (forall (I : BoxIntegral.Box.{u1} ι), NNReal -> ((ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) -> (BoxIntegral.TaggedPrepartition.{u1} ι I) -> Prop)
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι], BoxIntegral.IntegrationParams -> (forall (I : BoxIntegral.Box.{u1} ι), NNReal -> ((ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) -> (BoxIntegral.TaggedPrepartition.{u1} ι I) -> Prop)
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.mem_base_set BoxIntegral.IntegrationParams.MemBaseSetₓ'. -/
 /-- The predicate corresponding to a base set of the filter defined by an
 `integration_params`. It says that
 
@@ -348,12 +318,6 @@ structure MemBaseSet (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) (r : (ι
   exists_compl : l.bDistortion → ∃ π' : Prepartition I, π'.iUnion = I \ π.iUnion ∧ π'.distortion ≤ c
 #align box_integral.integration_params.mem_base_set BoxIntegral.IntegrationParams.MemBaseSet
 
-/- warning: box_integral.integration_params.r_cond -> BoxIntegral.IntegrationParams.RCond is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}}, BoxIntegral.IntegrationParams -> ((ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) -> Prop
-but is expected to have type
-  forall {ι : Type.{u1}}, BoxIntegral.IntegrationParams -> ((ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) -> Prop
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.r_cond BoxIntegral.IntegrationParams.RCondₓ'. -/
 /-- A predicate saying that in case `l.bRiemann = tt`, the function `r` is a constant. -/
 def RCond {ι : Type _} (l : IntegrationParams) (r : (ι → ℝ) → Ioi (0 : ℝ)) : Prop :=
   l.bRiemann → ∀ x, r x = r 0
@@ -396,33 +360,15 @@ def toFilteriUnion (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I)
 #align box_integral.integration_params.to_filter_Union BoxIntegral.IntegrationParams.toFilteriUnion
 -/
 
-/- warning: box_integral.integration_params.r_cond_of_bRiemann_eq_ff -> BoxIntegral.IntegrationParams.rCond_of_bRiemann_eq_false is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} (l : BoxIntegral.IntegrationParams), (Eq.{1} Bool (BoxIntegral.IntegrationParams.bRiemann l) Bool.false) -> (forall {r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))}, BoxIntegral.IntegrationParams.RCond.{u1} ι l r)
-but is expected to have type
-  forall {ι : Type.{u1}} (l : BoxIntegral.IntegrationParams), (Eq.{1} Bool (BoxIntegral.IntegrationParams.bRiemann l) Bool.false) -> (forall {r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))}, BoxIntegral.IntegrationParams.RCond.{u1} ι l r)
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.r_cond_of_bRiemann_eq_ff BoxIntegral.IntegrationParams.rCond_of_bRiemann_eq_falseₓ'. -/
 theorem rCond_of_bRiemann_eq_false {ι} (l : IntegrationParams) (hl : l.bRiemann = false)
     {r : (ι → ℝ) → Ioi (0 : ℝ)} : l.RCond r := by simp [r_cond, hl]
 #align box_integral.integration_params.r_cond_of_bRiemann_eq_ff BoxIntegral.IntegrationParams.rCond_of_bRiemann_eq_false
 
-/- warning: box_integral.integration_params.to_filter_inf_Union_eq -> BoxIntegral.IntegrationParams.toFilter_inf_iUnion_eq is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (π₀ : BoxIntegral.Prepartition.{u1} ι I), Eq.{succ u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Inf.inf.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.hasInf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l I) (Filter.principal.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀))))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l I π₀)
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (π₀ : BoxIntegral.Prepartition.{u1} ι I), Eq.{succ u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Inf.inf.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.instInfFilter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l I) (Filter.principal.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀))))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l I π₀)
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.to_filter_inf_Union_eq BoxIntegral.IntegrationParams.toFilter_inf_iUnion_eqₓ'. -/
 theorem toFilter_inf_iUnion_eq (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
     l.toFilter I ⊓ 𝓟 { π | π.iUnion = π₀.iUnion } = l.toFilteriUnion I π₀ :=
   (iSup_inf_principal _ _).symm
 #align box_integral.integration_params.to_filter_inf_Union_eq BoxIntegral.IntegrationParams.toFilter_inf_iUnion_eq
 
-/- warning: box_integral.integration_params.mem_base_set.mono' -> BoxIntegral.IntegrationParams.MemBaseSet.mono' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c₁ : NNReal} {c₂ : NNReal} {r₁ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {r₂ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) l₁ l₂) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) c₁ c₂) -> (forall {π : BoxIntegral.TaggedPrepartition.{u1} ι I}, (forall (J : BoxIntegral.Box.{u1} ι), (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.TaggedPrepartition.{u1} ι I) (BoxIntegral.TaggedPrepartition.hasMem.{u1} ι I) J π) -> (LE.le.{0} (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) (Subtype.hasLe.{0} Real Real.hasLe (fun (x : Real) => Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (r₁ (BoxIntegral.TaggedPrepartition.tag.{u1} ι I π J)) (r₂ (BoxIntegral.TaggedPrepartition.tag.{u1} ι I π J)))) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₁ I c₁ r₁ π) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₂ I c₂ r₂ π))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c₁ : NNReal} {c₂ : NNReal} {r₁ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {r₂ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) l₁ l₂) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) c₁ c₂) -> (forall {π : BoxIntegral.TaggedPrepartition.{u1} ι I}, (forall (J : BoxIntegral.Box.{u1} ι), (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.TaggedPrepartition.{u1} ι I) (BoxIntegral.TaggedPrepartition.instMembershipBoxTaggedPrepartition.{u1} ι I) J π) -> (LE.le.{0} (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) (Subtype.le.{0} Real Real.instLEReal (fun (x : Real) => Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (r₁ (BoxIntegral.TaggedPrepartition.tag.{u1} ι I π J)) (r₂ (BoxIntegral.TaggedPrepartition.tag.{u1} ι I π J)))) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₁ I c₁ r₁ π) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₂ I c₂ r₂ π))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.mem_base_set.mono' BoxIntegral.IntegrationParams.MemBaseSet.mono'ₓ'. -/
 theorem MemBaseSet.mono' (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {π : TaggedPrepartition I}
     (hr : ∀ J ∈ π, r₁ (π.Tag J) ≤ r₂ (π.Tag J)) (hπ : l₁.MemBaseSet I c₁ r₁ π) :
     l₂.MemBaseSet I c₂ r₂ π :=
@@ -431,24 +377,12 @@ theorem MemBaseSet.mono' (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {
     (hπ.4 (le_iff_imp.1 h.2.2 hD)).imp fun π hπ => ⟨hπ.1, hπ.2.trans hc⟩⟩
 #align box_integral.integration_params.mem_base_set.mono' BoxIntegral.IntegrationParams.MemBaseSet.mono'
 
-/- warning: box_integral.integration_params.mem_base_set.mono -> BoxIntegral.IntegrationParams.MemBaseSet.mono is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c₁ : NNReal} {c₂ : NNReal} {r₁ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {r₂ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) l₁ l₂) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) c₁ c₂) -> (forall {π : BoxIntegral.TaggedPrepartition.{u1} ι I}, (forall (x : ι -> Real), (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) x (coeFn.{succ u1, succ u1} (OrderEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.hasLe.{u1} ι) (Set.hasLe.{u1} (ι -> Real))) (fun (_x : RelEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) (LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.hasLe.{u1} (ι -> Real)))) => (BoxIntegral.Box.{u1} ι) -> (Set.{u1} (ι -> Real))) (RelEmbedding.hasCoeToFun.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) (LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.hasLe.{u1} (ι -> Real)))) (BoxIntegral.Box.Icc.{u1} ι) I)) -> (LE.le.{0} (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) (Subtype.hasLe.{0} Real Real.hasLe (fun (x : Real) => Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (r₁ x) (r₂ x))) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₁ I c₁ r₁ π) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₂ I c₂ r₂ π))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c₁ : NNReal} {c₂ : NNReal} {r₁ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {r₂ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) l₁ l₂) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) c₁ c₂) -> (forall {π : BoxIntegral.TaggedPrepartition.{u1} ι I}, (forall (x : ι -> Real), (Membership.mem.{u1, u1} (ι -> Real) ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : BoxIntegral.Box.{u1} ι) => Set.{u1} (ι -> Real)) I) (Set.instMembershipSet.{u1} (ι -> Real)) x (FunLike.coe.{succ u1, succ u1, succ u1} (OrderEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.instLEBox.{u1} ι) (Set.instLESet.{u1} (ι -> Real))) (BoxIntegral.Box.{u1} ι) (fun (_x : BoxIntegral.Box.{u1} ι) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : BoxIntegral.Box.{u1} ι) => Set.{u1} (ι -> Real)) _x) (RelHomClass.toFunLike.{u1, u1, u1} (OrderEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.instLEBox.{u1} ι) (Set.instLESet.{u1} (ι -> Real))) (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : BoxIntegral.Box.{u1} ι) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : BoxIntegral.Box.{u1} ι) => LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instLEBox.{u1} ι) x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Set.{u1} (ι -> Real)) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Set.{u1} (ι -> Real)) => LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.instLESet.{u1} (ι -> Real)) x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699) (RelEmbedding.instRelHomClassRelEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : BoxIntegral.Box.{u1} ι) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : BoxIntegral.Box.{u1} ι) => LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instLEBox.{u1} ι) x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Set.{u1} (ι -> Real)) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Set.{u1} (ι -> Real)) => LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.instLESet.{u1} (ι -> Real)) x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699))) (BoxIntegral.Box.Icc.{u1} ι) I)) -> (LE.le.{0} (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) (Subtype.le.{0} Real Real.instLEReal (fun (x : Real) => Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (r₁ x) (r₂ x))) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₁ I c₁ r₁ π) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₂ I c₂ r₂ π))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.mem_base_set.mono BoxIntegral.IntegrationParams.MemBaseSet.monoₓ'. -/
 @[mono]
 theorem MemBaseSet.mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {π : TaggedPrepartition I}
     (hr : ∀ x ∈ I.Icc, r₁ x ≤ r₂ x) (hπ : l₁.MemBaseSet I c₁ r₁ π) : l₂.MemBaseSet I c₂ r₂ π :=
   hπ.mono' I h hc fun J hJ => hr _ <| π.tag_mem_Icc J
 #align box_integral.integration_params.mem_base_set.mono BoxIntegral.IntegrationParams.MemBaseSet.mono
 
-/- warning: box_integral.integration_params.mem_base_set.exists_common_compl -> BoxIntegral.IntegrationParams.MemBaseSet.exists_common_compl is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c₁ : NNReal} {c₂ : NNReal} {r₁ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {r₂ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {π₁ : BoxIntegral.TaggedPrepartition.{u1} ι I} {π₂ : BoxIntegral.TaggedPrepartition.{u1} ι I} {l : BoxIntegral.IntegrationParams}, (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c₁ r₁ π₁) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c₂ r₂ π₂) -> (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₁) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₂)) -> (Exists.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (fun (π : BoxIntegral.Prepartition.{u1} ι I) => And (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.iUnion.{u1} ι I π) (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} (ι -> Real)) (Set.booleanAlgebra.{u1} (ι -> Real))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.Set.hasCoeT.{u1} ι))) I) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₁))) (And ((coeSort.{1, 1} Bool Prop coeSortBool (BoxIntegral.IntegrationParams.bDistortion l)) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I π _inst_1) c₁)) ((coeSort.{1, 1} Bool Prop coeSortBool (BoxIntegral.IntegrationParams.bDistortion l)) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I π _inst_1) c₂)))))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c₁ : NNReal} {c₂ : NNReal} {r₁ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {r₂ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {π₁ : BoxIntegral.TaggedPrepartition.{u1} ι I} {π₂ : BoxIntegral.TaggedPrepartition.{u1} ι I} {l : BoxIntegral.IntegrationParams}, (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c₁ r₁ π₁) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c₂ r₂ π₂) -> (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₁) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₂)) -> (Exists.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (fun (π : BoxIntegral.Prepartition.{u1} ι I) => And (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.iUnion.{u1} ι I π) (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (Set.instSDiffSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₁))) (And ((Eq.{1} Bool (BoxIntegral.IntegrationParams.bDistortion l) Bool.true) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I π _inst_1) c₁)) ((Eq.{1} Bool (BoxIntegral.IntegrationParams.bDistortion l) Bool.true) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I π _inst_1) c₂)))))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.mem_base_set.exists_common_compl BoxIntegral.IntegrationParams.MemBaseSet.exists_common_complₓ'. -/
 theorem MemBaseSet.exists_common_compl (h₁ : l.MemBaseSet I c₁ r₁ π₁) (h₂ : l.MemBaseSet I c₂ r₂ π₂)
     (hU : π₁.iUnion = π₂.iUnion) :
     ∃ π : Prepartition I,
@@ -466,12 +400,6 @@ theorem MemBaseSet.exists_common_compl (h₁ : l.MemBaseSet I c₁ r₁ π₁) (
         (hD h).elim⟩
 #align box_integral.integration_params.mem_base_set.exists_common_compl BoxIntegral.IntegrationParams.MemBaseSet.exists_common_compl
 
-/- warning: box_integral.integration_params.mem_base_set.union_compl_to_subordinate -> BoxIntegral.IntegrationParams.MemBaseSet.unionComplToSubordinate is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} {r₁ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {r₂ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {π₁ : BoxIntegral.TaggedPrepartition.{u1} ι I} {l : BoxIntegral.IntegrationParams}, (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r₁ π₁) -> (forall (x : ι -> Real), (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) x (coeFn.{succ u1, succ u1} (OrderEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.hasLe.{u1} ι) (Set.hasLe.{u1} (ι -> Real))) (fun (_x : RelEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) (LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.hasLe.{u1} (ι -> Real)))) => (BoxIntegral.Box.{u1} ι) -> (Set.{u1} (ι -> Real))) (RelEmbedding.hasCoeToFun.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) (LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.hasLe.{u1} (ι -> Real)))) (BoxIntegral.Box.Icc.{u1} ι) I)) -> (LE.le.{0} (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) (Subtype.hasLe.{0} Real Real.hasLe (fun (x : Real) => Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (r₂ x) (r₁ x))) -> (forall {π₂ : BoxIntegral.Prepartition.{u1} ι I} (hU : Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₂) (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} (ι -> Real)) (Set.booleanAlgebra.{u1} (ι -> Real))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.Set.hasCoeT.{u1} ι))) I) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₁))), ((coeSort.{1, 1} Bool Prop coeSortBool (BoxIntegral.IntegrationParams.bDistortion l)) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I π₂ _inst_1) c)) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r₁ (BoxIntegral.TaggedPrepartition.unionComplToSubordinate.{u1} ι _inst_1 I π₁ π₂ hU r₂)))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} {r₁ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {r₂ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {π₁ : BoxIntegral.TaggedPrepartition.{u1} ι I} {l : BoxIntegral.IntegrationParams}, (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r₁ π₁) -> (forall (x : ι -> Real), (Membership.mem.{u1, u1} (ι -> Real) ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : BoxIntegral.Box.{u1} ι) => Set.{u1} (ι -> Real)) I) (Set.instMembershipSet.{u1} (ι -> Real)) x (FunLike.coe.{succ u1, succ u1, succ u1} (OrderEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.instLEBox.{u1} ι) (Set.instLESet.{u1} (ι -> Real))) (BoxIntegral.Box.{u1} ι) (fun (_x : BoxIntegral.Box.{u1} ι) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : BoxIntegral.Box.{u1} ι) => Set.{u1} (ι -> Real)) _x) (RelHomClass.toFunLike.{u1, u1, u1} (OrderEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.instLEBox.{u1} ι) (Set.instLESet.{u1} (ι -> Real))) (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : BoxIntegral.Box.{u1} ι) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : BoxIntegral.Box.{u1} ι) => LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instLEBox.{u1} ι) x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Set.{u1} (ι -> Real)) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Set.{u1} (ι -> Real)) => LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.instLESet.{u1} (ι -> Real)) x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699) (RelEmbedding.instRelHomClassRelEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : BoxIntegral.Box.{u1} ι) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : BoxIntegral.Box.{u1} ι) => LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instLEBox.{u1} ι) x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Set.{u1} (ι -> Real)) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Set.{u1} (ι -> Real)) => LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.instLESet.{u1} (ι -> Real)) x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699))) (BoxIntegral.Box.Icc.{u1} ι) I)) -> (LE.le.{0} (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) (Subtype.le.{0} Real Real.instLEReal (fun (x : Real) => Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (r₂ x) (r₁ x))) -> (forall {π₂ : BoxIntegral.Prepartition.{u1} ι I} (hU : Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₂) (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (Set.instSDiffSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₁))), ((Eq.{1} Bool (BoxIntegral.IntegrationParams.bDistortion l) Bool.true) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I π₂ _inst_1) c)) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r₁ (BoxIntegral.TaggedPrepartition.unionComplToSubordinate.{u1} ι _inst_1 I π₁ π₂ hU r₂)))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.mem_base_set.union_compl_to_subordinate BoxIntegral.IntegrationParams.MemBaseSet.unionComplToSubordinateₓ'. -/
 protected theorem MemBaseSet.unionComplToSubordinate (hπ₁ : l.MemBaseSet I c r₁ π₁)
     (hle : ∀ x ∈ I.Icc, r₂ x ≤ r₁ x) {π₂ : Prepartition I} (hU : π₂.iUnion = I \ π₁.iUnion)
     (hc : l.bDistortion → π₂.distortion ≤ c) :
@@ -482,12 +410,6 @@ protected theorem MemBaseSet.unionComplToSubordinate (hπ₁ : l.MemBaseSet I c
     ⟨⊥, by simp⟩⟩
 #align box_integral.integration_params.mem_base_set.union_compl_to_subordinate BoxIntegral.IntegrationParams.MemBaseSet.unionComplToSubordinate
 
-/- warning: box_integral.integration_params.mem_base_set.filter -> BoxIntegral.IntegrationParams.MemBaseSet.filter is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} {r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {π : BoxIntegral.TaggedPrepartition.{u1} ι I} {l : BoxIntegral.IntegrationParams}, (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) -> (forall (p : (BoxIntegral.Box.{u1} ι) -> Prop), BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r (BoxIntegral.TaggedPrepartition.filter.{u1} ι I π p))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} {r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {π : BoxIntegral.TaggedPrepartition.{u1} ι I} {l : BoxIntegral.IntegrationParams}, (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) -> (forall (p : (BoxIntegral.Box.{u1} ι) -> Prop), BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r (BoxIntegral.TaggedPrepartition.filter.{u1} ι I π p))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.mem_base_set.filter BoxIntegral.IntegrationParams.MemBaseSet.filterₓ'. -/
 protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι → Prop) :
     l.MemBaseSet I c r (π.filterₓ p) :=
   by
@@ -510,12 +432,6 @@ protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι 
     simpa [hc]
 #align box_integral.integration_params.mem_base_set.filter BoxIntegral.IntegrationParams.MemBaseSet.filter
 
-/- warning: box_integral.integration_params.bUnion_tagged_mem_base_set -> BoxIntegral.IntegrationParams.biUnionTagged_memBaseSet is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} {r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {l : BoxIntegral.IntegrationParams} {π : BoxIntegral.Prepartition.{u1} ι I} {πi : forall (J : BoxIntegral.Box.{u1} ι), BoxIntegral.TaggedPrepartition.{u1} ι J}, (forall (J : BoxIntegral.Box.{u1} ι), (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) J π) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l J c r (πi J))) -> (forall (J : BoxIntegral.Box.{u1} ι), (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) J π) -> (BoxIntegral.TaggedPrepartition.IsPartition.{u1} ι J (πi J))) -> ((coeSort.{1, 1} Bool Prop coeSortBool (BoxIntegral.IntegrationParams.bDistortion l)) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I (Finite.of_fintype.{u1} ι _inst_1) π) _inst_1) c)) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r (BoxIntegral.Prepartition.biUnionTagged.{u1} ι I π πi))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} {r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {l : BoxIntegral.IntegrationParams} {π : BoxIntegral.Prepartition.{u1} ι I} {πi : forall (J : BoxIntegral.Box.{u1} ι), BoxIntegral.TaggedPrepartition.{u1} ι J}, (forall (J : BoxIntegral.Box.{u1} ι), (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) J π) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l J c r (πi J))) -> (forall (J : BoxIntegral.Box.{u1} ι), (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) J π) -> (BoxIntegral.TaggedPrepartition.IsPartition.{u1} ι J (πi J))) -> ((Eq.{1} Bool (BoxIntegral.IntegrationParams.bDistortion l) Bool.true) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I (Finite.of_fintype.{u1} ι _inst_1) π) _inst_1) c)) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r (BoxIntegral.Prepartition.biUnionTagged.{u1} ι I π πi))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.bUnion_tagged_mem_base_set BoxIntegral.IntegrationParams.biUnionTagged_memBaseSetₓ'. -/
 theorem biUnionTagged_memBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepartition J}
     (h : ∀ J ∈ π, l.MemBaseSet J c r (πi J)) (hp : ∀ J ∈ π, (πi J).IsPartition)
     (hc : l.bDistortion → π.compl.distortion ≤ c) : l.MemBaseSet I c r (π.biUnionTagged πi) :=
@@ -530,33 +446,15 @@ theorem biUnionTagged_memBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepa
     rw [π.Union_compl, ← π.Union_bUnion_partition hp]; rfl
 #align box_integral.integration_params.bUnion_tagged_mem_base_set BoxIntegral.IntegrationParams.biUnionTagged_memBaseSet
 
-/- warning: box_integral.integration_params.r_cond.mono -> BoxIntegral.IntegrationParams.RCond.mono is a dubious translation:
-lean 3 declaration is
-  forall {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} {ι : Type.{u1}} {r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))}, (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) l₁ l₂) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l₂ r) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l₁ r)
-but is expected to have type
-  forall {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} {ι : Type.{u1}} {r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))}, (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) l₁ l₂) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l₂ r) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l₁ r)
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.r_cond.mono BoxIntegral.IntegrationParams.RCond.monoₓ'. -/
 @[mono]
 theorem RCond.mono {ι : Type _} {r : (ι → ℝ) → Ioi (0 : ℝ)} (h : l₁ ≤ l₂) (hr : l₂.RCond r) :
     l₁.RCond r := fun hR => hr (le_iff_imp.1 h.1 hR)
 #align box_integral.integration_params.r_cond.mono BoxIntegral.IntegrationParams.RCond.mono
 
-/- warning: box_integral.integration_params.r_cond.min -> BoxIntegral.IntegrationParams.RCond.min is a dubious translation:
-lean 3 declaration is
-  forall {l : BoxIntegral.IntegrationParams} {ι : Type.{u1}} {r₁ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {r₂ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))}, (BoxIntegral.IntegrationParams.RCond.{u1} ι l r₁) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l r₂) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l (fun (x : ι -> Real) => LinearOrder.min.{0} (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) (Subtype.linearOrder.{0} Real Real.linearOrder (fun (x : Real) => Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (r₁ x) (r₂ x)))
-but is expected to have type
-  forall {l : BoxIntegral.IntegrationParams} {ι : Type.{u1}} {r₁ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {r₂ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))}, (BoxIntegral.IntegrationParams.RCond.{u1} ι l r₁) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l r₂) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l (fun (x : ι -> Real) => Min.min.{0} (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) (LinearOrder.toMin.{0} (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) (Subtype.linearOrder.{0} Real Real.linearOrder (fun (x : Real) => Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))))) (r₁ x) (r₂ x)))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.r_cond.min BoxIntegral.IntegrationParams.RCond.minₓ'. -/
 theorem RCond.min {ι : Type _} {r₁ r₂ : (ι → ℝ) → Ioi (0 : ℝ)} (h₁ : l.RCond r₁) (h₂ : l.RCond r₂) :
     l.RCond fun x => min (r₁ x) (r₂ x) := fun hR x => congr_arg₂ min (h₁ hR x) (h₂ hR x)
 #align box_integral.integration_params.r_cond.min BoxIntegral.IntegrationParams.RCond.min
 
-/- warning: box_integral.integration_params.to_filter_distortion_mono -> BoxIntegral.IntegrationParams.toFilterDistortion_mono is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c₁ : NNReal} {c₂ : NNReal} {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) l₁ l₂) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) c₁ c₂) -> (LE.le.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Preorder.toHasLe.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.partialOrder.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)))) (BoxIntegral.IntegrationParams.toFilterDistortion.{u1} ι _inst_1 l₁ I c₁) (BoxIntegral.IntegrationParams.toFilterDistortion.{u1} ι _inst_1 l₂ I c₂))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c₁ : NNReal} {c₂ : NNReal} {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) l₁ l₂) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) c₁ c₂) -> (LE.le.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Preorder.toLE.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.instPartialOrderFilter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)))) (BoxIntegral.IntegrationParams.toFilterDistortion.{u1} ι _inst_1 l₁ I c₁) (BoxIntegral.IntegrationParams.toFilterDistortion.{u1} ι _inst_1 l₂ I c₂))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.to_filter_distortion_mono BoxIntegral.IntegrationParams.toFilterDistortion_monoₓ'. -/
 @[mono]
 theorem toFilterDistortion_mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) :
     l₁.toFilterDistortion I c₁ ≤ l₂.toFilterDistortion I c₂ :=
@@ -565,24 +463,12 @@ theorem toFilterDistortion_mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤
       ⟨hr.mono h, principal_mono.2 fun _ => MemBaseSet.mono I h hc fun _ _ => le_rfl⟩
 #align box_integral.integration_params.to_filter_distortion_mono BoxIntegral.IntegrationParams.toFilterDistortion_mono
 
-/- warning: box_integral.integration_params.to_filter_mono -> BoxIntegral.IntegrationParams.toFilter_mono is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (I : BoxIntegral.Box.{u1} ι) {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams}, (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) l₁ l₂) -> (LE.le.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Preorder.toHasLe.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.partialOrder.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)))) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l₁ I) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l₂ I))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (I : BoxIntegral.Box.{u1} ι) {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams}, (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) l₁ l₂) -> (LE.le.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Preorder.toLE.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.instPartialOrderFilter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)))) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l₁ I) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l₂ I))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.to_filter_mono BoxIntegral.IntegrationParams.toFilter_monoₓ'. -/
 @[mono]
 theorem toFilter_mono (I : Box ι) {l₁ l₂ : IntegrationParams} (h : l₁ ≤ l₂) :
     l₁.toFilter I ≤ l₂.toFilter I :=
   iSup_mono fun c => toFilterDistortion_mono I h le_rfl
 #align box_integral.integration_params.to_filter_mono BoxIntegral.IntegrationParams.toFilter_mono
 
-/- warning: box_integral.integration_params.to_filter_Union_mono -> BoxIntegral.IntegrationParams.toFilteriUnion_mono is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (I : BoxIntegral.Box.{u1} ι) {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams}, (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) l₁ l₂) -> (forall (π₀ : BoxIntegral.Prepartition.{u1} ι I), LE.le.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Preorder.toHasLe.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.partialOrder.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l₁ I π₀) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l₂ I π₀))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (I : BoxIntegral.Box.{u1} ι) {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams}, (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) l₁ l₂) -> (forall (π₀ : BoxIntegral.Prepartition.{u1} ι I), LE.le.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Preorder.toLE.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.instPartialOrderFilter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l₁ I π₀) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l₂ I π₀))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.to_filter_Union_mono BoxIntegral.IntegrationParams.toFilteriUnion_monoₓ'. -/
 @[mono]
 theorem toFilteriUnion_mono (I : Box ι) {l₁ l₂ : IntegrationParams} (h : l₁ ≤ l₂)
     (π₀ : Prepartition I) : l₁.toFilteriUnion I π₀ ≤ l₂.toFilteriUnion I π₀ :=
@@ -596,12 +482,6 @@ theorem toFilteriUnion_congr (I : Box ι) (l : IntegrationParams) {π₁ π₂ :
 #align box_integral.integration_params.to_filter_Union_congr BoxIntegral.IntegrationParams.toFilteriUnion_congr
 -/
 
-/- warning: box_integral.integration_params.has_basis_to_filter_distortion -> BoxIntegral.IntegrationParams.hasBasis_toFilterDistortion is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (c : NNReal), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) ((ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (BoxIntegral.IntegrationParams.toFilterDistortion.{u1} ι _inst_1 l I c) (BoxIntegral.IntegrationParams.RCond.{u1} ι l) (fun (r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (c : NNReal), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) ((ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (BoxIntegral.IntegrationParams.toFilterDistortion.{u1} ι _inst_1 l I c) (BoxIntegral.IntegrationParams.RCond.{u1} ι l) (fun (r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.has_basis_to_filter_distortion BoxIntegral.IntegrationParams.hasBasis_toFilterDistortionₓ'. -/
 theorem hasBasis_toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) :
     (l.toFilterDistortion I c).HasBasis l.RCond fun r => { π | l.MemBaseSet I c r π } :=
   hasBasis_biInf_principal'
@@ -611,12 +491,6 @@ theorem hasBasis_toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : 
     ⟨fun _ => ⟨1, zero_lt_one⟩, fun _ _ => rfl⟩
 #align box_integral.integration_params.has_basis_to_filter_distortion BoxIntegral.IntegrationParams.hasBasis_toFilterDistortion
 
-/- warning: box_integral.integration_params.has_basis_to_filter_distortion_Union -> BoxIntegral.IntegrationParams.hasBasis_toFilterDistortioniUnion is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (c : NNReal) (π₀ : BoxIntegral.Prepartition.{u1} ι I), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) ((ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (BoxIntegral.IntegrationParams.toFilterDistortioniUnion.{u1} ι _inst_1 l I c π₀) (BoxIntegral.IntegrationParams.RCond.{u1} ι l) (fun (r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀))))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (c : NNReal) (π₀ : BoxIntegral.Prepartition.{u1} ι I), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) ((ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (BoxIntegral.IntegrationParams.toFilterDistortioniUnion.{u1} ι _inst_1 l I c π₀) (BoxIntegral.IntegrationParams.RCond.{u1} ι l) (fun (r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀))))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.has_basis_to_filter_distortion_Union BoxIntegral.IntegrationParams.hasBasis_toFilterDistortioniUnionₓ'. -/
 theorem hasBasis_toFilterDistortioniUnion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0)
     (π₀ : Prepartition I) :
     (l.toFilterDistortioniUnion I c π₀).HasBasis l.RCond fun r =>
@@ -624,12 +498,6 @@ theorem hasBasis_toFilterDistortioniUnion (l : IntegrationParams) (I : Box ι) (
   (l.hasBasis_toFilterDistortion I c).inf_principal _
 #align box_integral.integration_params.has_basis_to_filter_distortion_Union BoxIntegral.IntegrationParams.hasBasis_toFilterDistortioniUnion
 
-/- warning: box_integral.integration_params.has_basis_to_filter_Union -> BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (π₀ : BoxIntegral.Prepartition.{u1} ι I), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l I π₀) (fun (r : NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => forall (c : NNReal), BoxIntegral.IntegrationParams.RCond.{u1} ι l (r c)) (fun (r : NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Exists.{1} NNReal (fun (c : NNReal) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c (r c) π) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀)))))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (π₀ : BoxIntegral.Prepartition.{u1} ι I), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l I π₀) (fun (r : NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => forall (c : NNReal), BoxIntegral.IntegrationParams.RCond.{u1} ι l (r c)) (fun (r : NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Exists.{1} NNReal (fun (c : NNReal) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c (r c) π) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀)))))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.has_basis_to_filter_Union BoxIntegral.IntegrationParams.hasBasis_toFilteriUnionₓ'. -/
 theorem hasBasis_toFilteriUnion (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
     (l.toFilteriUnion I π₀).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
       fun r => { π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.iUnion = π₀.iUnion } :=
@@ -638,12 +506,6 @@ theorem hasBasis_toFilteriUnion (l : IntegrationParams) (I : Box ι) (π₀ : Pr
   simpa only [set_of_and, set_of_exists] using has_basis_supr this
 #align box_integral.integration_params.has_basis_to_filter_Union BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion
 
-/- warning: box_integral.integration_params.has_basis_to_filter_Union_top -> BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion_top is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l I (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toHasTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.orderTop.{u1} ι I)))) (fun (r : NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => forall (c : NNReal), BoxIntegral.IntegrationParams.RCond.{u1} ι l (r c)) (fun (r : NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Exists.{1} NNReal (fun (c : NNReal) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c (r c) π) (BoxIntegral.TaggedPrepartition.IsPartition.{u1} ι I π))))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l I (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.instOrderTopPrepartitionInstLEPrepartition.{u1} ι I)))) (fun (r : NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => forall (c : NNReal), BoxIntegral.IntegrationParams.RCond.{u1} ι l (r c)) (fun (r : NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Exists.{1} NNReal (fun (c : NNReal) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c (r c) π) (BoxIntegral.TaggedPrepartition.IsPartition.{u1} ι I π))))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.has_basis_to_filter_Union_top BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion_topₓ'. -/
 theorem hasBasis_toFilteriUnion_top (l : IntegrationParams) (I : Box ι) :
     (l.toFilteriUnion I ⊤).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
       fun r => { π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.IsPartition } :=
@@ -652,12 +514,6 @@ theorem hasBasis_toFilteriUnion_top (l : IntegrationParams) (I : Box ι) :
     l.has_basis_to_filter_Union I ⊤
 #align box_integral.integration_params.has_basis_to_filter_Union_top BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion_top
 
-/- warning: box_integral.integration_params.has_basis_to_filter -> BoxIntegral.IntegrationParams.hasBasis_toFilter is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l I) (fun (r : NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => forall (c : NNReal), BoxIntegral.IntegrationParams.RCond.{u1} ι l (r c)) (fun (r : NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Exists.{1} NNReal (fun (c : NNReal) => BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c (r c) π)))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l I) (fun (r : NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => forall (c : NNReal), BoxIntegral.IntegrationParams.RCond.{u1} ι l (r c)) (fun (r : NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Exists.{1} NNReal (fun (c : NNReal) => BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c (r c) π)))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.has_basis_to_filter BoxIntegral.IntegrationParams.hasBasis_toFilterₓ'. -/
 theorem hasBasis_toFilter (l : IntegrationParams) (I : Box ι) :
     (l.toFilter I).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c)) fun r =>
       { π | ∃ c, l.MemBaseSet I c (r c) π } :=
@@ -685,12 +541,6 @@ theorem tendsto_embedBox_toFilteriUnion_top (l : IntegrationParams) (h : I ≤ J
 #align box_integral.integration_params.tendsto_embed_box_to_filter_Union_top BoxIntegral.IntegrationParams.tendsto_embedBox_toFilteriUnion_top
 -/
 
-/- warning: box_integral.integration_params.exists_mem_base_set_le_Union_eq -> BoxIntegral.IntegrationParams.exists_memBaseSet_le_iUnion_eq is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} (l : BoxIntegral.IntegrationParams) (π₀ : BoxIntegral.Prepartition.{u1} ι I), (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I π₀ _inst_1) c) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I (Finite.of_fintype.{u1} ι _inst_1) π₀) _inst_1) c) -> (forall (r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))), Exists.{succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) (And (LE.le.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.TaggedPrepartition.toPrepartition.{u1} ι I π) π₀) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀)))))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} (l : BoxIntegral.IntegrationParams) (π₀ : BoxIntegral.Prepartition.{u1} ι I), (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I π₀ _inst_1) c) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I (Finite.of_fintype.{u1} ι _inst_1) π₀) _inst_1) c) -> (forall (r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))), Exists.{succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) (And (LE.le.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.TaggedPrepartition.toPrepartition.{u1} ι I π) π₀) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀)))))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.exists_mem_base_set_le_Union_eq BoxIntegral.IntegrationParams.exists_memBaseSet_le_iUnion_eqₓ'. -/
 theorem exists_memBaseSet_le_iUnion_eq (l : IntegrationParams) (π₀ : Prepartition I)
     (hc₁ : π₀.distortion ≤ c) (hc₂ : π₀.compl.distortion ≤ c) (r : (ι → ℝ) → Ioi (0 : ℝ)) :
     ∃ π, l.MemBaseSet I c r π ∧ π.toPrepartition ≤ π₀ ∧ π.iUnion = π₀.iUnion :=
@@ -700,12 +550,6 @@ theorem exists_memBaseSet_le_iUnion_eq (l : IntegrationParams) (π₀ : Preparti
   exact prepartition.compl_congr hU ▸ π.to_prepartition.Union_compl
 #align box_integral.integration_params.exists_mem_base_set_le_Union_eq BoxIntegral.IntegrationParams.exists_memBaseSet_le_iUnion_eq
 
-/- warning: box_integral.integration_params.exists_mem_base_set_is_partition -> BoxIntegral.IntegrationParams.exists_memBaseSet_isPartition is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c : NNReal} (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Box.distortion.{u1} ι _inst_1 I) c) -> (forall (r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))), Exists.{succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) (BoxIntegral.TaggedPrepartition.IsPartition.{u1} ι I π)))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c : NNReal} (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Box.distortion.{u1} ι _inst_1 I) c) -> (forall (r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))), Exists.{succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) (BoxIntegral.TaggedPrepartition.IsPartition.{u1} ι I π)))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.exists_mem_base_set_is_partition BoxIntegral.IntegrationParams.exists_memBaseSet_isPartitionₓ'. -/
 theorem exists_memBaseSet_isPartition (l : IntegrationParams) (I : Box ι) (hc : I.distortion ≤ c)
     (r : (ι → ℝ) → Ioi (0 : ℝ)) : ∃ π, l.MemBaseSet I c r π ∧ π.IsPartition :=
   by
@@ -714,12 +558,6 @@ theorem exists_memBaseSet_isPartition (l : IntegrationParams) (I : Box ι) (hc :
   simpa [is_partition_iff_Union_eq] using l.exists_mem_base_set_le_Union_eq ⊤ hc hc' r
 #align box_integral.integration_params.exists_mem_base_set_is_partition BoxIntegral.IntegrationParams.exists_memBaseSet_isPartition
 
-/- warning: box_integral.integration_params.to_filter_distortion_Union_ne_bot -> BoxIntegral.IntegrationParams.toFilterDistortioniUnion_neBot is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c : NNReal} (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (π₀ : BoxIntegral.Prepartition.{u1} ι I), (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I π₀ _inst_1) c) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I (Finite.of_fintype.{u1} ι _inst_1) π₀) _inst_1) c) -> (Filter.NeBot.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (BoxIntegral.IntegrationParams.toFilterDistortioniUnion.{u1} ι _inst_1 l I c π₀))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c : NNReal} (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (π₀ : BoxIntegral.Prepartition.{u1} ι I), (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I π₀ _inst_1) c) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I (Finite.of_fintype.{u1} ι _inst_1) π₀) _inst_1) c) -> (Filter.NeBot.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (BoxIntegral.IntegrationParams.toFilterDistortioniUnion.{u1} ι _inst_1 l I c π₀))
-Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.to_filter_distortion_Union_ne_bot BoxIntegral.IntegrationParams.toFilterDistortioniUnion_neBotₓ'. -/
 theorem toFilterDistortioniUnion_neBot (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I)
     (hc₁ : π₀.distortion ≤ c) (hc₂ : π₀.compl.distortion ≤ c) :
     (l.toFilterDistortioniUnion I c π₀).ne_bot :=

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -501,12 +501,10 @@ protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι 
   refine' ⟨π₁.disj_union π₂.to_prepartition this, _, _⟩
   · suffices ↑I \ π.Union ∪ π.Union \ (π.filter p).iUnion = ↑I \ (π.filter p).iUnion by simpa [*]
     have : (π.filter p).iUnion ⊆ π.Union := bUnion_subset_bUnion_left (Finset.filter_subset _ _)
-    ext x
-    fconstructor
+    ext x; fconstructor
     · rintro (⟨hxI, hxπ⟩ | ⟨hxπ, hxp⟩)
       exacts[⟨hxI, mt (@this x) hxπ⟩, ⟨π.Union_subset hxπ, hxp⟩]
-    · rintro ⟨hxI, hxp⟩
-      by_cases hxπ : x ∈ π.Union
+    · rintro ⟨hxI, hxp⟩; by_cases hxπ : x ∈ π.Union
       exacts[Or.inr ⟨hxπ, hxp⟩, Or.inl ⟨hxI, hxπ⟩]
   · have : (π.filter fun J => ¬p J).distortion ≤ c := (distortion_filter_le _ _).trans (hπ.3 hD)
     simpa [hc]
@@ -529,8 +527,7 @@ theorem biUnionTagged_memBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepa
   · rw [prepartition.distortion_bUnion_tagged, Finset.sup_le_iff]
     exact fun J hJ => (h J hJ).3 hD
   · refine' ⟨_, _, hc hD⟩
-    rw [π.Union_compl, ← π.Union_bUnion_partition hp]
-    rfl
+    rw [π.Union_compl, ← π.Union_bUnion_partition hp]; rfl
 #align box_integral.integration_params.bUnion_tagged_mem_base_set BoxIntegral.IntegrationParams.biUnionTagged_memBaseSet
 
 /- warning: box_integral.integration_params.r_cond.mono -> BoxIntegral.IntegrationParams.RCond.mono is a dubious translation:
@@ -682,8 +679,7 @@ theorem tendsto_embedBox_toFilteriUnion_top (l : IntegrationParams) (h : I ≤ J
   refine' ⟨r, hr, fun π hπ => _⟩
   rw [mem_set_of_eq, prepartition.Union_top] at hπ
   refine' ⟨⟨hπ.1.1, hπ.1.2, fun hD => le_trans (hπ.1.3 hD) (le_max_left _ _), fun hD => _⟩, _⟩
-  · refine' ⟨_, π₀.Union_compl.trans _, le_max_right _ _⟩
-    congr 1
+  · refine' ⟨_, π₀.Union_compl.trans _, le_max_right _ _⟩; congr 1
     exact (prepartition.Union_single h).trans hπ.2.symm
   · exact hπ.2.trans (prepartition.Union_single _).symm
 #align box_integral.integration_params.tendsto_embed_box_to_filter_Union_top BoxIntegral.IntegrationParams.tendsto_embedBox_toFilteriUnion_top

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
 
 ! This file was ported from Lean 3 source module analysis.box_integral.partition.filter
-! leanprover-community/mathlib commit 92ca63f0fb391a9ca5f22d2409a6080e786d99f7
+! leanprover-community/mathlib commit 0b7c740e25651db0ba63648fbae9f9d6f941e31b
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -14,6 +14,9 @@ import Mathbin.Analysis.BoxIntegral.Partition.Split
 /-!
 # Filters used in box-based integrals
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 First we define a structure `box_integral.integration_params`. This structure will be used as an
 argument in the definition of `box_integral.integral` in order to use the same definition for a few
 well-known definitions of integrals based on partitions of a rectangular box into subboxes (Riemann

mathlib commit https://github.com/leanprover-community/mathlib/commit/ef95945cd48c932c9e034872bd25c3c220d9c946

@@ -180,6 +180,7 @@ variable {ι : Type _} [Fintype ι] {I J : Box ι} {c c₁ c₂ : ℝ≥0} {r r
 
 open TaggedPrepartition
 
+#print BoxIntegral.IntegrationParams /-
 /-- An `integration_params` is a structure holding 3 boolean values used to define a filter to be
 used in the definition of a box-integrable function.
 
@@ -199,11 +200,13 @@ used in the definition of a box-integrable function.
 structure IntegrationParams : Type where
   (bRiemann bHenstock bDistortion : Bool)
 #align box_integral.integration_params BoxIntegral.IntegrationParams
+-/
 
 variable {l l₁ l₂ : IntegrationParams}
 
 namespace IntegrationParams
 
+#print BoxIntegral.IntegrationParams.equivProd /-
 /-- Auxiliary equivalence with a product type used to lift an order. -/
 def equivProd : IntegrationParams ≃ Bool × Boolᵒᵈ × Boolᵒᵈ
     where
@@ -212,10 +215,17 @@ def equivProd : IntegrationParams ≃ Bool × Boolᵒᵈ × Boolᵒᵈ
   left_inv := fun ⟨a, b, c⟩ => rfl
   right_inv := fun ⟨a, b, c⟩ => rfl
 #align box_integral.integration_params.equiv_prod BoxIntegral.IntegrationParams.equivProd
+-/
 
 instance : PartialOrder IntegrationParams :=
   PartialOrder.lift equivProd equivProd.Injective
 
+/- warning: box_integral.integration_params.iso_prod -> BoxIntegral.IntegrationParams.isoProd is a dubious translation:
+lean 3 declaration is
+  OrderIso.{0, 0} BoxIntegral.IntegrationParams (Prod.{0, 0} Bool (Prod.{0, 0} (OrderDual.{0} Bool) (OrderDual.{0} Bool))) (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) (Prod.hasLe.{0, 0} Bool (Prod.{0, 0} (OrderDual.{0} Bool) (OrderDual.{0} Bool)) (Preorder.toHasLe.{0} Bool (PartialOrder.toPreorder.{0} Bool (SemilatticeInf.toPartialOrder.{0} Bool (Lattice.toSemilatticeInf.{0} Bool (GeneralizedCoheytingAlgebra.toLattice.{0} Bool (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{0} Bool (BooleanAlgebra.toGeneralizedBooleanAlgebra.{0} Bool Bool.booleanAlgebra))))))) (Prod.hasLe.{0, 0} (OrderDual.{0} Bool) (OrderDual.{0} Bool) (OrderDual.hasLe.{0} Bool (Preorder.toHasLe.{0} Bool (PartialOrder.toPreorder.{0} Bool (SemilatticeInf.toPartialOrder.{0} Bool (Lattice.toSemilatticeInf.{0} Bool (GeneralizedCoheytingAlgebra.toLattice.{0} Bool (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{0} Bool (BooleanAlgebra.toGeneralizedBooleanAlgebra.{0} Bool Bool.booleanAlgebra)))))))) (OrderDual.hasLe.{0} Bool (Preorder.toHasLe.{0} Bool (PartialOrder.toPreorder.{0} Bool (SemilatticeInf.toPartialOrder.{0} Bool (Lattice.toSemilatticeInf.{0} Bool (GeneralizedCoheytingAlgebra.toLattice.{0} Bool (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{0} Bool (BooleanAlgebra.toGeneralizedBooleanAlgebra.{0} Bool Bool.booleanAlgebra))))))))))
+but is expected to have type
+  OrderIso.{0, 0} BoxIntegral.IntegrationParams (Prod.{0, 0} Bool (Prod.{0, 0} (OrderDual.{0} Bool) (OrderDual.{0} Bool))) (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) (Prod.instLEProd.{0, 0} Bool (Prod.{0, 0} (OrderDual.{0} Bool) (OrderDual.{0} Bool)) (Preorder.toLE.{0} Bool (PartialOrder.toPreorder.{0} Bool (SemilatticeInf.toPartialOrder.{0} Bool (Lattice.toSemilatticeInf.{0} Bool (GeneralizedCoheytingAlgebra.toLattice.{0} Bool (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{0} Bool (BiheytingAlgebra.toCoheytingAlgebra.{0} Bool (BooleanAlgebra.toBiheytingAlgebra.{0} Bool instBooleanAlgebraBool)))))))) (Prod.instLEProd.{0, 0} (OrderDual.{0} Bool) (OrderDual.{0} Bool) (OrderDual.instLEOrderDual.{0} Bool (Preorder.toLE.{0} Bool (PartialOrder.toPreorder.{0} Bool (SemilatticeInf.toPartialOrder.{0} Bool (Lattice.toSemilatticeInf.{0} Bool (GeneralizedCoheytingAlgebra.toLattice.{0} Bool (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{0} Bool (BiheytingAlgebra.toCoheytingAlgebra.{0} Bool (BooleanAlgebra.toBiheytingAlgebra.{0} Bool instBooleanAlgebraBool))))))))) (OrderDual.instLEOrderDual.{0} Bool (Preorder.toLE.{0} Bool (PartialOrder.toPreorder.{0} Bool (SemilatticeInf.toPartialOrder.{0} Bool (Lattice.toSemilatticeInf.{0} Bool (GeneralizedCoheytingAlgebra.toLattice.{0} Bool (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{0} Bool (BiheytingAlgebra.toCoheytingAlgebra.{0} Bool (BooleanAlgebra.toBiheytingAlgebra.{0} Bool instBooleanAlgebraBool)))))))))))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.iso_prod BoxIntegral.IntegrationParams.isoProdₓ'. -/
 /-- Auxiliary `order_iso` with a product type used to lift a `bounded_order` structure. -/
 def isoProd : IntegrationParams ≃o Bool × Boolᵒᵈ × Boolᵒᵈ :=
   ⟨equivProd, fun ⟨x, y, z⟩ => Iff.rfl⟩
@@ -236,49 +246,81 @@ instance : DecidableRel ((· ≤ ·) : IntegrationParams → IntegrationParams 
 
 instance : DecidableEq IntegrationParams := fun x y => decidable_of_iff _ (ext_iff x y).symm
 
+#print BoxIntegral.IntegrationParams.Riemann /-
 /-- The `box_integral.integration_params` corresponding to the Riemann integral. In the
 corresponding filter, we require that the diameters of all boxes `J` of a tagged partition are
 bounded from above by a constant upper estimate that may not depend on the geometry of `J`, and each
 tag belongs to the corresponding closed box. -/
-def riemann : IntegrationParams where
+def Riemann : IntegrationParams where
   bRiemann := true
   bHenstock := true
   bDistortion := false
-#align box_integral.integration_params.Riemann BoxIntegral.IntegrationParams.riemann
+#align box_integral.integration_params.Riemann BoxIntegral.IntegrationParams.Riemann
+-/
 
+#print BoxIntegral.IntegrationParams.Henstock /-
 /-- The `box_integral.integration_params` corresponding to the Henstock-Kurzweil integral. In the
 corresponding filter, we require that the tagged partition is subordinate to a (possibly,
 discontinuous) positive function `r` and each tag belongs to the corresponding closed box. -/
-def henstock : IntegrationParams :=
+def Henstock : IntegrationParams :=
   ⟨false, true, false⟩
-#align box_integral.integration_params.Henstock BoxIntegral.IntegrationParams.henstock
+#align box_integral.integration_params.Henstock BoxIntegral.IntegrationParams.Henstock
+-/
 
+#print BoxIntegral.IntegrationParams.McShane /-
 /-- The `box_integral.integration_params` corresponding to the McShane integral. In the
 corresponding filter, we require that the tagged partition is subordinate to a (possibly,
 discontinuous) positive function `r`; the tags may be outside of the corresponding closed box
 (but still inside the ambient closed box `I.Icc`). -/
-def mcShane : IntegrationParams :=
+def McShane : IntegrationParams :=
   ⟨false, false, false⟩
-#align box_integral.integration_params.McShane BoxIntegral.IntegrationParams.mcShane
+#align box_integral.integration_params.McShane BoxIntegral.IntegrationParams.McShane
+-/
 
+#print BoxIntegral.IntegrationParams.GP /-
 /-- The `box_integral.integration_params` corresponding to the generalized Perron integral. In the
 corresponding filter, we require that the tagged partition is subordinate to a (possibly,
 discontinuous) positive function `r` and each tag belongs to the corresponding closed box. We also
 require an upper estimate on the distortion of all boxes of the partition. -/
-def gP : IntegrationParams :=
+def GP : IntegrationParams :=
   ⊥
-#align box_integral.integration_params.GP BoxIntegral.IntegrationParams.gP
+#align box_integral.integration_params.GP BoxIntegral.IntegrationParams.GP
+-/
 
-theorem henstock_le_riemann : henstock ≤ riemann := by decide
+/- warning: box_integral.integration_params.Henstock_le_Riemann -> BoxIntegral.IntegrationParams.henstock_le_riemann is a dubious translation:
+lean 3 declaration is
+  LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) BoxIntegral.IntegrationParams.Henstock BoxIntegral.IntegrationParams.Riemann
+but is expected to have type
+  LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) BoxIntegral.IntegrationParams.Henstock BoxIntegral.IntegrationParams.Riemann
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.Henstock_le_Riemann BoxIntegral.IntegrationParams.henstock_le_riemannₓ'. -/
+theorem henstock_le_riemann : Henstock ≤ Riemann := by decide
 #align box_integral.integration_params.Henstock_le_Riemann BoxIntegral.IntegrationParams.henstock_le_riemann
 
-theorem henstock_le_mcShane : henstock ≤ mcShane := by decide
+/- warning: box_integral.integration_params.Henstock_le_McShane -> BoxIntegral.IntegrationParams.henstock_le_mcShane is a dubious translation:
+lean 3 declaration is
+  LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) BoxIntegral.IntegrationParams.Henstock BoxIntegral.IntegrationParams.McShane
+but is expected to have type
+  LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) BoxIntegral.IntegrationParams.Henstock BoxIntegral.IntegrationParams.McShane
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.Henstock_le_McShane BoxIntegral.IntegrationParams.henstock_le_mcShaneₓ'. -/
+theorem henstock_le_mcShane : Henstock ≤ McShane := by decide
 #align box_integral.integration_params.Henstock_le_McShane BoxIntegral.IntegrationParams.henstock_le_mcShane
 
-theorem gP_le : gP ≤ l :=
+/- warning: box_integral.integration_params.GP_le -> BoxIntegral.IntegrationParams.gp_le is a dubious translation:
+lean 3 declaration is
+  forall {l : BoxIntegral.IntegrationParams}, LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) BoxIntegral.IntegrationParams.GP l
+but is expected to have type
+  forall {l : BoxIntegral.IntegrationParams}, LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) BoxIntegral.IntegrationParams.GP l
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.GP_le BoxIntegral.IntegrationParams.gp_leₓ'. -/
+theorem gp_le : GP ≤ l :=
   bot_le
-#align box_integral.integration_params.GP_le BoxIntegral.IntegrationParams.gP_le
-
+#align box_integral.integration_params.GP_le BoxIntegral.IntegrationParams.gp_le
+
+/- warning: box_integral.integration_params.mem_base_set -> BoxIntegral.IntegrationParams.MemBaseSet is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι], BoxIntegral.IntegrationParams -> (forall (I : BoxIntegral.Box.{u1} ι), NNReal -> ((ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) -> (BoxIntegral.TaggedPrepartition.{u1} ι I) -> Prop)
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι], BoxIntegral.IntegrationParams -> (forall (I : BoxIntegral.Box.{u1} ι), NNReal -> ((ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) -> (BoxIntegral.TaggedPrepartition.{u1} ι I) -> Prop)
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.mem_base_set BoxIntegral.IntegrationParams.MemBaseSetₓ'. -/
 /-- The predicate corresponding to a base set of the filter defined by an
 `integration_params`. It says that
 
@@ -303,11 +345,18 @@ structure MemBaseSet (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) (r : (ι
   exists_compl : l.bDistortion → ∃ π' : Prepartition I, π'.iUnion = I \ π.iUnion ∧ π'.distortion ≤ c
 #align box_integral.integration_params.mem_base_set BoxIntegral.IntegrationParams.MemBaseSet
 
+/- warning: box_integral.integration_params.r_cond -> BoxIntegral.IntegrationParams.RCond is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}}, BoxIntegral.IntegrationParams -> ((ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) -> Prop
+but is expected to have type
+  forall {ι : Type.{u1}}, BoxIntegral.IntegrationParams -> ((ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) -> Prop
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.r_cond BoxIntegral.IntegrationParams.RCondₓ'. -/
 /-- A predicate saying that in case `l.bRiemann = tt`, the function `r` is a constant. -/
 def RCond {ι : Type _} (l : IntegrationParams) (r : (ι → ℝ) → Ioi (0 : ℝ)) : Prop :=
   l.bRiemann → ∀ x, r x = r 0
 #align box_integral.integration_params.r_cond BoxIntegral.IntegrationParams.RCond
 
+#print BoxIntegral.IntegrationParams.toFilterDistortion /-
 /-- A set `s : set (tagged_prepartition I)` belongs to `l.to_filter_distortion I c` if there exists
 a function `r : ℝⁿ → (0, ∞)` (or a constant `r` if `l.bRiemann = tt`) such that `s` contains each
 prepartition `π` such that `l.mem_base_set I c r π`. -/
@@ -315,37 +364,62 @@ def toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) :
     Filter (TaggedPrepartition I) :=
   ⨅ (r : (ι → ℝ) → Ioi (0 : ℝ)) (hr : l.RCond r), 𝓟 { π | l.MemBaseSet I c r π }
 #align box_integral.integration_params.to_filter_distortion BoxIntegral.IntegrationParams.toFilterDistortion
+-/
 
+#print BoxIntegral.IntegrationParams.toFilter /-
 /-- A set `s : set (tagged_prepartition I)` belongs to `l.to_filter I` if for any `c : ℝ≥0` there
 exists a function `r : ℝⁿ → (0, ∞)` (or a constant `r` if `l.bRiemann = tt`) such that
 `s` contains each prepartition `π` such that `l.mem_base_set I c r π`. -/
 def toFilter (l : IntegrationParams) (I : Box ι) : Filter (TaggedPrepartition I) :=
   ⨆ c : ℝ≥0, l.toFilterDistortion I c
 #align box_integral.integration_params.to_filter BoxIntegral.IntegrationParams.toFilter
+-/
 
+#print BoxIntegral.IntegrationParams.toFilterDistortioniUnion /-
 /-- A set `s : set (tagged_prepartition I)` belongs to `l.to_filter_distortion_Union I c π₀` if
 there exists a function `r : ℝⁿ → (0, ∞)` (or a constant `r` if `l.bRiemann = tt`) such that `s`
 contains each prepartition `π` such that `l.mem_base_set I c r π` and `π.Union = π₀.Union`. -/
-def toFilterDistortionUnion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) (π₀ : Prepartition I) :=
+def toFilterDistortioniUnion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) (π₀ : Prepartition I) :=
   l.toFilterDistortion I c ⊓ 𝓟 { π | π.iUnion = π₀.iUnion }
-#align box_integral.integration_params.to_filter_distortion_Union BoxIntegral.IntegrationParams.toFilterDistortionUnion
+#align box_integral.integration_params.to_filter_distortion_Union BoxIntegral.IntegrationParams.toFilterDistortioniUnion
+-/
 
+#print BoxIntegral.IntegrationParams.toFilteriUnion /-
 /-- A set `s : set (tagged_prepartition I)` belongs to `l.to_filter_Union I π₀` if for any `c : ℝ≥0`
 there exists a function `r : ℝⁿ → (0, ∞)` (or a constant `r` if `l.bRiemann = tt`) such that `s`
 contains each prepartition `π` such that `l.mem_base_set I c r π` and `π.Union = π₀.Union`. -/
-def toFilterUnion (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :=
-  ⨆ c : ℝ≥0, l.toFilterDistortionUnion I c π₀
-#align box_integral.integration_params.to_filter_Union BoxIntegral.IntegrationParams.toFilterUnion
+def toFilteriUnion (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :=
+  ⨆ c : ℝ≥0, l.toFilterDistortioniUnion I c π₀
+#align box_integral.integration_params.to_filter_Union BoxIntegral.IntegrationParams.toFilteriUnion
+-/
 
+/- warning: box_integral.integration_params.r_cond_of_bRiemann_eq_ff -> BoxIntegral.IntegrationParams.rCond_of_bRiemann_eq_false is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} (l : BoxIntegral.IntegrationParams), (Eq.{1} Bool (BoxIntegral.IntegrationParams.bRiemann l) Bool.false) -> (forall {r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))}, BoxIntegral.IntegrationParams.RCond.{u1} ι l r)
+but is expected to have type
+  forall {ι : Type.{u1}} (l : BoxIntegral.IntegrationParams), (Eq.{1} Bool (BoxIntegral.IntegrationParams.bRiemann l) Bool.false) -> (forall {r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))}, BoxIntegral.IntegrationParams.RCond.{u1} ι l r)
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.r_cond_of_bRiemann_eq_ff BoxIntegral.IntegrationParams.rCond_of_bRiemann_eq_falseₓ'. -/
 theorem rCond_of_bRiemann_eq_false {ι} (l : IntegrationParams) (hl : l.bRiemann = false)
     {r : (ι → ℝ) → Ioi (0 : ℝ)} : l.RCond r := by simp [r_cond, hl]
 #align box_integral.integration_params.r_cond_of_bRiemann_eq_ff BoxIntegral.IntegrationParams.rCond_of_bRiemann_eq_false
 
+/- warning: box_integral.integration_params.to_filter_inf_Union_eq -> BoxIntegral.IntegrationParams.toFilter_inf_iUnion_eq is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (π₀ : BoxIntegral.Prepartition.{u1} ι I), Eq.{succ u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Inf.inf.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.hasInf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l I) (Filter.principal.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀))))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l I π₀)
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (π₀ : BoxIntegral.Prepartition.{u1} ι I), Eq.{succ u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Inf.inf.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.instInfFilter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l I) (Filter.principal.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀))))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l I π₀)
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.to_filter_inf_Union_eq BoxIntegral.IntegrationParams.toFilter_inf_iUnion_eqₓ'. -/
 theorem toFilter_inf_iUnion_eq (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
-    l.toFilter I ⊓ 𝓟 { π | π.iUnion = π₀.iUnion } = l.toFilterUnion I π₀ :=
+    l.toFilter I ⊓ 𝓟 { π | π.iUnion = π₀.iUnion } = l.toFilteriUnion I π₀ :=
   (iSup_inf_principal _ _).symm
 #align box_integral.integration_params.to_filter_inf_Union_eq BoxIntegral.IntegrationParams.toFilter_inf_iUnion_eq
 
+/- warning: box_integral.integration_params.mem_base_set.mono' -> BoxIntegral.IntegrationParams.MemBaseSet.mono' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c₁ : NNReal} {c₂ : NNReal} {r₁ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {r₂ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) l₁ l₂) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) c₁ c₂) -> (forall {π : BoxIntegral.TaggedPrepartition.{u1} ι I}, (forall (J : BoxIntegral.Box.{u1} ι), (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.TaggedPrepartition.{u1} ι I) (BoxIntegral.TaggedPrepartition.hasMem.{u1} ι I) J π) -> (LE.le.{0} (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) (Subtype.hasLe.{0} Real Real.hasLe (fun (x : Real) => Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (r₁ (BoxIntegral.TaggedPrepartition.tag.{u1} ι I π J)) (r₂ (BoxIntegral.TaggedPrepartition.tag.{u1} ι I π J)))) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₁ I c₁ r₁ π) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₂ I c₂ r₂ π))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c₁ : NNReal} {c₂ : NNReal} {r₁ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {r₂ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) l₁ l₂) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) c₁ c₂) -> (forall {π : BoxIntegral.TaggedPrepartition.{u1} ι I}, (forall (J : BoxIntegral.Box.{u1} ι), (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.TaggedPrepartition.{u1} ι I) (BoxIntegral.TaggedPrepartition.instMembershipBoxTaggedPrepartition.{u1} ι I) J π) -> (LE.le.{0} (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) (Subtype.le.{0} Real Real.instLEReal (fun (x : Real) => Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (r₁ (BoxIntegral.TaggedPrepartition.tag.{u1} ι I π J)) (r₂ (BoxIntegral.TaggedPrepartition.tag.{u1} ι I π J)))) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₁ I c₁ r₁ π) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₂ I c₂ r₂ π))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.mem_base_set.mono' BoxIntegral.IntegrationParams.MemBaseSet.mono'ₓ'. -/
 theorem MemBaseSet.mono' (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {π : TaggedPrepartition I}
     (hr : ∀ J ∈ π, r₁ (π.Tag J) ≤ r₂ (π.Tag J)) (hπ : l₁.MemBaseSet I c₁ r₁ π) :
     l₂.MemBaseSet I c₂ r₂ π :=
@@ -354,12 +428,24 @@ theorem MemBaseSet.mono' (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {
     (hπ.4 (le_iff_imp.1 h.2.2 hD)).imp fun π hπ => ⟨hπ.1, hπ.2.trans hc⟩⟩
 #align box_integral.integration_params.mem_base_set.mono' BoxIntegral.IntegrationParams.MemBaseSet.mono'
 
+/- warning: box_integral.integration_params.mem_base_set.mono -> BoxIntegral.IntegrationParams.MemBaseSet.mono is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c₁ : NNReal} {c₂ : NNReal} {r₁ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {r₂ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) l₁ l₂) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) c₁ c₂) -> (forall {π : BoxIntegral.TaggedPrepartition.{u1} ι I}, (forall (x : ι -> Real), (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) x (coeFn.{succ u1, succ u1} (OrderEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.hasLe.{u1} ι) (Set.hasLe.{u1} (ι -> Real))) (fun (_x : RelEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) (LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.hasLe.{u1} (ι -> Real)))) => (BoxIntegral.Box.{u1} ι) -> (Set.{u1} (ι -> Real))) (RelEmbedding.hasCoeToFun.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) (LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.hasLe.{u1} (ι -> Real)))) (BoxIntegral.Box.Icc.{u1} ι) I)) -> (LE.le.{0} (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) (Subtype.hasLe.{0} Real Real.hasLe (fun (x : Real) => Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (r₁ x) (r₂ x))) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₁ I c₁ r₁ π) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₂ I c₂ r₂ π))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c₁ : NNReal} {c₂ : NNReal} {r₁ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {r₂ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) l₁ l₂) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) c₁ c₂) -> (forall {π : BoxIntegral.TaggedPrepartition.{u1} ι I}, (forall (x : ι -> Real), (Membership.mem.{u1, u1} (ι -> Real) ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : BoxIntegral.Box.{u1} ι) => Set.{u1} (ι -> Real)) I) (Set.instMembershipSet.{u1} (ι -> Real)) x (FunLike.coe.{succ u1, succ u1, succ u1} (OrderEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.instLEBox.{u1} ι) (Set.instLESet.{u1} (ι -> Real))) (BoxIntegral.Box.{u1} ι) (fun (_x : BoxIntegral.Box.{u1} ι) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : BoxIntegral.Box.{u1} ι) => Set.{u1} (ι -> Real)) _x) (RelHomClass.toFunLike.{u1, u1, u1} (OrderEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.instLEBox.{u1} ι) (Set.instLESet.{u1} (ι -> Real))) (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : BoxIntegral.Box.{u1} ι) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : BoxIntegral.Box.{u1} ι) => LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instLEBox.{u1} ι) x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Set.{u1} (ι -> Real)) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Set.{u1} (ι -> Real)) => LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.instLESet.{u1} (ι -> Real)) x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699) (RelEmbedding.instRelHomClassRelEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : BoxIntegral.Box.{u1} ι) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : BoxIntegral.Box.{u1} ι) => LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instLEBox.{u1} ι) x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Set.{u1} (ι -> Real)) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Set.{u1} (ι -> Real)) => LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.instLESet.{u1} (ι -> Real)) x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699))) (BoxIntegral.Box.Icc.{u1} ι) I)) -> (LE.le.{0} (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) (Subtype.le.{0} Real Real.instLEReal (fun (x : Real) => Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (r₁ x) (r₂ x))) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₁ I c₁ r₁ π) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l₂ I c₂ r₂ π))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.mem_base_set.mono BoxIntegral.IntegrationParams.MemBaseSet.monoₓ'. -/
 @[mono]
 theorem MemBaseSet.mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {π : TaggedPrepartition I}
     (hr : ∀ x ∈ I.Icc, r₁ x ≤ r₂ x) (hπ : l₁.MemBaseSet I c₁ r₁ π) : l₂.MemBaseSet I c₂ r₂ π :=
   hπ.mono' I h hc fun J hJ => hr _ <| π.tag_mem_Icc J
 #align box_integral.integration_params.mem_base_set.mono BoxIntegral.IntegrationParams.MemBaseSet.mono
 
+/- warning: box_integral.integration_params.mem_base_set.exists_common_compl -> BoxIntegral.IntegrationParams.MemBaseSet.exists_common_compl is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c₁ : NNReal} {c₂ : NNReal} {r₁ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {r₂ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {π₁ : BoxIntegral.TaggedPrepartition.{u1} ι I} {π₂ : BoxIntegral.TaggedPrepartition.{u1} ι I} {l : BoxIntegral.IntegrationParams}, (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c₁ r₁ π₁) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c₂ r₂ π₂) -> (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₁) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₂)) -> (Exists.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (fun (π : BoxIntegral.Prepartition.{u1} ι I) => And (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.iUnion.{u1} ι I π) (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} (ι -> Real)) (Set.booleanAlgebra.{u1} (ι -> Real))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.Set.hasCoeT.{u1} ι))) I) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₁))) (And ((coeSort.{1, 1} Bool Prop coeSortBool (BoxIntegral.IntegrationParams.bDistortion l)) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I π _inst_1) c₁)) ((coeSort.{1, 1} Bool Prop coeSortBool (BoxIntegral.IntegrationParams.bDistortion l)) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I π _inst_1) c₂)))))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c₁ : NNReal} {c₂ : NNReal} {r₁ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {r₂ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {π₁ : BoxIntegral.TaggedPrepartition.{u1} ι I} {π₂ : BoxIntegral.TaggedPrepartition.{u1} ι I} {l : BoxIntegral.IntegrationParams}, (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c₁ r₁ π₁) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c₂ r₂ π₂) -> (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₁) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₂)) -> (Exists.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (fun (π : BoxIntegral.Prepartition.{u1} ι I) => And (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.iUnion.{u1} ι I π) (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (Set.instSDiffSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₁))) (And ((Eq.{1} Bool (BoxIntegral.IntegrationParams.bDistortion l) Bool.true) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I π _inst_1) c₁)) ((Eq.{1} Bool (BoxIntegral.IntegrationParams.bDistortion l) Bool.true) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I π _inst_1) c₂)))))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.mem_base_set.exists_common_compl BoxIntegral.IntegrationParams.MemBaseSet.exists_common_complₓ'. -/
 theorem MemBaseSet.exists_common_compl (h₁ : l.MemBaseSet I c₁ r₁ π₁) (h₂ : l.MemBaseSet I c₂ r₂ π₂)
     (hU : π₁.iUnion = π₂.iUnion) :
     ∃ π : Prepartition I,
@@ -377,6 +463,12 @@ theorem MemBaseSet.exists_common_compl (h₁ : l.MemBaseSet I c₁ r₁ π₁) (
         (hD h).elim⟩
 #align box_integral.integration_params.mem_base_set.exists_common_compl BoxIntegral.IntegrationParams.MemBaseSet.exists_common_compl
 
+/- warning: box_integral.integration_params.mem_base_set.union_compl_to_subordinate -> BoxIntegral.IntegrationParams.MemBaseSet.unionComplToSubordinate is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} {r₁ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {r₂ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {π₁ : BoxIntegral.TaggedPrepartition.{u1} ι I} {l : BoxIntegral.IntegrationParams}, (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r₁ π₁) -> (forall (x : ι -> Real), (Membership.Mem.{u1, u1} (ι -> Real) (Set.{u1} (ι -> Real)) (Set.hasMem.{u1} (ι -> Real)) x (coeFn.{succ u1, succ u1} (OrderEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.hasLe.{u1} ι) (Set.hasLe.{u1} (ι -> Real))) (fun (_x : RelEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) (LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.hasLe.{u1} (ι -> Real)))) => (BoxIntegral.Box.{u1} ι) -> (Set.{u1} (ι -> Real))) (RelEmbedding.hasCoeToFun.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) (LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.hasLe.{u1} (ι -> Real)))) (BoxIntegral.Box.Icc.{u1} ι) I)) -> (LE.le.{0} (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) (Subtype.hasLe.{0} Real Real.hasLe (fun (x : Real) => Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (r₂ x) (r₁ x))) -> (forall {π₂ : BoxIntegral.Prepartition.{u1} ι I} (hU : Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₂) (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} (ι -> Real)) (Set.booleanAlgebra.{u1} (ι -> Real))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.Set.hasCoeT.{u1} ι))) I) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₁))), ((coeSort.{1, 1} Bool Prop coeSortBool (BoxIntegral.IntegrationParams.bDistortion l)) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I π₂ _inst_1) c)) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r₁ (BoxIntegral.TaggedPrepartition.unionComplToSubordinate.{u1} ι _inst_1 I π₁ π₂ hU r₂)))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} {r₁ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {r₂ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {π₁ : BoxIntegral.TaggedPrepartition.{u1} ι I} {l : BoxIntegral.IntegrationParams}, (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r₁ π₁) -> (forall (x : ι -> Real), (Membership.mem.{u1, u1} (ι -> Real) ((fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : BoxIntegral.Box.{u1} ι) => Set.{u1} (ι -> Real)) I) (Set.instMembershipSet.{u1} (ι -> Real)) x (FunLike.coe.{succ u1, succ u1, succ u1} (OrderEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.instLEBox.{u1} ι) (Set.instLESet.{u1} (ι -> Real))) (BoxIntegral.Box.{u1} ι) (fun (_x : BoxIntegral.Box.{u1} ι) => (fun (x._@.Mathlib.Order.RelIso.Basic._hyg.869 : BoxIntegral.Box.{u1} ι) => Set.{u1} (ι -> Real)) _x) (RelHomClass.toFunLike.{u1, u1, u1} (OrderEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.instLEBox.{u1} ι) (Set.instLESet.{u1} (ι -> Real))) (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : BoxIntegral.Box.{u1} ι) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : BoxIntegral.Box.{u1} ι) => LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instLEBox.{u1} ι) x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Set.{u1} (ι -> Real)) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Set.{u1} (ι -> Real)) => LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.instLESet.{u1} (ι -> Real)) x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699) (RelEmbedding.instRelHomClassRelEmbedding.{u1, u1} (BoxIntegral.Box.{u1} ι) (Set.{u1} (ι -> Real)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.682 : BoxIntegral.Box.{u1} ι) (x._@.Mathlib.Order.Hom.Basic._hyg.684 : BoxIntegral.Box.{u1} ι) => LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instLEBox.{u1} ι) x._@.Mathlib.Order.Hom.Basic._hyg.682 x._@.Mathlib.Order.Hom.Basic._hyg.684) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.697 : Set.{u1} (ι -> Real)) (x._@.Mathlib.Order.Hom.Basic._hyg.699 : Set.{u1} (ι -> Real)) => LE.le.{u1} (Set.{u1} (ι -> Real)) (Set.instLESet.{u1} (ι -> Real)) x._@.Mathlib.Order.Hom.Basic._hyg.697 x._@.Mathlib.Order.Hom.Basic._hyg.699))) (BoxIntegral.Box.Icc.{u1} ι) I)) -> (LE.le.{0} (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) (Subtype.le.{0} Real Real.instLEReal (fun (x : Real) => Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (r₂ x) (r₁ x))) -> (forall {π₂ : BoxIntegral.Prepartition.{u1} ι I} (hU : Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₂) (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (Set.instSDiffSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π₁))), ((Eq.{1} Bool (BoxIntegral.IntegrationParams.bDistortion l) Bool.true) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I π₂ _inst_1) c)) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r₁ (BoxIntegral.TaggedPrepartition.unionComplToSubordinate.{u1} ι _inst_1 I π₁ π₂ hU r₂)))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.mem_base_set.union_compl_to_subordinate BoxIntegral.IntegrationParams.MemBaseSet.unionComplToSubordinateₓ'. -/
 protected theorem MemBaseSet.unionComplToSubordinate (hπ₁ : l.MemBaseSet I c r₁ π₁)
     (hle : ∀ x ∈ I.Icc, r₂ x ≤ r₁ x) {π₂ : Prepartition I} (hU : π₂.iUnion = I \ π₁.iUnion)
     (hc : l.bDistortion → π₂.distortion ≤ c) :
@@ -387,6 +479,12 @@ protected theorem MemBaseSet.unionComplToSubordinate (hπ₁ : l.MemBaseSet I c
     ⟨⊥, by simp⟩⟩
 #align box_integral.integration_params.mem_base_set.union_compl_to_subordinate BoxIntegral.IntegrationParams.MemBaseSet.unionComplToSubordinate
 
+/- warning: box_integral.integration_params.mem_base_set.filter -> BoxIntegral.IntegrationParams.MemBaseSet.filter is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} {r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {π : BoxIntegral.TaggedPrepartition.{u1} ι I} {l : BoxIntegral.IntegrationParams}, (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) -> (forall (p : (BoxIntegral.Box.{u1} ι) -> Prop), BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r (BoxIntegral.TaggedPrepartition.filter.{u1} ι I π p))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} {r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {π : BoxIntegral.TaggedPrepartition.{u1} ι I} {l : BoxIntegral.IntegrationParams}, (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) -> (forall (p : (BoxIntegral.Box.{u1} ι) -> Prop), BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r (BoxIntegral.TaggedPrepartition.filter.{u1} ι I π p))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.mem_base_set.filter BoxIntegral.IntegrationParams.MemBaseSet.filterₓ'. -/
 protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι → Prop) :
     l.MemBaseSet I c r (π.filterₓ p) :=
   by
@@ -411,7 +509,13 @@ protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι 
     simpa [hc]
 #align box_integral.integration_params.mem_base_set.filter BoxIntegral.IntegrationParams.MemBaseSet.filter
 
-theorem bUnionTaggedMemBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepartition J}
+/- warning: box_integral.integration_params.bUnion_tagged_mem_base_set -> BoxIntegral.IntegrationParams.biUnionTagged_memBaseSet is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} {r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {l : BoxIntegral.IntegrationParams} {π : BoxIntegral.Prepartition.{u1} ι I} {πi : forall (J : BoxIntegral.Box.{u1} ι), BoxIntegral.TaggedPrepartition.{u1} ι J}, (forall (J : BoxIntegral.Box.{u1} ι), (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) J π) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l J c r (πi J))) -> (forall (J : BoxIntegral.Box.{u1} ι), (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) J π) -> (BoxIntegral.TaggedPrepartition.IsPartition.{u1} ι J (πi J))) -> ((coeSort.{1, 1} Bool Prop coeSortBool (BoxIntegral.IntegrationParams.bDistortion l)) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I (Finite.of_fintype.{u1} ι _inst_1) π) _inst_1) c)) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r (BoxIntegral.Prepartition.biUnionTagged.{u1} ι I π πi))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} {r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {l : BoxIntegral.IntegrationParams} {π : BoxIntegral.Prepartition.{u1} ι I} {πi : forall (J : BoxIntegral.Box.{u1} ι), BoxIntegral.TaggedPrepartition.{u1} ι J}, (forall (J : BoxIntegral.Box.{u1} ι), (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) J π) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l J c r (πi J))) -> (forall (J : BoxIntegral.Box.{u1} ι), (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) J π) -> (BoxIntegral.TaggedPrepartition.IsPartition.{u1} ι J (πi J))) -> ((Eq.{1} Bool (BoxIntegral.IntegrationParams.bDistortion l) Bool.true) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I (Finite.of_fintype.{u1} ι _inst_1) π) _inst_1) c)) -> (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r (BoxIntegral.Prepartition.biUnionTagged.{u1} ι I π πi))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.bUnion_tagged_mem_base_set BoxIntegral.IntegrationParams.biUnionTagged_memBaseSetₓ'. -/
+theorem biUnionTagged_memBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepartition J}
     (h : ∀ J ∈ π, l.MemBaseSet J c r (πi J)) (hp : ∀ J ∈ π, (πi J).IsPartition)
     (hc : l.bDistortion → π.compl.distortion ≤ c) : l.MemBaseSet I c r (π.biUnionTagged πi) :=
   by
@@ -424,17 +528,35 @@ theorem bUnionTaggedMemBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepart
   · refine' ⟨_, _, hc hD⟩
     rw [π.Union_compl, ← π.Union_bUnion_partition hp]
     rfl
-#align box_integral.integration_params.bUnion_tagged_mem_base_set BoxIntegral.IntegrationParams.bUnionTaggedMemBaseSet
-
+#align box_integral.integration_params.bUnion_tagged_mem_base_set BoxIntegral.IntegrationParams.biUnionTagged_memBaseSet
+
+/- warning: box_integral.integration_params.r_cond.mono -> BoxIntegral.IntegrationParams.RCond.mono is a dubious translation:
+lean 3 declaration is
+  forall {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} {ι : Type.{u1}} {r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))}, (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) l₁ l₂) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l₂ r) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l₁ r)
+but is expected to have type
+  forall {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} {ι : Type.{u1}} {r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))}, (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) l₁ l₂) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l₂ r) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l₁ r)
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.r_cond.mono BoxIntegral.IntegrationParams.RCond.monoₓ'. -/
 @[mono]
 theorem RCond.mono {ι : Type _} {r : (ι → ℝ) → Ioi (0 : ℝ)} (h : l₁ ≤ l₂) (hr : l₂.RCond r) :
     l₁.RCond r := fun hR => hr (le_iff_imp.1 h.1 hR)
 #align box_integral.integration_params.r_cond.mono BoxIntegral.IntegrationParams.RCond.mono
 
+/- warning: box_integral.integration_params.r_cond.min -> BoxIntegral.IntegrationParams.RCond.min is a dubious translation:
+lean 3 declaration is
+  forall {l : BoxIntegral.IntegrationParams} {ι : Type.{u1}} {r₁ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))} {r₂ : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))}, (BoxIntegral.IntegrationParams.RCond.{u1} ι l r₁) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l r₂) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l (fun (x : ι -> Real) => LinearOrder.min.{0} (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))) (Subtype.linearOrder.{0} Real Real.linearOrder (fun (x : Real) => Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (r₁ x) (r₂ x)))
+but is expected to have type
+  forall {l : BoxIntegral.IntegrationParams} {ι : Type.{u1}} {r₁ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))} {r₂ : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))}, (BoxIntegral.IntegrationParams.RCond.{u1} ι l r₁) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l r₂) -> (BoxIntegral.IntegrationParams.RCond.{u1} ι l (fun (x : ι -> Real) => Min.min.{0} (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) (LinearOrder.toMin.{0} (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))) (Subtype.linearOrder.{0} Real Real.linearOrder (fun (x : Real) => Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))))) (r₁ x) (r₂ x)))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.r_cond.min BoxIntegral.IntegrationParams.RCond.minₓ'. -/
 theorem RCond.min {ι : Type _} {r₁ r₂ : (ι → ℝ) → Ioi (0 : ℝ)} (h₁ : l.RCond r₁) (h₂ : l.RCond r₂) :
     l.RCond fun x => min (r₁ x) (r₂ x) := fun hR x => congr_arg₂ min (h₁ hR x) (h₂ hR x)
 #align box_integral.integration_params.r_cond.min BoxIntegral.IntegrationParams.RCond.min
 
+/- warning: box_integral.integration_params.to_filter_distortion_mono -> BoxIntegral.IntegrationParams.toFilterDistortion_mono is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c₁ : NNReal} {c₂ : NNReal} {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) l₁ l₂) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) c₁ c₂) -> (LE.le.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Preorder.toHasLe.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.partialOrder.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)))) (BoxIntegral.IntegrationParams.toFilterDistortion.{u1} ι _inst_1 l₁ I c₁) (BoxIntegral.IntegrationParams.toFilterDistortion.{u1} ι _inst_1 l₂ I c₂))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c₁ : NNReal} {c₂ : NNReal} {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams} (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) l₁ l₂) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) c₁ c₂) -> (LE.le.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Preorder.toLE.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.instPartialOrderFilter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)))) (BoxIntegral.IntegrationParams.toFilterDistortion.{u1} ι _inst_1 l₁ I c₁) (BoxIntegral.IntegrationParams.toFilterDistortion.{u1} ι _inst_1 l₂ I c₂))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.to_filter_distortion_mono BoxIntegral.IntegrationParams.toFilterDistortion_monoₓ'. -/
 @[mono]
 theorem toFilterDistortion_mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) :
     l₁.toFilterDistortion I c₁ ≤ l₂.toFilterDistortion I c₂ :=
@@ -443,23 +565,43 @@ theorem toFilterDistortion_mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤
       ⟨hr.mono h, principal_mono.2 fun _ => MemBaseSet.mono I h hc fun _ _ => le_rfl⟩
 #align box_integral.integration_params.to_filter_distortion_mono BoxIntegral.IntegrationParams.toFilterDistortion_mono
 
+/- warning: box_integral.integration_params.to_filter_mono -> BoxIntegral.IntegrationParams.toFilter_mono is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (I : BoxIntegral.Box.{u1} ι) {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams}, (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) l₁ l₂) -> (LE.le.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Preorder.toHasLe.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.partialOrder.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)))) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l₁ I) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l₂ I))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (I : BoxIntegral.Box.{u1} ι) {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams}, (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) l₁ l₂) -> (LE.le.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Preorder.toLE.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.instPartialOrderFilter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)))) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l₁ I) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l₂ I))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.to_filter_mono BoxIntegral.IntegrationParams.toFilter_monoₓ'. -/
 @[mono]
 theorem toFilter_mono (I : Box ι) {l₁ l₂ : IntegrationParams} (h : l₁ ≤ l₂) :
     l₁.toFilter I ≤ l₂.toFilter I :=
   iSup_mono fun c => toFilterDistortion_mono I h le_rfl
 #align box_integral.integration_params.to_filter_mono BoxIntegral.IntegrationParams.toFilter_mono
 
+/- warning: box_integral.integration_params.to_filter_Union_mono -> BoxIntegral.IntegrationParams.toFilteriUnion_mono is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (I : BoxIntegral.Box.{u1} ι) {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams}, (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toHasLe.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.partialOrder)) l₁ l₂) -> (forall (π₀ : BoxIntegral.Prepartition.{u1} ι I), LE.le.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Preorder.toHasLe.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.partialOrder.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l₁ I π₀) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l₂ I π₀))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (I : BoxIntegral.Box.{u1} ι) {l₁ : BoxIntegral.IntegrationParams} {l₂ : BoxIntegral.IntegrationParams}, (LE.le.{0} BoxIntegral.IntegrationParams (Preorder.toLE.{0} BoxIntegral.IntegrationParams (PartialOrder.toPreorder.{0} BoxIntegral.IntegrationParams BoxIntegral.IntegrationParams.instPartialOrderIntegrationParams)) l₁ l₂) -> (forall (π₀ : BoxIntegral.Prepartition.{u1} ι I), LE.le.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Preorder.toLE.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (PartialOrder.toPreorder.{u1} (Filter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)) (Filter.instPartialOrderFilter.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I)))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l₁ I π₀) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l₂ I π₀))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.to_filter_Union_mono BoxIntegral.IntegrationParams.toFilteriUnion_monoₓ'. -/
 @[mono]
-theorem toFilterUnion_mono (I : Box ι) {l₁ l₂ : IntegrationParams} (h : l₁ ≤ l₂)
-    (π₀ : Prepartition I) : l₁.toFilterUnion I π₀ ≤ l₂.toFilterUnion I π₀ :=
+theorem toFilteriUnion_mono (I : Box ι) {l₁ l₂ : IntegrationParams} (h : l₁ ≤ l₂)
+    (π₀ : Prepartition I) : l₁.toFilteriUnion I π₀ ≤ l₂.toFilteriUnion I π₀ :=
   iSup_mono fun c => inf_le_inf_right _ <| toFilterDistortion_mono _ h le_rfl
-#align box_integral.integration_params.to_filter_Union_mono BoxIntegral.IntegrationParams.toFilterUnion_mono
+#align box_integral.integration_params.to_filter_Union_mono BoxIntegral.IntegrationParams.toFilteriUnion_mono
 
-theorem toFilterUnion_congr (I : Box ι) (l : IntegrationParams) {π₁ π₂ : Prepartition I}
-    (h : π₁.iUnion = π₂.iUnion) : l.toFilterUnion I π₁ = l.toFilterUnion I π₂ := by
+#print BoxIntegral.IntegrationParams.toFilteriUnion_congr /-
+theorem toFilteriUnion_congr (I : Box ι) (l : IntegrationParams) {π₁ π₂ : Prepartition I}
+    (h : π₁.iUnion = π₂.iUnion) : l.toFilteriUnion I π₁ = l.toFilteriUnion I π₂ := by
   simp only [to_filter_Union, to_filter_distortion_Union, h]
-#align box_integral.integration_params.to_filter_Union_congr BoxIntegral.IntegrationParams.toFilterUnion_congr
+#align box_integral.integration_params.to_filter_Union_congr BoxIntegral.IntegrationParams.toFilteriUnion_congr
+-/
 
+/- warning: box_integral.integration_params.has_basis_to_filter_distortion -> BoxIntegral.IntegrationParams.hasBasis_toFilterDistortion is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (c : NNReal), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) ((ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (BoxIntegral.IntegrationParams.toFilterDistortion.{u1} ι _inst_1 l I c) (BoxIntegral.IntegrationParams.RCond.{u1} ι l) (fun (r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (c : NNReal), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) ((ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (BoxIntegral.IntegrationParams.toFilterDistortion.{u1} ι _inst_1 l I c) (BoxIntegral.IntegrationParams.RCond.{u1} ι l) (fun (r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.has_basis_to_filter_distortion BoxIntegral.IntegrationParams.hasBasis_toFilterDistortionₓ'. -/
 theorem hasBasis_toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) :
     (l.toFilterDistortion I c).HasBasis l.RCond fun r => { π | l.MemBaseSet I c r π } :=
   hasBasis_biInf_principal'
@@ -469,38 +611,63 @@ theorem hasBasis_toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : 
     ⟨fun _ => ⟨1, zero_lt_one⟩, fun _ _ => rfl⟩
 #align box_integral.integration_params.has_basis_to_filter_distortion BoxIntegral.IntegrationParams.hasBasis_toFilterDistortion
 
-theorem hasBasis_toFilterDistortionUnion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0)
+/- warning: box_integral.integration_params.has_basis_to_filter_distortion_Union -> BoxIntegral.IntegrationParams.hasBasis_toFilterDistortioniUnion is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (c : NNReal) (π₀ : BoxIntegral.Prepartition.{u1} ι I), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) ((ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (BoxIntegral.IntegrationParams.toFilterDistortioniUnion.{u1} ι _inst_1 l I c π₀) (BoxIntegral.IntegrationParams.RCond.{u1} ι l) (fun (r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀))))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (c : NNReal) (π₀ : BoxIntegral.Prepartition.{u1} ι I), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) ((ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (BoxIntegral.IntegrationParams.toFilterDistortioniUnion.{u1} ι _inst_1 l I c π₀) (BoxIntegral.IntegrationParams.RCond.{u1} ι l) (fun (r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀))))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.has_basis_to_filter_distortion_Union BoxIntegral.IntegrationParams.hasBasis_toFilterDistortioniUnionₓ'. -/
+theorem hasBasis_toFilterDistortioniUnion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0)
     (π₀ : Prepartition I) :
-    (l.toFilterDistortionUnion I c π₀).HasBasis l.RCond fun r =>
+    (l.toFilterDistortioniUnion I c π₀).HasBasis l.RCond fun r =>
       { π | l.MemBaseSet I c r π ∧ π.iUnion = π₀.iUnion } :=
   (l.hasBasis_toFilterDistortion I c).inf_principal _
-#align box_integral.integration_params.has_basis_to_filter_distortion_Union BoxIntegral.IntegrationParams.hasBasis_toFilterDistortionUnion
-
-theorem hasBasis_toFilterUnion (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
-    (l.toFilterUnion I π₀).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
+#align box_integral.integration_params.has_basis_to_filter_distortion_Union BoxIntegral.IntegrationParams.hasBasis_toFilterDistortioniUnion
+
+/- warning: box_integral.integration_params.has_basis_to_filter_Union -> BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (π₀ : BoxIntegral.Prepartition.{u1} ι I), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l I π₀) (fun (r : NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => forall (c : NNReal), BoxIntegral.IntegrationParams.RCond.{u1} ι l (r c)) (fun (r : NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Exists.{1} NNReal (fun (c : NNReal) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c (r c) π) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀)))))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (π₀ : BoxIntegral.Prepartition.{u1} ι I), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l I π₀) (fun (r : NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => forall (c : NNReal), BoxIntegral.IntegrationParams.RCond.{u1} ι l (r c)) (fun (r : NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Exists.{1} NNReal (fun (c : NNReal) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c (r c) π) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀)))))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.has_basis_to_filter_Union BoxIntegral.IntegrationParams.hasBasis_toFilteriUnionₓ'. -/
+theorem hasBasis_toFilteriUnion (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
+    (l.toFilteriUnion I π₀).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
       fun r => { π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.iUnion = π₀.iUnion } :=
   by
-  have := fun c => l.hasBasis_toFilterDistortionUnion I c π₀
+  have := fun c => l.hasBasis_toFilterDistortioniUnion I c π₀
   simpa only [set_of_and, set_of_exists] using has_basis_supr this
-#align box_integral.integration_params.has_basis_to_filter_Union BoxIntegral.IntegrationParams.hasBasis_toFilterUnion
-
-theorem hasBasis_toFilterUnion_top (l : IntegrationParams) (I : Box ι) :
-    (l.toFilterUnion I ⊤).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
+#align box_integral.integration_params.has_basis_to_filter_Union BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion
+
+/- warning: box_integral.integration_params.has_basis_to_filter_Union_top -> BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion_top is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l I (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toHasTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.orderTop.{u1} ι I)))) (fun (r : NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => forall (c : NNReal), BoxIntegral.IntegrationParams.RCond.{u1} ι l (r c)) (fun (r : NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Exists.{1} NNReal (fun (c : NNReal) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c (r c) π) (BoxIntegral.TaggedPrepartition.IsPartition.{u1} ι I π))))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (BoxIntegral.IntegrationParams.toFilteriUnion.{u1} ι _inst_1 l I (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.instOrderTopPrepartitionInstLEPrepartition.{u1} ι I)))) (fun (r : NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => forall (c : NNReal), BoxIntegral.IntegrationParams.RCond.{u1} ι l (r c)) (fun (r : NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Exists.{1} NNReal (fun (c : NNReal) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c (r c) π) (BoxIntegral.TaggedPrepartition.IsPartition.{u1} ι I π))))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.has_basis_to_filter_Union_top BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion_topₓ'. -/
+theorem hasBasis_toFilteriUnion_top (l : IntegrationParams) (I : Box ι) :
+    (l.toFilteriUnion I ⊤).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
       fun r => { π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.IsPartition } :=
   by
   simpa only [tagged_prepartition.is_partition_iff_Union_eq, prepartition.Union_top] using
     l.has_basis_to_filter_Union I ⊤
-#align box_integral.integration_params.has_basis_to_filter_Union_top BoxIntegral.IntegrationParams.hasBasis_toFilterUnion_top
-
+#align box_integral.integration_params.has_basis_to_filter_Union_top BoxIntegral.IntegrationParams.hasBasis_toFilteriUnion_top
+
+/- warning: box_integral.integration_params.has_basis_to_filter -> BoxIntegral.IntegrationParams.hasBasis_toFilter is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l I) (fun (r : NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => forall (c : NNReal), BoxIntegral.IntegrationParams.RCond.{u1} ι l (r c)) (fun (r : NNReal -> (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Exists.{1} NNReal (fun (c : NNReal) => BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c (r c) π)))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι), Filter.HasBasis.{u1, succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) (BoxIntegral.IntegrationParams.toFilter.{u1} ι _inst_1 l I) (fun (r : NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => forall (c : NNReal), BoxIntegral.IntegrationParams.RCond.{u1} ι l (r c)) (fun (r : NNReal -> (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))) => setOf.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => Exists.{1} NNReal (fun (c : NNReal) => BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c (r c) π)))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.has_basis_to_filter BoxIntegral.IntegrationParams.hasBasis_toFilterₓ'. -/
 theorem hasBasis_toFilter (l : IntegrationParams) (I : Box ι) :
     (l.toFilter I).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c)) fun r =>
       { π | ∃ c, l.MemBaseSet I c (r c) π } :=
   by simpa only [set_of_exists] using has_basis_supr (l.has_basis_to_filter_distortion I)
 #align box_integral.integration_params.has_basis_to_filter BoxIntegral.IntegrationParams.hasBasis_toFilter
 
-theorem tendsto_embedBox_toFilterUnion_top (l : IntegrationParams) (h : I ≤ J) :
-    Tendsto (TaggedPrepartition.embedBox I J h) (l.toFilterUnion I ⊤)
-      (l.toFilterUnion J (Prepartition.single J I h)) :=
+#print BoxIntegral.IntegrationParams.tendsto_embedBox_toFilteriUnion_top /-
+theorem tendsto_embedBox_toFilteriUnion_top (l : IntegrationParams) (h : I ≤ J) :
+    Tendsto (TaggedPrepartition.embedBox I J h) (l.toFilteriUnion I ⊤)
+      (l.toFilteriUnion J (Prepartition.single J I h)) :=
   by
   simp only [to_filter_Union, tendsto_supr]; intro c
   set π₀ := prepartition.single J I h
@@ -516,8 +683,15 @@ theorem tendsto_embedBox_toFilterUnion_top (l : IntegrationParams) (h : I ≤ J)
     congr 1
     exact (prepartition.Union_single h).trans hπ.2.symm
   · exact hπ.2.trans (prepartition.Union_single _).symm
-#align box_integral.integration_params.tendsto_embed_box_to_filter_Union_top BoxIntegral.IntegrationParams.tendsto_embedBox_toFilterUnion_top
+#align box_integral.integration_params.tendsto_embed_box_to_filter_Union_top BoxIntegral.IntegrationParams.tendsto_embedBox_toFilteriUnion_top
+-/
 
+/- warning: box_integral.integration_params.exists_mem_base_set_le_Union_eq -> BoxIntegral.IntegrationParams.exists_memBaseSet_le_iUnion_eq is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} (l : BoxIntegral.IntegrationParams) (π₀ : BoxIntegral.Prepartition.{u1} ι I), (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I π₀ _inst_1) c) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I (Finite.of_fintype.{u1} ι _inst_1) π₀) _inst_1) c) -> (forall (r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))), Exists.{succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) (And (LE.le.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.TaggedPrepartition.toPrepartition.{u1} ι I π) π₀) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀)))))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {I : BoxIntegral.Box.{u1} ι} {c : NNReal} (l : BoxIntegral.IntegrationParams) (π₀ : BoxIntegral.Prepartition.{u1} ι I), (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I π₀ _inst_1) c) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I (Finite.of_fintype.{u1} ι _inst_1) π₀) _inst_1) c) -> (forall (r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))), Exists.{succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) (And (LE.le.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.TaggedPrepartition.toPrepartition.{u1} ι I π) π₀) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.TaggedPrepartition.iUnion.{u1} ι I π) (BoxIntegral.Prepartition.iUnion.{u1} ι I π₀)))))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.exists_mem_base_set_le_Union_eq BoxIntegral.IntegrationParams.exists_memBaseSet_le_iUnion_eqₓ'. -/
 theorem exists_memBaseSet_le_iUnion_eq (l : IntegrationParams) (π₀ : Prepartition I)
     (hc₁ : π₀.distortion ≤ c) (hc₂ : π₀.compl.distortion ≤ c) (r : (ι → ℝ) → Ioi (0 : ℝ)) :
     ∃ π, l.MemBaseSet I c r π ∧ π.toPrepartition ≤ π₀ ∧ π.iUnion = π₀.iUnion :=
@@ -527,6 +701,12 @@ theorem exists_memBaseSet_le_iUnion_eq (l : IntegrationParams) (π₀ : Preparti
   exact prepartition.compl_congr hU ▸ π.to_prepartition.Union_compl
 #align box_integral.integration_params.exists_mem_base_set_le_Union_eq BoxIntegral.IntegrationParams.exists_memBaseSet_le_iUnion_eq
 
+/- warning: box_integral.integration_params.exists_mem_base_set_is_partition -> BoxIntegral.IntegrationParams.exists_memBaseSet_isPartition is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c : NNReal} (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Box.distortion.{u1} ι _inst_1 I) c) -> (forall (r : (ι -> Real) -> (coeSort.{1, 2} (Set.{0} Real) Type (Set.hasCoeToSort.{0} Real) (Set.Ioi.{0} Real Real.preorder (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero)))))), Exists.{succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) (BoxIntegral.TaggedPrepartition.IsPartition.{u1} ι I π)))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c : NNReal} (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι), (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Box.distortion.{u1} ι _inst_1 I) c) -> (forall (r : (ι -> Real) -> (Set.Elem.{0} Real (Set.Ioi.{0} Real Real.instPreorderReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal))))), Exists.{succ u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (fun (π : BoxIntegral.TaggedPrepartition.{u1} ι I) => And (BoxIntegral.IntegrationParams.MemBaseSet.{u1} ι _inst_1 l I c r π) (BoxIntegral.TaggedPrepartition.IsPartition.{u1} ι I π)))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.exists_mem_base_set_is_partition BoxIntegral.IntegrationParams.exists_memBaseSet_isPartitionₓ'. -/
 theorem exists_memBaseSet_isPartition (l : IntegrationParams) (I : Box ι) (hc : I.distortion ≤ c)
     (r : (ι → ℝ) → Ioi (0 : ℝ)) : ∃ π, l.MemBaseSet I c r π ∧ π.IsPartition :=
   by
@@ -535,40 +715,56 @@ theorem exists_memBaseSet_isPartition (l : IntegrationParams) (I : Box ι) (hc :
   simpa [is_partition_iff_Union_eq] using l.exists_mem_base_set_le_Union_eq ⊤ hc hc' r
 #align box_integral.integration_params.exists_mem_base_set_is_partition BoxIntegral.IntegrationParams.exists_memBaseSet_isPartition
 
-theorem toFilterDistortionUnion_neBot (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I)
+/- warning: box_integral.integration_params.to_filter_distortion_Union_ne_bot -> BoxIntegral.IntegrationParams.toFilterDistortioniUnion_neBot is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c : NNReal} (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (π₀ : BoxIntegral.Prepartition.{u1} ι I), (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I π₀ _inst_1) c) -> (LE.le.{0} NNReal (Preorder.toHasLe.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (BoxIntegral.Prepartition.distortion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I (Finite.of_fintype.{u1} ι _inst_1) π₀) _inst_1) c) -> (Filter.NeBot.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (BoxIntegral.IntegrationParams.toFilterDistortioniUnion.{u1} ι _inst_1 l I c π₀))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Fintype.{u1} ι] {c : NNReal} (l : BoxIntegral.IntegrationParams) (I : BoxIntegral.Box.{u1} ι) (π₀ : BoxIntegral.Prepartition.{u1} ι I), (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I π₀ _inst_1) c) -> (LE.le.{0} NNReal (Preorder.toLE.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (BoxIntegral.Prepartition.distortion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I (Finite.of_fintype.{u1} ι _inst_1) π₀) _inst_1) c) -> (Filter.NeBot.{u1} (BoxIntegral.TaggedPrepartition.{u1} ι I) (BoxIntegral.IntegrationParams.toFilterDistortioniUnion.{u1} ι _inst_1 l I c π₀))
+Case conversion may be inaccurate. Consider using '#align box_integral.integration_params.to_filter_distortion_Union_ne_bot BoxIntegral.IntegrationParams.toFilterDistortioniUnion_neBotₓ'. -/
+theorem toFilterDistortioniUnion_neBot (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I)
     (hc₁ : π₀.distortion ≤ c) (hc₂ : π₀.compl.distortion ≤ c) :
-    (l.toFilterDistortionUnion I c π₀).ne_bot :=
+    (l.toFilterDistortioniUnion I c π₀).ne_bot :=
   ((l.hasBasis_toFilterDistortion I _).inf_principal _).neBot_iff.2 fun r hr =>
     (l.exists_memBaseSet_le_iUnion_eq π₀ hc₁ hc₂ r).imp fun π hπ => ⟨hπ.1, hπ.2.2⟩
-#align box_integral.integration_params.to_filter_distortion_Union_ne_bot BoxIntegral.IntegrationParams.toFilterDistortionUnion_neBot
+#align box_integral.integration_params.to_filter_distortion_Union_ne_bot BoxIntegral.IntegrationParams.toFilterDistortioniUnion_neBot
 
-instance toFilterDistortionUnion_ne_bot' (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
-    (l.toFilterDistortionUnion I (max π₀.distortion π₀.compl.distortion) π₀).ne_bot :=
-  l.toFilterDistortionUnion_neBot I π₀ (le_max_left _ _) (le_max_right _ _)
-#align box_integral.integration_params.to_filter_distortion_Union_ne_bot' BoxIntegral.IntegrationParams.toFilterDistortionUnion_ne_bot'
+#print BoxIntegral.IntegrationParams.toFilterDistortioniUnion_neBot' /-
+instance toFilterDistortioniUnion_neBot' (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
+    (l.toFilterDistortioniUnion I (max π₀.distortion π₀.compl.distortion) π₀).ne_bot :=
+  l.toFilterDistortioniUnion_neBot I π₀ (le_max_left _ _) (le_max_right _ _)
+#align box_integral.integration_params.to_filter_distortion_Union_ne_bot' BoxIntegral.IntegrationParams.toFilterDistortioniUnion_neBot'
+-/
 
+#print BoxIntegral.IntegrationParams.toFilterDistortion_neBot /-
 instance toFilterDistortion_neBot (l : IntegrationParams) (I : Box ι) :
     (l.toFilterDistortion I I.distortion).ne_bot := by
   simpa using (l.to_filter_distortion_Union_ne_bot' I ⊤).mono inf_le_left
 #align box_integral.integration_params.to_filter_distortion_ne_bot BoxIntegral.IntegrationParams.toFilterDistortion_neBot
+-/
 
+#print BoxIntegral.IntegrationParams.toFilter_neBot /-
 instance toFilter_neBot (l : IntegrationParams) (I : Box ι) : (l.toFilter I).ne_bot :=
   (l.toFilterDistortion_neBot I).mono <| le_iSup _ _
 #align box_integral.integration_params.to_filter_ne_bot BoxIntegral.IntegrationParams.toFilter_neBot
+-/
 
-instance toFilterUnion_neBot (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
-    (l.toFilterUnion I π₀).ne_bot :=
-  (l.toFilterDistortionUnion_ne_bot' I π₀).mono <|
-    le_iSup (fun c => l.toFilterDistortionUnion I c π₀) _
-#align box_integral.integration_params.to_filter_Union_ne_bot BoxIntegral.IntegrationParams.toFilterUnion_neBot
+#print BoxIntegral.IntegrationParams.toFilteriUnion_neBot /-
+instance toFilteriUnion_neBot (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
+    (l.toFilteriUnion I π₀).ne_bot :=
+  (l.toFilterDistortioniUnion_neBot' I π₀).mono <|
+    le_iSup (fun c => l.toFilterDistortioniUnion I c π₀) _
+#align box_integral.integration_params.to_filter_Union_ne_bot BoxIntegral.IntegrationParams.toFilteriUnion_neBot
+-/
 
+#print BoxIntegral.IntegrationParams.eventually_isPartition /-
 theorem eventually_isPartition (l : IntegrationParams) (I : Box ι) :
-    ∀ᶠ π in l.toFilterUnion I ⊤, TaggedPrepartition.IsPartition π :=
+    ∀ᶠ π in l.toFilteriUnion I ⊤, TaggedPrepartition.IsPartition π :=
   eventually_iSup.2 fun c =>
     eventually_inf_principal.2 <|
       eventually_of_forall fun π h =>
         π.isPartition_iff_iUnion_eq.2 (h.trans Prepartition.iUnion_top)
 #align box_integral.integration_params.eventually_is_partition BoxIntegral.IntegrationParams.eventually_isPartition
+-/
 
 end IntegrationParams
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

@@ -341,10 +341,10 @@ theorem rCond_of_bRiemann_eq_false {ι} (l : IntegrationParams) (hl : l.bRiemann
     {r : (ι → ℝ) → Ioi (0 : ℝ)} : l.RCond r := by simp [r_cond, hl]
 #align box_integral.integration_params.r_cond_of_bRiemann_eq_ff BoxIntegral.IntegrationParams.rCond_of_bRiemann_eq_false
 
-theorem toFilter_inf_union_eq (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
+theorem toFilter_inf_iUnion_eq (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
     l.toFilter I ⊓ 𝓟 { π | π.iUnion = π₀.iUnion } = l.toFilterUnion I π₀ :=
   (iSup_inf_principal _ _).symm
-#align box_integral.integration_params.to_filter_inf_Union_eq BoxIntegral.IntegrationParams.toFilter_inf_union_eq
+#align box_integral.integration_params.to_filter_inf_Union_eq BoxIntegral.IntegrationParams.toFilter_inf_iUnion_eq
 
 theorem MemBaseSet.mono' (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {π : TaggedPrepartition I}
     (hr : ∀ J ∈ π, r₁ (π.Tag J) ≤ r₂ (π.Tag J)) (hπ : l₁.MemBaseSet I c₁ r₁ π) :
@@ -411,9 +411,9 @@ protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι 
     simpa [hc]
 #align box_integral.integration_params.mem_base_set.filter BoxIntegral.IntegrationParams.MemBaseSet.filter
 
-theorem bUnionTagged_memBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepartition J}
+theorem bUnionTaggedMemBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepartition J}
     (h : ∀ J ∈ π, l.MemBaseSet J c r (πi J)) (hp : ∀ J ∈ π, (πi J).IsPartition)
-    (hc : l.bDistortion → π.compl.distortion ≤ c) : l.MemBaseSet I c r (π.bUnionTagged πi) :=
+    (hc : l.bDistortion → π.compl.distortion ≤ c) : l.MemBaseSet I c r (π.biUnionTagged πi) :=
   by
   refine'
     ⟨tagged_prepartition.is_subordinate_bUnion_tagged.2 fun J hJ => (h J hJ).1, fun hH =>
@@ -424,7 +424,7 @@ theorem bUnionTagged_memBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepar
   · refine' ⟨_, _, hc hD⟩
     rw [π.Union_compl, ← π.Union_bUnion_partition hp]
     rfl
-#align box_integral.integration_params.bUnion_tagged_mem_base_set BoxIntegral.IntegrationParams.bUnionTagged_memBaseSet
+#align box_integral.integration_params.bUnion_tagged_mem_base_set BoxIntegral.IntegrationParams.bUnionTaggedMemBaseSet
 
 @[mono]
 theorem RCond.mono {ι : Type _} {r : (ι → ℝ) → Ioi (0 : ℝ)} (h : l₁ ≤ l₂) (hr : l₂.RCond r) :
@@ -518,14 +518,14 @@ theorem tendsto_embedBox_toFilterUnion_top (l : IntegrationParams) (h : I ≤ J)
   · exact hπ.2.trans (prepartition.Union_single _).symm
 #align box_integral.integration_params.tendsto_embed_box_to_filter_Union_top BoxIntegral.IntegrationParams.tendsto_embedBox_toFilterUnion_top
 
-theorem exists_memBaseSet_le_union_eq (l : IntegrationParams) (π₀ : Prepartition I)
+theorem exists_memBaseSet_le_iUnion_eq (l : IntegrationParams) (π₀ : Prepartition I)
     (hc₁ : π₀.distortion ≤ c) (hc₂ : π₀.compl.distortion ≤ c) (r : (ι → ℝ) → Ioi (0 : ℝ)) :
     ∃ π, l.MemBaseSet I c r π ∧ π.toPrepartition ≤ π₀ ∧ π.iUnion = π₀.iUnion :=
   by
   rcases π₀.exists_tagged_le_is_Henstock_is_subordinate_Union_eq r with ⟨π, hle, hH, hr, hd, hU⟩
   refine' ⟨π, ⟨hr, fun _ => hH, fun _ => hd.trans_le hc₁, fun hD => ⟨π₀.compl, _, hc₂⟩⟩, ⟨hle, hU⟩⟩
   exact prepartition.compl_congr hU ▸ π.to_prepartition.Union_compl
-#align box_integral.integration_params.exists_mem_base_set_le_Union_eq BoxIntegral.IntegrationParams.exists_memBaseSet_le_union_eq
+#align box_integral.integration_params.exists_mem_base_set_le_Union_eq BoxIntegral.IntegrationParams.exists_memBaseSet_le_iUnion_eq
 
 theorem exists_memBaseSet_isPartition (l : IntegrationParams) (I : Box ι) (hc : I.distortion ≤ c)
     (r : (ι → ℝ) → Ioi (0 : ℝ)) : ∃ π, l.MemBaseSet I c r π ∧ π.IsPartition :=
@@ -539,7 +539,7 @@ theorem toFilterDistortionUnion_neBot (l : IntegrationParams) (I : Box ι) (π
     (hc₁ : π₀.distortion ≤ c) (hc₂ : π₀.compl.distortion ≤ c) :
     (l.toFilterDistortionUnion I c π₀).ne_bot :=
   ((l.hasBasis_toFilterDistortion I _).inf_principal _).neBot_iff.2 fun r hr =>
-    (l.exists_memBaseSet_le_union_eq π₀ hc₁ hc₂ r).imp fun π hπ => ⟨hπ.1, hπ.2.2⟩
+    (l.exists_memBaseSet_le_iUnion_eq π₀ hc₁ hc₂ r).imp fun π hπ => ⟨hπ.1, hπ.2.2⟩
 #align box_integral.integration_params.to_filter_distortion_Union_ne_bot BoxIntegral.IntegrationParams.toFilterDistortionUnion_neBot
 
 instance toFilterDistortionUnion_ne_bot' (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/e3fb84046afd187b710170887195d50bada934ee

@@ -300,7 +300,7 @@ structure MemBaseSet (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) (r : (ι
   IsSubordinate : π.IsSubordinate r
   IsHenstock : l.bHenstock → π.IsHenstock
   distortion_le : l.bDistortion → π.distortion ≤ c
-  exists_compl : l.bDistortion → ∃ π' : Prepartition I, π'.unionᵢ = I \ π.unionᵢ ∧ π'.distortion ≤ c
+  exists_compl : l.bDistortion → ∃ π' : Prepartition I, π'.iUnion = I \ π.iUnion ∧ π'.distortion ≤ c
 #align box_integral.integration_params.mem_base_set BoxIntegral.IntegrationParams.MemBaseSet
 
 /-- A predicate saying that in case `l.bRiemann = tt`, the function `r` is a constant. -/
@@ -327,7 +327,7 @@ def toFilter (l : IntegrationParams) (I : Box ι) : Filter (TaggedPrepartition I
 there exists a function `r : ℝⁿ → (0, ∞)` (or a constant `r` if `l.bRiemann = tt`) such that `s`
 contains each prepartition `π` such that `l.mem_base_set I c r π` and `π.Union = π₀.Union`. -/
 def toFilterDistortionUnion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) (π₀ : Prepartition I) :=
-  l.toFilterDistortion I c ⊓ 𝓟 { π | π.unionᵢ = π₀.unionᵢ }
+  l.toFilterDistortion I c ⊓ 𝓟 { π | π.iUnion = π₀.iUnion }
 #align box_integral.integration_params.to_filter_distortion_Union BoxIntegral.IntegrationParams.toFilterDistortionUnion
 
 /-- A set `s : set (tagged_prepartition I)` belongs to `l.to_filter_Union I π₀` if for any `c : ℝ≥0`
@@ -342,8 +342,8 @@ theorem rCond_of_bRiemann_eq_false {ι} (l : IntegrationParams) (hl : l.bRiemann
 #align box_integral.integration_params.r_cond_of_bRiemann_eq_ff BoxIntegral.IntegrationParams.rCond_of_bRiemann_eq_false
 
 theorem toFilter_inf_union_eq (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
-    l.toFilter I ⊓ 𝓟 { π | π.unionᵢ = π₀.unionᵢ } = l.toFilterUnion I π₀ :=
-  (supᵢ_inf_principal _ _).symm
+    l.toFilter I ⊓ 𝓟 { π | π.iUnion = π₀.iUnion } = l.toFilterUnion I π₀ :=
+  (iSup_inf_principal _ _).symm
 #align box_integral.integration_params.to_filter_inf_Union_eq BoxIntegral.IntegrationParams.toFilter_inf_union_eq
 
 theorem MemBaseSet.mono' (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {π : TaggedPrepartition I}
@@ -361,9 +361,9 @@ theorem MemBaseSet.mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {
 #align box_integral.integration_params.mem_base_set.mono BoxIntegral.IntegrationParams.MemBaseSet.mono
 
 theorem MemBaseSet.exists_common_compl (h₁ : l.MemBaseSet I c₁ r₁ π₁) (h₂ : l.MemBaseSet I c₂ r₂ π₂)
-    (hU : π₁.unionᵢ = π₂.unionᵢ) :
+    (hU : π₁.iUnion = π₂.iUnion) :
     ∃ π : Prepartition I,
-      π.unionᵢ = I \ π₁.unionᵢ ∧
+      π.iUnion = I \ π₁.iUnion ∧
         (l.bDistortion → π.distortion ≤ c₁) ∧ (l.bDistortion → π.distortion ≤ c₂) :=
   by
   wlog hc : c₁ ≤ c₂
@@ -378,7 +378,7 @@ theorem MemBaseSet.exists_common_compl (h₁ : l.MemBaseSet I c₁ r₁ π₁) (
 #align box_integral.integration_params.mem_base_set.exists_common_compl BoxIntegral.IntegrationParams.MemBaseSet.exists_common_compl
 
 protected theorem MemBaseSet.unionComplToSubordinate (hπ₁ : l.MemBaseSet I c r₁ π₁)
-    (hle : ∀ x ∈ I.Icc, r₂ x ≤ r₁ x) {π₂ : Prepartition I} (hU : π₂.unionᵢ = I \ π₁.unionᵢ)
+    (hle : ∀ x ∈ I.Icc, r₂ x ≤ r₁ x) {π₂ : Prepartition I} (hU : π₂.iUnion = I \ π₁.iUnion)
     (hc : l.bDistortion → π₂.distortion ≤ c) :
     l.MemBaseSet I c r₁ (π₁.unionComplToSubordinate π₂ hU r₂) :=
   ⟨hπ₁.1.disjUnion ((π₂.isSubordinate_toSubordinate r₂).mono hle) _, fun h =>
@@ -398,8 +398,8 @@ protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι 
   have : Disjoint π₁.Union π₂.Union := by
     simpa [π₂, hπ₁U] using disjoint_sdiff_self_left.mono_right sdiff_le
   refine' ⟨π₁.disj_union π₂.to_prepartition this, _, _⟩
-  · suffices ↑I \ π.Union ∪ π.Union \ (π.filter p).unionᵢ = ↑I \ (π.filter p).unionᵢ by simpa [*]
-    have : (π.filter p).unionᵢ ⊆ π.Union := bUnion_subset_bUnion_left (Finset.filter_subset _ _)
+  · suffices ↑I \ π.Union ∪ π.Union \ (π.filter p).iUnion = ↑I \ (π.filter p).iUnion by simpa [*]
+    have : (π.filter p).iUnion ⊆ π.Union := bUnion_subset_bUnion_left (Finset.filter_subset _ _)
     ext x
     fconstructor
     · rintro (⟨hxI, hxπ⟩ | ⟨hxπ, hxp⟩)
@@ -438,31 +438,31 @@ theorem RCond.min {ι : Type _} {r₁ r₂ : (ι → ℝ) → Ioi (0 : ℝ)} (h
 @[mono]
 theorem toFilterDistortion_mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) :
     l₁.toFilterDistortion I c₁ ≤ l₂.toFilterDistortion I c₂ :=
-  infᵢ_mono fun r =>
-    infᵢ_mono' fun hr =>
+  iInf_mono fun r =>
+    iInf_mono' fun hr =>
       ⟨hr.mono h, principal_mono.2 fun _ => MemBaseSet.mono I h hc fun _ _ => le_rfl⟩
 #align box_integral.integration_params.to_filter_distortion_mono BoxIntegral.IntegrationParams.toFilterDistortion_mono
 
 @[mono]
 theorem toFilter_mono (I : Box ι) {l₁ l₂ : IntegrationParams} (h : l₁ ≤ l₂) :
     l₁.toFilter I ≤ l₂.toFilter I :=
-  supᵢ_mono fun c => toFilterDistortion_mono I h le_rfl
+  iSup_mono fun c => toFilterDistortion_mono I h le_rfl
 #align box_integral.integration_params.to_filter_mono BoxIntegral.IntegrationParams.toFilter_mono
 
 @[mono]
 theorem toFilterUnion_mono (I : Box ι) {l₁ l₂ : IntegrationParams} (h : l₁ ≤ l₂)
     (π₀ : Prepartition I) : l₁.toFilterUnion I π₀ ≤ l₂.toFilterUnion I π₀ :=
-  supᵢ_mono fun c => inf_le_inf_right _ <| toFilterDistortion_mono _ h le_rfl
+  iSup_mono fun c => inf_le_inf_right _ <| toFilterDistortion_mono _ h le_rfl
 #align box_integral.integration_params.to_filter_Union_mono BoxIntegral.IntegrationParams.toFilterUnion_mono
 
 theorem toFilterUnion_congr (I : Box ι) (l : IntegrationParams) {π₁ π₂ : Prepartition I}
-    (h : π₁.unionᵢ = π₂.unionᵢ) : l.toFilterUnion I π₁ = l.toFilterUnion I π₂ := by
+    (h : π₁.iUnion = π₂.iUnion) : l.toFilterUnion I π₁ = l.toFilterUnion I π₂ := by
   simp only [to_filter_Union, to_filter_distortion_Union, h]
 #align box_integral.integration_params.to_filter_Union_congr BoxIntegral.IntegrationParams.toFilterUnion_congr
 
 theorem hasBasis_toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) :
     (l.toFilterDistortion I c).HasBasis l.RCond fun r => { π | l.MemBaseSet I c r π } :=
-  hasBasis_binfᵢ_principal'
+  hasBasis_biInf_principal'
     (fun r₁ hr₁ r₂ hr₂ =>
       ⟨_, hr₁.min hr₂, fun _ => MemBaseSet.mono _ le_rfl le_rfl fun x hx => min_le_left _ _,
         fun _ => MemBaseSet.mono _ le_rfl le_rfl fun x hx => min_le_right _ _⟩)
@@ -472,13 +472,13 @@ theorem hasBasis_toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : 
 theorem hasBasis_toFilterDistortionUnion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0)
     (π₀ : Prepartition I) :
     (l.toFilterDistortionUnion I c π₀).HasBasis l.RCond fun r =>
-      { π | l.MemBaseSet I c r π ∧ π.unionᵢ = π₀.unionᵢ } :=
+      { π | l.MemBaseSet I c r π ∧ π.iUnion = π₀.iUnion } :=
   (l.hasBasis_toFilterDistortion I c).inf_principal _
 #align box_integral.integration_params.has_basis_to_filter_distortion_Union BoxIntegral.IntegrationParams.hasBasis_toFilterDistortionUnion
 
 theorem hasBasis_toFilterUnion (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
     (l.toFilterUnion I π₀).HasBasis (fun r : ℝ≥0 → (ι → ℝ) → Ioi (0 : ℝ) => ∀ c, l.RCond (r c))
-      fun r => { π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.unionᵢ = π₀.unionᵢ } :=
+      fun r => { π | ∃ c, l.MemBaseSet I c (r c) π ∧ π.iUnion = π₀.iUnion } :=
   by
   have := fun c => l.hasBasis_toFilterDistortionUnion I c π₀
   simpa only [set_of_and, set_of_exists] using has_basis_supr this
@@ -504,7 +504,7 @@ theorem tendsto_embedBox_toFilterUnion_top (l : IntegrationParams) (h : I ≤ J)
   by
   simp only [to_filter_Union, tendsto_supr]; intro c
   set π₀ := prepartition.single J I h
-  refine' le_supᵢ_of_le (max c π₀.compl.distortion) _
+  refine' le_iSup_of_le (max c π₀.compl.distortion) _
   refine'
     ((l.has_basis_to_filter_distortion_Union I c ⊤).tendsto_iffₓ
           (l.has_basis_to_filter_distortion_Union J _ _)).2
@@ -520,7 +520,7 @@ theorem tendsto_embedBox_toFilterUnion_top (l : IntegrationParams) (h : I ≤ J)
 
 theorem exists_memBaseSet_le_union_eq (l : IntegrationParams) (π₀ : Prepartition I)
     (hc₁ : π₀.distortion ≤ c) (hc₂ : π₀.compl.distortion ≤ c) (r : (ι → ℝ) → Ioi (0 : ℝ)) :
-    ∃ π, l.MemBaseSet I c r π ∧ π.toPrepartition ≤ π₀ ∧ π.unionᵢ = π₀.unionᵢ :=
+    ∃ π, l.MemBaseSet I c r π ∧ π.toPrepartition ≤ π₀ ∧ π.iUnion = π₀.iUnion :=
   by
   rcases π₀.exists_tagged_le_is_Henstock_is_subordinate_Union_eq r with ⟨π, hle, hH, hr, hd, hU⟩
   refine' ⟨π, ⟨hr, fun _ => hH, fun _ => hd.trans_le hc₁, fun hD => ⟨π₀.compl, _, hc₂⟩⟩, ⟨hle, hU⟩⟩
@@ -553,21 +553,21 @@ instance toFilterDistortion_neBot (l : IntegrationParams) (I : Box ι) :
 #align box_integral.integration_params.to_filter_distortion_ne_bot BoxIntegral.IntegrationParams.toFilterDistortion_neBot
 
 instance toFilter_neBot (l : IntegrationParams) (I : Box ι) : (l.toFilter I).ne_bot :=
-  (l.toFilterDistortion_neBot I).mono <| le_supᵢ _ _
+  (l.toFilterDistortion_neBot I).mono <| le_iSup _ _
 #align box_integral.integration_params.to_filter_ne_bot BoxIntegral.IntegrationParams.toFilter_neBot
 
 instance toFilterUnion_neBot (l : IntegrationParams) (I : Box ι) (π₀ : Prepartition I) :
     (l.toFilterUnion I π₀).ne_bot :=
   (l.toFilterDistortionUnion_ne_bot' I π₀).mono <|
-    le_supᵢ (fun c => l.toFilterDistortionUnion I c π₀) _
+    le_iSup (fun c => l.toFilterDistortionUnion I c π₀) _
 #align box_integral.integration_params.to_filter_Union_ne_bot BoxIntegral.IntegrationParams.toFilterUnion_neBot
 
 theorem eventually_isPartition (l : IntegrationParams) (I : Box ι) :
     ∀ᶠ π in l.toFilterUnion I ⊤, TaggedPrepartition.IsPartition π :=
-  eventually_supᵢ.2 fun c =>
+  eventually_iSup.2 fun c =>
     eventually_inf_principal.2 <|
       eventually_of_forall fun π h =>
-        π.isPartition_iff_unionᵢ_eq.2 (h.trans Prepartition.unionᵢ_top)
+        π.isPartition_iff_iUnion_eq.2 (h.trans Prepartition.iUnion_top)
 #align box_integral.integration_params.eventually_is_partition BoxIntegral.IntegrationParams.eventually_isPartition
 
 end IntegrationParams

mathlib commit https://github.com/leanprover-community/mathlib/commit/d2d964c64f8ddcccd6704a731c41f95d13e72f5c

@@ -381,8 +381,8 @@ protected theorem MemBaseSet.unionComplToSubordinate (hπ₁ : l.MemBaseSet I c
     (hle : ∀ x ∈ I.Icc, r₂ x ≤ r₁ x) {π₂ : Prepartition I} (hU : π₂.unionᵢ = I \ π₁.unionᵢ)
     (hc : l.bDistortion → π₂.distortion ≤ c) :
     l.MemBaseSet I c r₁ (π₁.unionComplToSubordinate π₂ hU r₂) :=
-  ⟨hπ₁.1.disjUnion ((π₂.isSubordinateToSubordinate r₂).mono hle) _, fun h =>
-    (hπ₁.2 h).disjUnion (π₂.isHenstockToSubordinate _) _, fun h =>
+  ⟨hπ₁.1.disjUnion ((π₂.isSubordinate_toSubordinate r₂).mono hle) _, fun h =>
+    (hπ₁.2 h).disjUnion (π₂.isHenstock_toSubordinate _) _, fun h =>
     (distortion_unionComplToSubordinate _ _ _ _).trans_le (max_le (hπ₁.3 h) (hc h)), fun _ =>
     ⟨⊥, by simp⟩⟩
 #align box_integral.integration_params.mem_base_set.union_compl_to_subordinate BoxIntegral.IntegrationParams.MemBaseSet.unionComplToSubordinate
@@ -411,7 +411,7 @@ protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι 
     simpa [hc]
 #align box_integral.integration_params.mem_base_set.filter BoxIntegral.IntegrationParams.MemBaseSet.filter
 
-theorem bUnionTaggedMemBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepartition J}
+theorem bUnionTagged_memBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepartition J}
     (h : ∀ J ∈ π, l.MemBaseSet J c r (πi J)) (hp : ∀ J ∈ π, (πi J).IsPartition)
     (hc : l.bDistortion → π.compl.distortion ≤ c) : l.MemBaseSet I c r (π.bUnionTagged πi) :=
   by
@@ -424,7 +424,7 @@ theorem bUnionTaggedMemBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepart
   · refine' ⟨_, _, hc hD⟩
     rw [π.Union_compl, ← π.Union_bUnion_partition hp]
     rfl
-#align box_integral.integration_params.bUnion_tagged_mem_base_set BoxIntegral.IntegrationParams.bUnionTaggedMemBaseSet
+#align box_integral.integration_params.bUnion_tagged_mem_base_set BoxIntegral.IntegrationParams.bUnionTagged_memBaseSet
 
 @[mono]
 theorem RCond.mono {ι : Type _} {r : (ι → ℝ) → Ioi (0 : ℝ)} (h : l₁ ≤ l₂) (hr : l₂.RCond r) :
@@ -566,7 +566,8 @@ theorem eventually_isPartition (l : IntegrationParams) (I : Box ι) :
     ∀ᶠ π in l.toFilterUnion I ⊤, TaggedPrepartition.IsPartition π :=
   eventually_supᵢ.2 fun c =>
     eventually_inf_principal.2 <|
-      eventually_of_forall fun π h => π.isPartition_iff_union_eq.2 (h.trans Prepartition.union_top)
+      eventually_of_forall fun π h =>
+        π.isPartition_iff_unionᵢ_eq.2 (h.trans Prepartition.unionᵢ_top)
 #align box_integral.integration_params.eventually_is_partition BoxIntegral.IntegrationParams.eventually_isPartition
 
 end IntegrationParams

mathlib commit https://github.com/leanprover-community/mathlib/commit/7ebf83ed9c262adbf983ef64d5e8c2ae94b625f4

@@ -357,7 +357,7 @@ theorem MemBaseSet.mono' (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {
 @[mono]
 theorem MemBaseSet.mono (I : Box ι) (h : l₁ ≤ l₂) (hc : c₁ ≤ c₂) {π : TaggedPrepartition I}
     (hr : ∀ x ∈ I.Icc, r₁ x ≤ r₂ x) (hπ : l₁.MemBaseSet I c₁ r₁ π) : l₂.MemBaseSet I c₂ r₂ π :=
-  hπ.mono' I h hc fun J hJ => hr _ <| π.tag_mem_icc J
+  hπ.mono' I h hc fun J hJ => hr _ <| π.tag_mem_Icc J
 #align box_integral.integration_params.mem_base_set.mono BoxIntegral.IntegrationParams.MemBaseSet.mono
 
 theorem MemBaseSet.exists_common_compl (h₁ : l.MemBaseSet I c₁ r₁ π₁) (h₂ : l.MemBaseSet I c₂ r₂ π₂)

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

in doc comments. These are terms of type bool, hence should be (Bool.)true/false.

And correct a typo also caused in the same PR.

@@ -34,15 +34,15 @@ the corresponding integral, or in the proofs of its properties. We equip
 
 The structure `BoxIntegral.IntegrationParams` has 3 boolean fields with the following meaning:
 
-* `bRiemann`: the value `True` means that the filter corresponds to a Riemann-style integral, i.e.
+* `bRiemann`: the value `true` means that the filter corresponds to a Riemann-style integral, i.e.
   in the definition of integrability we require a constant upper estimate `r` on the size of boxes
-  of a tagged partition; the value `False` means that the estimate may depend on the position of the
+  of a tagged partition; the value `false` means that the estimate may depend on the position of the
   tag.
 
-* `bHenstock`: the value `True` means that we require that each tag belongs to its own closed box;
-  the value `False` means that we only require that tags belong to the ambient box.
+* `bHenstock`: the value `true` means that we require that each tag belongs to its own closed box;
+  the value `false` means that we only require that tags belong to the ambient box.
 
-* `bDistortion`: the value `True` means that `r` can depend on the maximal ratio of sides of the
+* `bDistortion`: the value `true` means that `r` can depend on the maximal ratio of sides of the
   same box of a partition. Presence of this case make quite a few proofs harder but we can prove the
   divergence theorem only for the filter `BoxIntegral.IntegrationParams.GP = ⊥ =
   {bRiemann := false, bHenstock := true, bDistortion := true}`.
@@ -183,15 +183,15 @@ open TaggedPrepartition
 /-- An `IntegrationParams` is a structure holding 3 boolean values used to define a filter to be
 used in the definition of a box-integrable function.
 
-* `bRiemann`: the value `True` means that the filter corresponds to a Riemann-style integral, i.e.
+* `bRiemann`: the value `true` means that the filter corresponds to a Riemann-style integral, i.e.
   in the definition of integrability we require a constant upper estimate `r` on the size of boxes
-  of a tagged partition; the value `False` means that the estimate may depend on the position of the
+  of a tagged partition; the value `false` means that the estimate may depend on the position of the
   tag.
 
-* `bHenstock`: the value `True` means that we require that each tag belongs to its own closed box;
-  the value `False` means that we only require that tags belong to the ambient box.
+* `bHenstock`: the value `true` means that we require that each tag belongs to its own closed box;
+  the value `false` means that we only require that tags belong to the ambient box.
 
-* `bDistortion`: the value `True` means that `r` can depend on the maximal ratio of sides of the
+* `bDistortion`: the value `true` means that `r` can depend on the maximal ratio of sides of the
   same box of a partition. Presence of this case makes quite a few proofs harder but we can prove
   the divergence theorem only for the filter `BoxIntegral.IntegrationParams.GP = ⊥ =
   {bRiemann := false, bHenstock := true, bDistortion := true}`.

@@ -34,15 +34,15 @@ the corresponding integral, or in the proofs of its properties. We equip
 
 The structure `BoxIntegral.IntegrationParams` has 3 boolean fields with the following meaning:
 
-* `bRiemann`: the value `true` means that the filter corresponds to a Riemann-style integral, i.e.
+* `bRiemann`: the value `True` means that the filter corresponds to a Riemann-style integral, i.e.
   in the definition of integrability we require a constant upper estimate `r` on the size of boxes
-  of a tagged partition; the value `false` means that the estimate may depend on the position of the
+  of a tagged partition; the value `False` means that the estimate may depend on the position of the
   tag.
 
-* `bHenstock`: the value `true` means that we require that each tag belongs to its own closed box;
-  the value `false` means that we only require that tags belong to the ambient box.
+* `bHenstock`: the value `True` means that we require that each tag belongs to its own closed box;
+  the value `False` means that we only require that tags belong to the ambient box.
 
-* `bDistortion`: the value `true` means that `r` can depend on the maximal ratio of sides of the
+* `bDistortion`: the value `True` means that `r` can depend on the maximal ratio of sides of the
   same box of a partition. Presence of this case make quite a few proofs harder but we can prove the
   divergence theorem only for the filter `BoxIntegral.IntegrationParams.GP = ⊥ =
   {bRiemann := false, bHenstock := true, bDistortion := true}`.
@@ -183,15 +183,15 @@ open TaggedPrepartition
 /-- An `IntegrationParams` is a structure holding 3 boolean values used to define a filter to be
 used in the definition of a box-integrable function.
 
-* `bRiemann`: the value `true` means that the filter corresponds to a Riemann-style integral, i.e.
+* `bRiemann`: the value `True` means that the filter corresponds to a Riemann-style integral, i.e.
   in the definition of integrability we require a constant upper estimate `r` on the size of boxes
-  of a tagged partition; the value `false` means that the estimate may depend on the position of the
+  of a tagged partition; the value `False` means that the estimate may depend on the position of the
   tag.
 
-* `bHenstock`: the value `true` means that we require that each tag belongs to its own closed box;
-  the value `false` means that we only require that tags belong to the ambient box.
+* `bHenstock`: the value `True` means that we require that each tag belongs to its own closed box;
+  the value `False` means that we only require that tags belong to the ambient box.
 
-* `bDistortion`: the value `true` means that `r` can depend on the maximal ratio of sides of the
+* `bDistortion`: the value `True` means that `r` can depend on the maximal ratio of sides of the
   same box of a partition. Presence of this case makes quite a few proofs harder but we can prove
   the divergence theorem only for the filter `BoxIntegral.IntegrationParams.GP = ⊥ =
   {bRiemann := false, bHenstock := true, bDistortion := true}`.

We remove all but one open Classicals, instead preferring to use open scoped Classical. The only real side-effect this led to is moving a couple declarations to use Exists.choose instead of Classical.choose.

The first few commits are explicitly labelled regex replaces for ease of review.

@@ -168,7 +168,8 @@ integral, rectangular box, partition, filter
 
 open Set Function Filter Metric Finset Bool
 
-open Classical Topology Filter NNReal
+open scoped Classical
+open Topology Filter NNReal
 
 noncomputable section
 

This is a very large PR, but it has been reviewed piecemeal already in PRs to the bump/v4.7.0 branch as we update to intermediate nightlies.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: damiano <adomani@gmail.com>

@@ -401,7 +401,8 @@ protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι 
   have : Disjoint π₁.iUnion π₂.iUnion := by
     simpa [π₂, hπ₁U] using disjoint_sdiff_self_left.mono_right sdiff_le
   refine' ⟨π₁.disjUnion π₂.toPrepartition this, _, _⟩
-  · suffices ↑I \ π.iUnion ∪ π.iUnion \ (π.filter p).iUnion = ↑I \ (π.filter p).iUnion by simp [*]
+  · suffices ↑I \ π.iUnion ∪ π.iUnion \ (π.filter p).iUnion = ↑I \ (π.filter p).iUnion by
+      simp [π₂, *]
     have h : (π.filter p).iUnion ⊆ π.iUnion :=
       biUnion_subset_biUnion_left (Finset.filter_subset _ _)
     ext x

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -399,7 +399,7 @@ protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι 
   rcases hπ.4 hD with ⟨π₁, hπ₁U, hc⟩
   set π₂ := π.filter fun J => ¬p J
   have : Disjoint π₁.iUnion π₂.iUnion := by
-    simpa [hπ₁U] using disjoint_sdiff_self_left.mono_right sdiff_le
+    simpa [π₂, hπ₁U] using disjoint_sdiff_self_left.mono_right sdiff_le
   refine' ⟨π₁.disjUnion π₂.toPrepartition this, _, _⟩
   · suffices ↑I \ π.iUnion ∪ π.iUnion \ (π.filter p).iUnion = ↑I \ (π.filter p).iUnion by simp [*]
     have h : (π.filter p).iUnion ⊆ π.iUnion :=

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -174,7 +174,7 @@ noncomputable section
 
 namespace BoxIntegral
 
-variable {ι : Type _} [Fintype ι] {I J : Box ι} {c c₁ c₂ : ℝ≥0} {r r₁ r₂ : (ι → ℝ) → Ioi (0 : ℝ)}
+variable {ι : Type*} [Fintype ι] {I J : Box ι} {c c₁ c₂ : ℝ≥0} {r r₁ r₂ : (ι → ℝ) → Ioi (0 : ℝ)}
   {π π₁ π₂ : TaggedPrepartition I}
 
 open TaggedPrepartition
@@ -310,7 +310,7 @@ structure MemBaseSet (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) (r : (ι
 #align box_integral.integration_params.mem_base_set BoxIntegral.IntegrationParams.MemBaseSet
 
 /-- A predicate saying that in case `l.bRiemann = true`, the function `r` is a constant. -/
-def RCond {ι : Type _} (l : IntegrationParams) (r : (ι → ℝ) → Ioi (0 : ℝ)) : Prop :=
+def RCond {ι : Type*} (l : IntegrationParams) (r : (ι → ℝ) → Ioi (0 : ℝ)) : Prop :=
   l.bRiemann → ∀ x, r x = r 0
 #align box_integral.integration_params.r_cond BoxIntegral.IntegrationParams.RCond
 
@@ -429,12 +429,12 @@ theorem biUnionTagged_memBaseSet {π : Prepartition I} {πi : ∀ J, TaggedPrepa
 #align box_integral.integration_params.bUnion_tagged_mem_base_set BoxIntegral.IntegrationParams.biUnionTagged_memBaseSet
 
 @[mono]
-theorem RCond.mono {ι : Type _} {r : (ι → ℝ) → Ioi (0 : ℝ)} (h : l₁ ≤ l₂) (hr : l₂.RCond r) :
+theorem RCond.mono {ι : Type*} {r : (ι → ℝ) → Ioi (0 : ℝ)} (h : l₁ ≤ l₂) (hr : l₂.RCond r) :
     l₁.RCond r :=
   fun hR => hr (le_iff_imp.1 h.1 hR)
 #align box_integral.integration_params.r_cond.mono BoxIntegral.IntegrationParams.RCond.mono
 
-nonrec theorem RCond.min {ι : Type _} {r₁ r₂ : (ι → ℝ) → Ioi (0 : ℝ)} (h₁ : l.RCond r₁)
+nonrec theorem RCond.min {ι : Type*} {r₁ r₂ : (ι → ℝ) → Ioi (0 : ℝ)} (h₁ : l.RCond r₁)
     (h₂ : l.RCond r₂) : l.RCond fun x => min (r₁ x) (r₂ x) :=
   fun hR x => congr_arg₂ min (h₁ hR x) (h₂ hR x)
 #align box_integral.integration_params.r_cond.min BoxIntegral.IntegrationParams.RCond.min

• depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Yury Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury Kudryashov
-
-! This file was ported from Lean 3 source module analysis.box_integral.partition.filter
-! leanprover-community/mathlib commit 92ca63f0fb391a9ca5f22d2409a6080e786d99f7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Analysis.BoxIntegral.Partition.SubboxInduction
 import Mathlib.Analysis.BoxIntegral.Partition.Split
 
+#align_import analysis.box_integral.partition.filter from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
+
 /-!
 # Filters used in box-based integrals
 

Too often tempted to change these during other PRs, so doing a mass edit here.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

@@ -410,10 +410,10 @@ protected theorem MemBaseSet.filter (hπ : l.MemBaseSet I c r π) (p : Box ι 
     ext x
     fconstructor
     · rintro (⟨hxI, hxπ⟩ | ⟨hxπ, hxp⟩)
-      exacts[⟨hxI, mt (@h x) hxπ⟩, ⟨π.iUnion_subset hxπ, hxp⟩]
+      exacts [⟨hxI, mt (@h x) hxπ⟩, ⟨π.iUnion_subset hxπ, hxp⟩]
     · rintro ⟨hxI, hxp⟩
       by_cases hxπ : x ∈ π.iUnion
-      exacts[Or.inr ⟨hxπ, hxp⟩, Or.inl ⟨hxI, hxπ⟩]
+      exacts [Or.inr ⟨hxπ, hxp⟩, Or.inl ⟨hxI, hxπ⟩]
   · have : (π.filter fun J => ¬p J).distortion ≤ c := (distortion_filter_le _ _).trans (hπ.3 hD)
     simpa [hc]
 #align box_integral.integration_params.mem_base_set.filter BoxIntegral.IntegrationParams.MemBaseSet.filter

Co-authored-by: Alex J Best <alex.j.best@gmail.com> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -305,8 +305,8 @@ It is also automatically satisfied for any `c > 1`, see TODO section of the modu
 details. -/
 structure MemBaseSet (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) (r : (ι → ℝ) → Ioi (0 : ℝ))
     (π : TaggedPrepartition I) : Prop where
-  protected IsSubordinate : π.IsSubordinate r
-  protected IsHenstock : l.bHenstock → π.IsHenstock
+  protected isSubordinate : π.IsSubordinate r
+  protected isHenstock : l.bHenstock → π.IsHenstock
   protected distortion_le : l.bDistortion → π.distortion ≤ c
   protected exists_compl : l.bDistortion → ∃ π' : Prepartition I,
     π'.iUnion = ↑I \ π.iUnion ∧ π'.distortion ≤ c

@@ -322,7 +322,7 @@ a function `r : ℝⁿ → (0, ∞)` (or a constant `r` if `l.bRiemann = true`)
 prepartition `π` such that `l.MemBaseSet I c r π`. -/
 def toFilterDistortion (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) :
     Filter (TaggedPrepartition I) :=
-  ⨅ (r : (ι → ℝ) → Ioi (0 : ℝ)) (_hr : l.RCond r), 𝓟 { π | l.MemBaseSet I c r π }
+  ⨅ (r : (ι → ℝ) → Ioi (0 : ℝ)) (_ : l.RCond r), 𝓟 { π | l.MemBaseSet I c r π }
 #align box_integral.integration_params.to_filter_distortion BoxIntegral.IntegrationParams.toFilterDistortion
 
 /-- A set `s : Set (TaggedPrepartition I)` belongs to `l.toFilter I` if for any `c : ℝ≥0` there

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -303,13 +303,12 @@ Sacks-Henstock inequality to compare two prepartitions covering the same part of
 
 It is also automatically satisfied for any `c > 1`, see TODO section of the module docstring for
 details. -/
--- @[protect_proj] -- Porting note: Not yet implemented
 structure MemBaseSet (l : IntegrationParams) (I : Box ι) (c : ℝ≥0) (r : (ι → ℝ) → Ioi (0 : ℝ))
     (π : TaggedPrepartition I) : Prop where
-  IsSubordinate : π.IsSubordinate r
-  IsHenstock : l.bHenstock → π.IsHenstock
-  distortion_le : l.bDistortion → π.distortion ≤ c
-  exists_compl : l.bDistortion → ∃ π' : Prepartition I,
+  protected IsSubordinate : π.IsSubordinate r
+  protected IsHenstock : l.bHenstock → π.IsHenstock
+  protected distortion_le : l.bDistortion → π.distortion ≤ c
+  protected exists_compl : l.bDistortion → ∃ π' : Prepartition I,
     π'.iUnion = ↑I \ π.iUnion ∧ π'.distortion ≤ c
 #align box_integral.integration_params.mem_base_set BoxIntegral.IntegrationParams.MemBaseSet
 

Co-authored-by: Moritz Firsching <firsching@google.com>