Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

6ca1a09b

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

9d2f0748

bump to nightly-2024-04-25-08

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

ad7a2212

Diff

@@ -72,8 +72,8 @@ theorem coe_splitLower : (splitLower I i x : Set (ι → ℝ)) = I ∩ {y | y i
   rw [split_lower, coe_mk']
   ext y
   simp only [mem_univ_pi, mem_Ioc, mem_inter_iff, mem_coe, mem_set_of_eq, forall_and, ← Pi.le_def,
-    le_update_iff, le_min_iff, and_assoc', and_forall_ne i, mem_def]
-  rw [and_comm' (y i ≤ x), Pi.le_def]
+    le_update_iff, le_min_iff, and_assoc, and_forall_ne i, mem_def]
+  rw [and_comm (y i ≤ x), Pi.le_def]
 #align box_integral.box.coe_split_lower BoxIntegral.Box.coe_splitLower
 -/
 
@@ -126,9 +126,9 @@ theorem coe_splitUpper : (splitUpper I i x : Set (ι → ℝ)) = I ∩ {y | x <
   rw [split_upper, coe_mk']
   ext y
   simp only [mem_univ_pi, mem_Ioc, mem_inter_iff, mem_coe, mem_set_of_eq, forall_and,
-    forall_update_iff I.lower fun j z => z < y j, max_lt_iff, and_assoc' (x < y i), and_forall_ne i,
+    forall_update_iff I.lower fun j z => z < y j, max_lt_iff, and_assoc (x < y i), and_forall_ne i,
     mem_def]
-  exact and_comm' _ _
+  exact and_comm _ _
 #align box_integral.box.coe_split_upper BoxIntegral.Box.coe_splitUpper
 -/

9d2f0748

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -251,7 +251,7 @@ theorem split_of_not_mem_Ioo (h : x ∉ Ioo (I.lower i) (I.upper i)) : split I i
   refine' ((is_partition_top I).eq_of_boxes_subset fun J hJ => _).symm
   rcases mem_top.1 hJ with rfl; clear hJ
   rw [mem_boxes, mem_split_iff]
-  rw [mem_Ioo, not_and_or, not_lt, not_lt] at h 
+  rw [mem_Ioo, not_and_or, not_lt, not_lt] at h
   cases h <;> [right; left]
   · rwa [eq_comm, box.split_upper_eq_self]
   · rwa [eq_comm, box.split_lower_eq_self]
@@ -261,14 +261,14 @@ theorem split_of_not_mem_Ioo (h : x ∉ Ioo (I.lower i) (I.upper i)) : split I i
 #print BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_le /-
 theorem coe_eq_of_mem_split_of_mem_le {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
     (h₃ : y i ≤ x) : (J : Set (ι → ℝ)) = I ∩ {y | y i ≤ x} :=
-  (mem_split_iff'.1 h₁).resolve_right fun H => by rw [← box.mem_coe, H] at h₂ ; exact h₃.not_lt h₂.2
+  (mem_split_iff'.1 h₁).resolve_right fun H => by rw [← box.mem_coe, H] at h₂; exact h₃.not_lt h₂.2
 #align box_integral.prepartition.coe_eq_of_mem_split_of_mem_le BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_le
 -/
 
 #print BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_mem /-
 theorem coe_eq_of_mem_split_of_lt_mem {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
     (h₃ : x < y i) : (J : Set (ι → ℝ)) = I ∩ {y | x < y i} :=
-  (mem_split_iff'.1 h₁).resolve_left fun H => by rw [← box.mem_coe, H] at h₂ ; exact h₃.not_le h₂.2
+  (mem_split_iff'.1 h₁).resolve_left fun H => by rw [← box.mem_coe, H] at h₂; exact h₃.not_le h₂.2
 #align box_integral.prepartition.coe_eq_of_mem_split_of_lt_mem BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_mem
 -/
 
@@ -353,16 +353,16 @@ theorem not_disjoint_imp_le_of_subset_of_mem_splitMany {I J Js : Box ι} {s : Fi
     (H : ∀ i, {(i, J i), (i, J.upper i)} ⊆ s) (HJs : Js ∈ splitMany I s)
     (Hn : ¬Disjoint (J : WithBot (Box ι)) Js) : Js ≤ J :=
   by
-  simp only [Finset.insert_subset_iff, Finset.singleton_subset_iff] at H 
+  simp only [Finset.insert_subset_iff, Finset.singleton_subset_iff] at H
   rcases box.not_disjoint_coe_iff_nonempty_inter.mp Hn with ⟨x, hx, hxs⟩
   refine' fun y hy i => ⟨_, _⟩
   · rcases split_many_le_split I (H i).1 HJs with ⟨Jl, Hmem : Jl ∈ split I i (J.lower i), Hle⟩
     have := Hle hxs
-    rw [← box.coe_subset_coe, coe_eq_of_mem_split_of_lt_mem Hmem this (hx i).1] at Hle 
+    rw [← box.coe_subset_coe, coe_eq_of_mem_split_of_lt_mem Hmem this (hx i).1] at Hle
     exact (Hle hy).2
   · rcases split_many_le_split I (H i).2 HJs with ⟨Jl, Hmem : Jl ∈ split I i (J.upper i), Hle⟩
     have := Hle hxs
-    rw [← box.coe_subset_coe, coe_eq_of_mem_split_of_mem_le Hmem this (hx i).2] at Hle 
+    rw [← box.coe_subset_coe, coe_eq_of_mem_split_of_mem_le Hmem this (hx i).2] at Hle
     exact (Hle hy).2
 #align box_integral.prepartition.not_disjoint_imp_le_of_subset_of_mem_split_many BoxIntegral.Prepartition.not_disjoint_imp_le_of_subset_of_mem_splitMany
 -/
@@ -403,7 +403,7 @@ theorem eventually_splitMany_inf_eq_filter (π : Prepartition I) :
     rintro _ ⟨J₁, h₁, rfl⟩ hne
     refine' ⟨_, ⟨J₁, ⟨h₁, subset.trans _ (π.subset_Union hJ)⟩, rfl⟩, le_rfl⟩
     exact ht I J hJ J₁ h₁ (mt disjoint_iff.1 hne)
-  · rw [mem_filter] at hJ 
+  · rw [mem_filter] at hJ
     rcases Set.mem_iUnion₂.1 (hJ.2 J.upper_mem) with ⟨J', hJ', hmem⟩
     refine' ⟨J', hJ', ht I _ hJ' _ hJ.1 <| box.not_disjoint_coe_iff_nonempty_inter.2 _⟩
     exact ⟨J.upper, hmem, J.upper_mem⟩
@@ -425,7 +425,7 @@ theorem exists_splitMany_inf_eq_filter_of_finite (s : Set (Prepartition I)) (hs
 theorem IsPartition.exists_splitMany_le {I : Box ι} {π : Prepartition I} (h : IsPartition π) :
     ∃ s, splitMany I s ≤ π :=
   (eventually_splitMany_inf_eq_filter π).exists.imp fun s hs => by
-    rwa [h.Union_eq, filter_of_true, inf_eq_right] at hs ; exact fun J hJ => le_of_mem _ hJ
+    rwa [h.Union_eq, filter_of_true, inf_eq_right] at hs; exact fun J hJ => le_of_mem _ hJ
 #align box_integral.prepartition.is_partition.exists_split_many_le BoxIntegral.Prepartition.IsPartition.exists_splitMany_le
 -/

9d2f0748

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,7 +3,7 @@ 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.Basic
+import Analysis.BoxIntegral.Partition.Basic
 
 #align_import analysis.box_integral.partition.split from "leanprover-community/mathlib"@"9d2f0748e6c50d7a2657c564b1ff2c695b39148d"

9d2f0748

bump to nightly-2023-08-02-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/63721b2c3eba6c325ecf8ae8cca27155a4f6306f

7aca3f15

Diff

@@ -436,7 +436,7 @@ theorem exists_iUnion_eq_diff (π : Prepartition I) :
     ∃ π' : Prepartition I, π'.iUnion = I \ π.iUnion :=
   by
   rcases π.eventually_split_many_inf_eq_filter.exists with ⟨s, hs⟩
-  use (split_many I s).filterₓ fun J => ¬(J : Set (ι → ℝ)) ⊆ π.Union
+  use(split_many I s).filterₓ fun J => ¬(J : Set (ι → ℝ)) ⊆ π.Union
   simp [← hs]
 #align box_integral.prepartition.exists_Union_eq_diff BoxIntegral.Prepartition.exists_iUnion_eq_diff
 -/

9d2f0748

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 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.split
-! leanprover-community/mathlib commit 9d2f0748e6c50d7a2657c564b1ff2c695b39148d
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Analysis.BoxIntegral.Partition.Basic
 
+#align_import analysis.box_integral.partition.split from "leanprover-community/mathlib"@"9d2f0748e6c50d7a2657c564b1ff2c695b39148d"
+
 /-!
 # Split a box along one or more hyperplanes

9d2f0748

bump to nightly-2023-06-28-03

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

79a0bd3b

Diff

@@ -356,7 +356,7 @@ theorem not_disjoint_imp_le_of_subset_of_mem_splitMany {I J Js : Box ι} {s : Fi
     (H : ∀ i, {(i, J i), (i, J.upper i)} ⊆ s) (HJs : Js ∈ splitMany I s)
     (Hn : ¬Disjoint (J : WithBot (Box ι)) Js) : Js ≤ J :=
   by
-  simp only [Finset.insert_subset, Finset.singleton_subset_iff] at H 
+  simp only [Finset.insert_subset_iff, Finset.singleton_subset_iff] at H 
   rcases box.not_disjoint_coe_iff_nonempty_inter.mp Hn with ⟨x, hx, hxs⟩
   refine' fun y hy i => ⟨_, _⟩
   · rcases split_many_le_split I (H i).1 HJs with ⟨Jl, Hmem : Jl ∈ split I i (J.lower i), Hle⟩

9d2f0748

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -68,6 +68,7 @@ def splitLower (I : Box ι) (i : ι) (x : ℝ) : WithBot (Box ι) :=
 #align box_integral.box.split_lower BoxIntegral.Box.splitLower
 -/
 
+#print BoxIntegral.Box.coe_splitLower /-
 @[simp]
 theorem coe_splitLower : (splitLower I i x : Set (ι → ℝ)) = I ∩ {y | y i ≤ x} :=
   by
@@ -77,23 +78,31 @@ theorem coe_splitLower : (splitLower I i x : Set (ι → ℝ)) = I ∩ {y | y i
     le_update_iff, le_min_iff, and_assoc', and_forall_ne i, mem_def]
   rw [and_comm' (y i ≤ x), Pi.le_def]
 #align box_integral.box.coe_split_lower BoxIntegral.Box.coe_splitLower
+-/
 
+#print BoxIntegral.Box.splitLower_le /-
 theorem splitLower_le : I.splitLower i x ≤ I :=
   withBotCoe_subset_iff.1 <| by simp
 #align box_integral.box.split_lower_le BoxIntegral.Box.splitLower_le
+-/
 
+#print BoxIntegral.Box.splitLower_eq_bot /-
 @[simp]
 theorem splitLower_eq_bot {i x} : I.splitLower i x = ⊥ ↔ x ≤ I.lower i :=
   by
   rw [split_lower, mk'_eq_bot, exists_update_iff I.upper fun j y => y ≤ I.lower j]
   simp [(I.lower_lt_upper _).not_le]
 #align box_integral.box.split_lower_eq_bot BoxIntegral.Box.splitLower_eq_bot
+-/
 
+#print BoxIntegral.Box.splitLower_eq_self /-
 @[simp]
 theorem splitLower_eq_self : I.splitLower i x = I ↔ I.upper i ≤ x := by
   simp [split_lower, update_eq_iff]
 #align box_integral.box.split_lower_eq_self BoxIntegral.Box.splitLower_eq_self
+-/
 
+#print BoxIntegral.Box.splitLower_def /-
 theorem splitLower_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.upper i))
     (h' : ∀ j, I.lower j < update I.upper i x j :=
       (forall_update_iff I.upper fun j y => I.lower j < y).2
@@ -101,6 +110,7 @@ theorem splitLower_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.uppe
     I.splitLower i x = (⟨I.lower, update I.upper i x, h'⟩ : Box ι) := by
   simp only [split_lower, mk'_eq_coe, min_eq_left h.2.le]; use rfl; congr
 #align box_integral.box.split_lower_def BoxIntegral.Box.splitLower_def
+-/
 
 #print BoxIntegral.Box.splitUpper /-
 /-- Given a box `I` and `x ∈ (I.lower i, I.upper i)`, the hyperplane `{y : ι → ℝ | y i = x}` splits
@@ -112,6 +122,7 @@ def splitUpper (I : Box ι) (i : ι) (x : ℝ) : WithBot (Box ι) :=
 #align box_integral.box.split_upper BoxIntegral.Box.splitUpper
 -/
 
+#print BoxIntegral.Box.coe_splitUpper /-
 @[simp]
 theorem coe_splitUpper : (splitUpper I i x : Set (ι → ℝ)) = I ∩ {y | x < y i} :=
   by
@@ -122,23 +133,31 @@ theorem coe_splitUpper : (splitUpper I i x : Set (ι → ℝ)) = I ∩ {y | x <
     mem_def]
   exact and_comm' _ _
 #align box_integral.box.coe_split_upper BoxIntegral.Box.coe_splitUpper
+-/
 
+#print BoxIntegral.Box.splitUpper_le /-
 theorem splitUpper_le : I.splitUpper i x ≤ I :=
   withBotCoe_subset_iff.1 <| by simp
 #align box_integral.box.split_upper_le BoxIntegral.Box.splitUpper_le
+-/
 
+#print BoxIntegral.Box.splitUpper_eq_bot /-
 @[simp]
 theorem splitUpper_eq_bot {i x} : I.splitUpper i x = ⊥ ↔ I.upper i ≤ x :=
   by
   rw [split_upper, mk'_eq_bot, exists_update_iff I.lower fun j y => I.upper j ≤ y]
   simp [(I.lower_lt_upper _).not_le]
 #align box_integral.box.split_upper_eq_bot BoxIntegral.Box.splitUpper_eq_bot
+-/
 
+#print BoxIntegral.Box.splitUpper_eq_self /-
 @[simp]
 theorem splitUpper_eq_self : I.splitUpper i x = I ↔ x ≤ I.lower i := by
   simp [split_upper, update_eq_iff]
 #align box_integral.box.split_upper_eq_self BoxIntegral.Box.splitUpper_eq_self
+-/
 
+#print BoxIntegral.Box.splitUpper_def /-
 theorem splitUpper_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.upper i))
     (h' : ∀ j, update I.lower i x j < I.upper j :=
       (forall_update_iff I.lower fun j y => y < I.upper j).2
@@ -146,7 +165,9 @@ theorem splitUpper_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.uppe
     I.splitUpper i x = (⟨update I.lower i x, I.upper, h'⟩ : Box ι) := by
   simp only [split_upper, mk'_eq_coe, max_eq_left h.1.le]; refine' ⟨_, rfl⟩; congr
 #align box_integral.box.split_upper_def BoxIntegral.Box.splitUpper_def
+-/
 
+#print BoxIntegral.Box.disjoint_splitLower_splitUpper /-
 theorem disjoint_splitLower_splitUpper (I : Box ι) (i : ι) (x : ℝ) :
     Disjoint (I.splitLower i x) (I.splitUpper i x) :=
   by
@@ -155,6 +176,7 @@ theorem disjoint_splitLower_splitUpper (I : Box ι) (i : ι) (x : ℝ) :
   rw [Set.disjoint_left]
   exact fun y (hle : y i ≤ x) hlt => not_lt_of_le hle hlt
 #align box_integral.box.disjoint_split_lower_split_upper BoxIntegral.Box.disjoint_splitLower_splitUpper
+-/
 
 #print BoxIntegral.Box.splitLower_ne_splitUpper /-
 theorem splitLower_ne_splitUpper (I : Box ι) (i : ι) (x : ℝ) :
@@ -197,11 +219,13 @@ theorem mem_split_iff : J ∈ split I i x ↔ ↑J = I.splitLower i x ∨ ↑J =
 #align box_integral.prepartition.mem_split_iff BoxIntegral.Prepartition.mem_split_iff
 -/
 
+#print BoxIntegral.Prepartition.mem_split_iff' /-
 theorem mem_split_iff' :
     J ∈ split I i x ↔
       (J : Set (ι → ℝ)) = I ∩ {y | y i ≤ x} ∨ (J : Set (ι → ℝ)) = I ∩ {y | x < y i} :=
   by simp [mem_split_iff, ← box.with_bot_coe_inj]
 #align box_integral.prepartition.mem_split_iff' BoxIntegral.Prepartition.mem_split_iff'
+-/
 
 #print BoxIntegral.Prepartition.iUnion_split /-
 @[simp]
@@ -216,11 +240,14 @@ theorem isPartitionSplit (I : Box ι) (i : ι) (x : ℝ) : IsPartition (split I
 #align box_integral.prepartition.is_partition_split BoxIntegral.Prepartition.isPartitionSplit
 -/
 
+#print BoxIntegral.Prepartition.sum_split_boxes /-
 theorem sum_split_boxes {M : Type _} [AddCommMonoid M] (I : Box ι) (i : ι) (x : ℝ) (f : Box ι → M) :
     ∑ J in (split I i x).boxes, f J = (I.splitLower i x).elim 0 f + (I.splitUpper i x).elim 0 f :=
   by rw [split, sum_of_with_bot, Finset.sum_pair (I.split_lower_ne_split_upper i x)]
 #align box_integral.prepartition.sum_split_boxes BoxIntegral.Prepartition.sum_split_boxes
+-/
 
+#print BoxIntegral.Prepartition.split_of_not_mem_Ioo /-
 /-- If `x ∉ (I.lower i, I.upper i)`, then the hyperplane `{y | y i = x}` does not split `I`. -/
 theorem split_of_not_mem_Ioo (h : x ∉ Ioo (I.lower i) (I.upper i)) : split I i x = ⊤ :=
   by
@@ -232,16 +259,21 @@ theorem split_of_not_mem_Ioo (h : x ∉ Ioo (I.lower i) (I.upper i)) : split I i
   · rwa [eq_comm, box.split_upper_eq_self]
   · rwa [eq_comm, box.split_lower_eq_self]
 #align box_integral.prepartition.split_of_not_mem_Ioo BoxIntegral.Prepartition.split_of_not_mem_Ioo
+-/
 
+#print BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_le /-
 theorem coe_eq_of_mem_split_of_mem_le {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
     (h₃ : y i ≤ x) : (J : Set (ι → ℝ)) = I ∩ {y | y i ≤ x} :=
   (mem_split_iff'.1 h₁).resolve_right fun H => by rw [← box.mem_coe, H] at h₂ ; exact h₃.not_lt h₂.2
 #align box_integral.prepartition.coe_eq_of_mem_split_of_mem_le BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_le
+-/
 
+#print BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_mem /-
 theorem coe_eq_of_mem_split_of_lt_mem {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
     (h₃ : x < y i) : (J : Set (ι → ℝ)) = I ∩ {y | x < y i} :=
   (mem_split_iff'.1 h₁).resolve_left fun H => by rw [← box.mem_coe, H] at h₂ ; exact h₃.not_le h₂.2
 #align box_integral.prepartition.coe_eq_of_mem_split_of_lt_mem BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_mem
+-/
 
 #print BoxIntegral.Prepartition.restrict_split /-
 @[simp]
@@ -269,10 +301,12 @@ def splitMany (I : Box ι) (s : Finset (ι × ℝ)) : Prepartition I :=
 #align box_integral.prepartition.split_many BoxIntegral.Prepartition.splitMany
 -/
 
+#print BoxIntegral.Prepartition.splitMany_empty /-
 @[simp]
 theorem splitMany_empty (I : Box ι) : splitMany I ∅ = ⊤ :=
   Finset.inf_empty
 #align box_integral.prepartition.split_many_empty BoxIntegral.Prepartition.splitMany_empty
+-/
 
 #print BoxIntegral.Prepartition.splitMany_insert /-
 @[simp]
@@ -282,10 +316,12 @@ theorem splitMany_insert (I : Box ι) (s : Finset (ι × ℝ)) (p : ι × ℝ) :
 #align box_integral.prepartition.split_many_insert BoxIntegral.Prepartition.splitMany_insert
 -/
 
+#print BoxIntegral.Prepartition.splitMany_le_split /-
 theorem splitMany_le_split (I : Box ι) {s : Finset (ι × ℝ)} {p : ι × ℝ} (hp : p ∈ s) :
     splitMany I s ≤ split I p.1 p.2 :=
   Finset.inf_le hp
 #align box_integral.prepartition.split_many_le_split BoxIntegral.Prepartition.splitMany_le_split
+-/
 
 #print BoxIntegral.Prepartition.isPartition_splitMany /-
 theorem isPartition_splitMany (I : Box ι) (s : Finset (ι × ℝ)) : IsPartition (splitMany I s) :=
@@ -311,6 +347,7 @@ theorem inf_splitMany {I : Box ι} (π : Prepartition I) (s : Finset (ι × ℝ)
 #align box_integral.prepartition.inf_split_many BoxIntegral.Prepartition.inf_splitMany
 -/
 
+#print BoxIntegral.Prepartition.not_disjoint_imp_le_of_subset_of_mem_splitMany /-
 /-- Let `s : finset (ι × ℝ)` be a set of hyperplanes `{x : ι → ℝ | x i = r}` in `ι → ℝ` encoded as
 pairs `(i, r)`. Suppose that this set contains all faces of a box `J`. The hyperplanes of `s` split
 a box `I` into subboxes. Let `Js` be one of them. If `J` and `Js` have nonempty intersection, then
@@ -331,11 +368,13 @@ theorem not_disjoint_imp_le_of_subset_of_mem_splitMany {I J Js : Box ι} {s : Fi
     rw [← box.coe_subset_coe, coe_eq_of_mem_split_of_mem_le Hmem this (hx i).2] at Hle 
     exact (Hle hy).2
 #align box_integral.prepartition.not_disjoint_imp_le_of_subset_of_mem_split_many BoxIntegral.Prepartition.not_disjoint_imp_le_of_subset_of_mem_splitMany
+-/
 
 section Fintype
 
 variable [Finite ι]
 
+#print BoxIntegral.Prepartition.eventually_not_disjoint_imp_le_of_mem_splitMany /-
 /-- Let `s` be a finite set of boxes in `ℝⁿ = ι → ℝ`. Then there exists a finite set `t₀` of
 hyperplanes (namely, the set of all hyperfaces of boxes in `s`) such that for any `t ⊇ t₀`
 and any box `I` in `ℝⁿ` the following holds. The hyperplanes from `t` split `I` into subboxes.
@@ -353,6 +392,7 @@ theorem eventually_not_disjoint_imp_le_of_mem_splitMany (s : Finset (Box ι)) :
   exact fun p hp =>
     ht (Finset.mem_biUnion.2 ⟨J, hJ, Finset.mem_biUnion.2 ⟨i, Finset.mem_univ _, hp⟩⟩)
 #align box_integral.prepartition.eventually_not_disjoint_imp_le_of_mem_split_many BoxIntegral.Prepartition.eventually_not_disjoint_imp_le_of_mem_splitMany
+-/
 
 #print BoxIntegral.Prepartition.eventually_splitMany_inf_eq_filter /-
 theorem eventually_splitMany_inf_eq_filter (π : Prepartition I) :
@@ -382,6 +422,7 @@ theorem exists_splitMany_inf_eq_filter_of_finite (s : Set (Prepartition I)) (hs
 #align box_integral.prepartition.exists_split_many_inf_eq_filter_of_finite BoxIntegral.Prepartition.exists_splitMany_inf_eq_filter_of_finite
 -/
 
+#print BoxIntegral.Prepartition.IsPartition.exists_splitMany_le /-
 /-- If `π` is a partition of `I`, then there exists a finite set `s` of hyperplanes such that
 `split_many I s ≤ π`. -/
 theorem IsPartition.exists_splitMany_le {I : Box ι} {π : Prepartition I} (h : IsPartition π) :
@@ -389,7 +430,9 @@ theorem IsPartition.exists_splitMany_le {I : Box ι} {π : Prepartition I} (h :
   (eventually_splitMany_inf_eq_filter π).exists.imp fun s hs => by
     rwa [h.Union_eq, filter_of_true, inf_eq_right] at hs ; exact fun J hJ => le_of_mem _ hJ
 #align box_integral.prepartition.is_partition.exists_split_many_le BoxIntegral.Prepartition.IsPartition.exists_splitMany_le
+-/
 
+#print BoxIntegral.Prepartition.exists_iUnion_eq_diff /-
 /-- For every prepartition `π` of `I` there exists a prepartition that covers exactly
 `I \ π.Union`. -/
 theorem exists_iUnion_eq_diff (π : Prepartition I) :
@@ -399,6 +442,7 @@ theorem exists_iUnion_eq_diff (π : Prepartition I) :
   use (split_many I s).filterₓ fun J => ¬(J : Set (ι → ℝ)) ⊆ π.Union
   simp [← hs]
 #align box_integral.prepartition.exists_Union_eq_diff BoxIntegral.Prepartition.exists_iUnion_eq_diff
+-/
 
 #print BoxIntegral.Prepartition.compl /-
 /-- If `π` is a prepartition of `I`, then `π.compl` is a prepartition of `I`
@@ -408,10 +452,12 @@ def compl (π : Prepartition I) : Prepartition I :=
 #align box_integral.prepartition.compl BoxIntegral.Prepartition.compl
 -/
 
+#print BoxIntegral.Prepartition.iUnion_compl /-
 @[simp]
 theorem iUnion_compl (π : Prepartition I) : π.compl.iUnion = I \ π.iUnion :=
   π.exists_iUnion_eq_diff.choose_spec
 #align box_integral.prepartition.Union_compl BoxIntegral.Prepartition.iUnion_compl
+-/
 
 #print BoxIntegral.Prepartition.compl_congr /-
 /-- Since the definition of `box_integral.prepartition.compl` uses `Exists.some`,
@@ -421,14 +467,18 @@ theorem compl_congr {π₁ π₂ : Prepartition I} (h : π₁.iUnion = π₂.iUn
 #align box_integral.prepartition.compl_congr BoxIntegral.Prepartition.compl_congr
 -/
 
+#print BoxIntegral.Prepartition.IsPartition.compl_eq_bot /-
 theorem IsPartition.compl_eq_bot {π : Prepartition I} (h : IsPartition π) : π.compl = ⊥ := by
   rw [← Union_eq_empty, Union_compl, h.Union_eq, diff_self]
 #align box_integral.prepartition.is_partition.compl_eq_bot BoxIntegral.Prepartition.IsPartition.compl_eq_bot
+-/
 
+#print BoxIntegral.Prepartition.compl_top /-
 @[simp]
 theorem compl_top : (⊤ : Prepartition I).compl = ⊥ :=
   (isPartitionTop I).compl_eq_bot
 #align box_integral.prepartition.compl_top BoxIntegral.Prepartition.compl_top
+-/
 
 end Fintype

9d2f0748

bump to nightly-2023-06-10-07

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

3fdc57bc

Diff

@@ -217,7 +217,7 @@ theorem isPartitionSplit (I : Box ι) (i : ι) (x : ℝ) : IsPartition (split I
 -/
 
 theorem sum_split_boxes {M : Type _} [AddCommMonoid M] (I : Box ι) (i : ι) (x : ℝ) (f : Box ι → M) :
-    (∑ J in (split I i x).boxes, f J) = (I.splitLower i x).elim 0 f + (I.splitUpper i x).elim 0 f :=
+    ∑ J in (split I i x).boxes, f J = (I.splitLower i x).elim 0 f + (I.splitUpper i x).elim 0 f :=
   by rw [split, sum_of_with_bot, Finset.sum_pair (I.split_lower_ne_split_upper i x)]
 #align box_integral.prepartition.sum_split_boxes BoxIntegral.Prepartition.sum_split_boxes

9d2f0748

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -69,7 +69,7 @@ def splitLower (I : Box ι) (i : ι) (x : ℝ) : WithBot (Box ι) :=
 -/
 
 @[simp]
-theorem coe_splitLower : (splitLower I i x : Set (ι → ℝ)) = I ∩ { y | y i ≤ x } :=
+theorem coe_splitLower : (splitLower I i x : Set (ι → ℝ)) = I ∩ {y | y i ≤ x} :=
   by
   rw [split_lower, coe_mk']
   ext y
@@ -113,7 +113,7 @@ def splitUpper (I : Box ι) (i : ι) (x : ℝ) : WithBot (Box ι) :=
 -/
 
 @[simp]
-theorem coe_splitUpper : (splitUpper I i x : Set (ι → ℝ)) = I ∩ { y | x < y i } :=
+theorem coe_splitUpper : (splitUpper I i x : Set (ι → ℝ)) = I ∩ {y | x < y i} :=
   by
   rw [split_upper, coe_mk']
   ext y
@@ -199,7 +199,7 @@ theorem mem_split_iff : J ∈ split I i x ↔ ↑J = I.splitLower i x ∨ ↑J =
 
 theorem mem_split_iff' :
     J ∈ split I i x ↔
-      (J : Set (ι → ℝ)) = I ∩ { y | y i ≤ x } ∨ (J : Set (ι → ℝ)) = I ∩ { y | x < y i } :=
+      (J : Set (ι → ℝ)) = I ∩ {y | y i ≤ x} ∨ (J : Set (ι → ℝ)) = I ∩ {y | x < y i} :=
   by simp [mem_split_iff, ← box.with_bot_coe_inj]
 #align box_integral.prepartition.mem_split_iff' BoxIntegral.Prepartition.mem_split_iff'
 
@@ -234,12 +234,12 @@ theorem split_of_not_mem_Ioo (h : x ∉ Ioo (I.lower i) (I.upper i)) : split I i
 #align box_integral.prepartition.split_of_not_mem_Ioo BoxIntegral.Prepartition.split_of_not_mem_Ioo
 
 theorem coe_eq_of_mem_split_of_mem_le {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
-    (h₃ : y i ≤ x) : (J : Set (ι → ℝ)) = I ∩ { y | y i ≤ x } :=
+    (h₃ : y i ≤ x) : (J : Set (ι → ℝ)) = I ∩ {y | y i ≤ x} :=
   (mem_split_iff'.1 h₁).resolve_right fun H => by rw [← box.mem_coe, H] at h₂ ; exact h₃.not_lt h₂.2
 #align box_integral.prepartition.coe_eq_of_mem_split_of_mem_le BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_le
 
 theorem coe_eq_of_mem_split_of_lt_mem {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
-    (h₃ : x < y i) : (J : Set (ι → ℝ)) = I ∩ { y | x < y i } :=
+    (h₃ : x < y i) : (J : Set (ι → ℝ)) = I ∩ {y | x < y i} :=
   (mem_split_iff'.1 h₁).resolve_left fun H => by rw [← box.mem_coe, H] at h₂ ; exact h₃.not_le h₂.2
 #align box_integral.prepartition.coe_eq_of_mem_split_of_lt_mem BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_mem

9d2f0748

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -181,7 +181,7 @@ def split (I : Box ι) (i : ι) (x : ℝ) : Prepartition I :=
     (by
       simp only [Finset.mem_insert, Finset.mem_singleton]
       rintro J (rfl | rfl)
-      exacts[box.split_lower_le, box.split_upper_le])
+      exacts [box.split_lower_le, box.split_upper_le])
     (by
       simp only [Finset.coe_insert, Finset.coe_singleton, true_and_iff, Set.mem_singleton_iff,
         pairwise_insert_of_symmetric symmetric_disjoint, pairwise_singleton]
@@ -227,20 +227,20 @@ theorem split_of_not_mem_Ioo (h : x ∉ Ioo (I.lower i) (I.upper i)) : split I i
   refine' ((is_partition_top I).eq_of_boxes_subset fun J hJ => _).symm
   rcases mem_top.1 hJ with rfl; clear hJ
   rw [mem_boxes, mem_split_iff]
-  rw [mem_Ioo, not_and_or, not_lt, not_lt] at h
-  cases h <;> [right;left]
+  rw [mem_Ioo, not_and_or, not_lt, not_lt] at h 
+  cases h <;> [right; left]
   · rwa [eq_comm, box.split_upper_eq_self]
   · rwa [eq_comm, box.split_lower_eq_self]
 #align box_integral.prepartition.split_of_not_mem_Ioo BoxIntegral.Prepartition.split_of_not_mem_Ioo
 
 theorem coe_eq_of_mem_split_of_mem_le {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
     (h₃ : y i ≤ x) : (J : Set (ι → ℝ)) = I ∩ { y | y i ≤ x } :=
-  (mem_split_iff'.1 h₁).resolve_right fun H => by rw [← box.mem_coe, H] at h₂; exact h₃.not_lt h₂.2
+  (mem_split_iff'.1 h₁).resolve_right fun H => by rw [← box.mem_coe, H] at h₂ ; exact h₃.not_lt h₂.2
 #align box_integral.prepartition.coe_eq_of_mem_split_of_mem_le BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_le
 
 theorem coe_eq_of_mem_split_of_lt_mem {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
     (h₃ : x < y i) : (J : Set (ι → ℝ)) = I ∩ { y | x < y i } :=
-  (mem_split_iff'.1 h₁).resolve_left fun H => by rw [← box.mem_coe, H] at h₂; exact h₃.not_le h₂.2
+  (mem_split_iff'.1 h₁).resolve_left fun H => by rw [← box.mem_coe, H] at h₂ ; exact h₃.not_le h₂.2
 #align box_integral.prepartition.coe_eq_of_mem_split_of_lt_mem BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_mem
 
 #print BoxIntegral.Prepartition.restrict_split /-
@@ -250,7 +250,7 @@ theorem restrict_split (h : I ≤ J) (i : ι) (x : ℝ) : (split J i x).restrict
   refine' ((is_partition_split J i x).restrict h).eq_of_boxes_subset _
   simp only [Finset.subset_iff, mem_boxes, mem_restrict', exists_prop, mem_split_iff']
   have : ∀ s, (I ∩ s : Set (ι → ℝ)) ⊆ J := fun s => (inter_subset_left _ _).trans h
-  rintro J₁ ⟨J₂, H₂ | H₂, H₁⟩ <;> [left;right] <;> simp [H₁, H₂, inter_left_comm ↑I, this]
+  rintro J₁ ⟨J₂, H₂ | H₂, H₁⟩ <;> [left; right] <;> simp [H₁, H₂, inter_left_comm ↑I, this]
 #align box_integral.prepartition.restrict_split BoxIntegral.Prepartition.restrict_split
 -/
 
@@ -319,16 +319,16 @@ theorem not_disjoint_imp_le_of_subset_of_mem_splitMany {I J Js : Box ι} {s : Fi
     (H : ∀ i, {(i, J i), (i, J.upper i)} ⊆ s) (HJs : Js ∈ splitMany I s)
     (Hn : ¬Disjoint (J : WithBot (Box ι)) Js) : Js ≤ J :=
   by
-  simp only [Finset.insert_subset, Finset.singleton_subset_iff] at H
+  simp only [Finset.insert_subset, Finset.singleton_subset_iff] at H 
   rcases box.not_disjoint_coe_iff_nonempty_inter.mp Hn with ⟨x, hx, hxs⟩
   refine' fun y hy i => ⟨_, _⟩
   · rcases split_many_le_split I (H i).1 HJs with ⟨Jl, Hmem : Jl ∈ split I i (J.lower i), Hle⟩
     have := Hle hxs
-    rw [← box.coe_subset_coe, coe_eq_of_mem_split_of_lt_mem Hmem this (hx i).1] at Hle
+    rw [← box.coe_subset_coe, coe_eq_of_mem_split_of_lt_mem Hmem this (hx i).1] at Hle 
     exact (Hle hy).2
   · rcases split_many_le_split I (H i).2 HJs with ⟨Jl, Hmem : Jl ∈ split I i (J.upper i), Hle⟩
     have := Hle hxs
-    rw [← box.coe_subset_coe, coe_eq_of_mem_split_of_mem_le Hmem this (hx i).2] at Hle
+    rw [← box.coe_subset_coe, coe_eq_of_mem_split_of_mem_le Hmem this (hx i).2] at Hle 
     exact (Hle hy).2
 #align box_integral.prepartition.not_disjoint_imp_le_of_subset_of_mem_split_many BoxIntegral.Prepartition.not_disjoint_imp_le_of_subset_of_mem_splitMany
 
@@ -366,7 +366,7 @@ theorem eventually_splitMany_inf_eq_filter (π : Prepartition I) :
     rintro _ ⟨J₁, h₁, rfl⟩ hne
     refine' ⟨_, ⟨J₁, ⟨h₁, subset.trans _ (π.subset_Union hJ)⟩, rfl⟩, le_rfl⟩
     exact ht I J hJ J₁ h₁ (mt disjoint_iff.1 hne)
-  · rw [mem_filter] at hJ
+  · rw [mem_filter] at hJ 
     rcases Set.mem_iUnion₂.1 (hJ.2 J.upper_mem) with ⟨J', hJ', hmem⟩
     refine' ⟨J', hJ', ht I _ hJ' _ hJ.1 <| box.not_disjoint_coe_iff_nonempty_inter.2 _⟩
     exact ⟨J.upper, hmem, J.upper_mem⟩
@@ -387,7 +387,7 @@ theorem exists_splitMany_inf_eq_filter_of_finite (s : Set (Prepartition I)) (hs
 theorem IsPartition.exists_splitMany_le {I : Box ι} {π : Prepartition I} (h : IsPartition π) :
     ∃ s, splitMany I s ≤ π :=
   (eventually_splitMany_inf_eq_filter π).exists.imp fun s hs => by
-    rwa [h.Union_eq, filter_of_true, inf_eq_right] at hs; exact fun J hJ => le_of_mem _ hJ
+    rwa [h.Union_eq, filter_of_true, inf_eq_right] at hs ; exact fun J hJ => le_of_mem _ hJ
 #align box_integral.prepartition.is_partition.exists_split_many_le BoxIntegral.Prepartition.IsPartition.exists_splitMany_le
 
 /-- For every prepartition `π` of `I` there exists a prepartition that covers exactly

9d2f0748

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -46,7 +46,7 @@ rectangular box, partition, hyperplane
 
 noncomputable section
 
-open Classical BigOperators Filter
+open scoped Classical BigOperators Filter
 
 open Function Set Filter

9d2f0748

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -68,12 +68,6 @@ def splitLower (I : Box ι) (i : ι) (x : ℝ) : WithBot (Box ι) :=
 #align box_integral.box.split_lower BoxIntegral.Box.splitLower
 -/
 
-/- warning: box_integral.box.coe_split_lower -> BoxIntegral.Box.coe_splitLower is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Eq.{succ u1} (Set.{u1} (ι -> Real)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Set.{u1} (ι -> Real)) (HasLiftT.mk.{succ u1, succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Set.{u1} (ι -> Real)) (CoeTCₓ.coe.{succ u1, succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.withBotCoe.{u1} ι))) (BoxIntegral.Box.splitLower.{u1} ι I i x)) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.hasInter.{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) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LE.le.{0} Real Real.hasLe (y i) x)))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Box.withBotToSet.{u1} ι (BoxIntegral.Box.splitLower.{u1} ι I i x)) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.instInterSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LE.le.{0} Real Real.instLEReal (y i) x)))
-Case conversion may be inaccurate. Consider using '#align box_integral.box.coe_split_lower BoxIntegral.Box.coe_splitLowerₓ'. -/
 @[simp]
 theorem coe_splitLower : (splitLower I i x : Set (ι → ℝ)) = I ∩ { y | y i ≤ x } :=
   by
@@ -84,22 +78,10 @@ theorem coe_splitLower : (splitLower I i x : Set (ι → ℝ)) = I ∩ { y | y i
   rw [and_comm' (y i ≤ x), Pi.le_def]
 #align box_integral.box.coe_split_lower BoxIntegral.Box.coe_splitLower
 
-/- warning: box_integral.box.split_lower_le -> BoxIntegral.Box.splitLower_le is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toHasLe.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)))) (BoxIntegral.Box.splitLower.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) I)
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toLE.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)))) (BoxIntegral.Box.splitLower.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) I)
-Case conversion may be inaccurate. Consider using '#align box_integral.box.split_lower_le BoxIntegral.Box.splitLower_leₓ'. -/
 theorem splitLower_le : I.splitLower i x ≤ I :=
   withBotCoe_subset_iff.1 <| by simp
 #align box_integral.box.split_lower_le BoxIntegral.Box.splitLower_le
 
-/- warning: box_integral.box.split_lower_eq_bot -> BoxIntegral.Box.splitLower_eq_bot is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) (Bot.bot.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasBot.{u1} (BoxIntegral.Box.{u1} ι)))) (LE.le.{0} Real Real.hasLe x (BoxIntegral.Box.lower.{u1} ι I i))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) (Bot.bot.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.bot.{u1} (BoxIntegral.Box.{u1} ι)))) (LE.le.{0} Real Real.instLEReal x (BoxIntegral.Box.lower.{u1} ι I i))
-Case conversion may be inaccurate. Consider using '#align box_integral.box.split_lower_eq_bot BoxIntegral.Box.splitLower_eq_botₓ'. -/
 @[simp]
 theorem splitLower_eq_bot {i x} : I.splitLower i x = ⊥ ↔ x ≤ I.lower i :=
   by
@@ -107,23 +89,11 @@ theorem splitLower_eq_bot {i x} : I.splitLower i x = ⊥ ↔ x ≤ I.lower i :=
   simp [(I.lower_lt_upper _).not_le]
 #align box_integral.box.split_lower_eq_bot BoxIntegral.Box.splitLower_eq_bot
 
-/- warning: box_integral.box.split_lower_eq_self -> BoxIntegral.Box.splitLower_eq_self is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) I)) (LE.le.{0} Real Real.hasLe (BoxIntegral.Box.upper.{u1} ι I i) x)
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) I)) (LE.le.{0} Real Real.instLEReal (BoxIntegral.Box.upper.{u1} ι I i) x)
-Case conversion may be inaccurate. Consider using '#align box_integral.box.split_lower_eq_self BoxIntegral.Box.splitLower_eq_selfₓ'. -/
 @[simp]
 theorem splitLower_eq_self : I.splitLower i x = I ↔ I.upper i ≤ x := by
   simp [split_lower, update_eq_iff]
 #align box_integral.box.split_lower_eq_self BoxIntegral.Box.splitLower_eq_self
 
-/- warning: box_integral.box.split_lower_def -> BoxIntegral.Box.splitLower_def is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioo.{0} Real Real.preorder (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x j)) (Iff.mpr (forall (x_1 : ι), (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) x_1 (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x x_1)) (And ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) x (BoxIntegral.Box.upper.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y)) (And.intro ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) x (BoxIntegral.Box.upper.{u1} ι I x))) (And.left (LT.lt.{0} Real (Preorder.toHasLt.{0} Real Real.preorder) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toHasLt.{0} Real Real.preorder) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) (BoxIntegral.Box.mk.{u1} ι (BoxIntegral.Box.lower.{u1} ι I) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x) h'))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioo.{0} Real Real.instPreorderReal (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I j) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x j)) (Iff.mpr (forall (x_1 : ι), LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x_1) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x x_1)) (And (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I i) x) (forall (x : ι), (Ne.{succ u1} ι x i) -> (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x) (BoxIntegral.Box.upper.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I j) y)) (And.intro (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I i) x) (forall (x : ι), (Ne.{succ u1} ι x i) -> (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x) (BoxIntegral.Box.upper.{u1} ι I x))) (And.left (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.instPreorderReal) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.instPreorderReal) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.mk.{u1} ι (BoxIntegral.Box.lower.{u1} ι I) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x) h'))
-Case conversion may be inaccurate. Consider using '#align box_integral.box.split_lower_def BoxIntegral.Box.splitLower_defₓ'. -/
 theorem splitLower_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.upper i))
     (h' : ∀ j, I.lower j < update I.upper i x j :=
       (forall_update_iff I.upper fun j y => I.lower j < y).2
@@ -142,12 +112,6 @@ def splitUpper (I : Box ι) (i : ι) (x : ℝ) : WithBot (Box ι) :=
 #align box_integral.box.split_upper BoxIntegral.Box.splitUpper
 -/
 
-/- warning: box_integral.box.coe_split_upper -> BoxIntegral.Box.coe_splitUpper is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Eq.{succ u1} (Set.{u1} (ι -> Real)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Set.{u1} (ι -> Real)) (HasLiftT.mk.{succ u1, succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Set.{u1} (ι -> Real)) (CoeTCₓ.coe.{succ u1, succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.withBotCoe.{u1} ι))) (BoxIntegral.Box.splitUpper.{u1} ι I i x)) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.hasInter.{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) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LT.lt.{0} Real Real.hasLt x (y i))))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Box.withBotToSet.{u1} ι (BoxIntegral.Box.splitUpper.{u1} ι I i x)) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.instInterSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LT.lt.{0} Real Real.instLTReal x (y i))))
-Case conversion may be inaccurate. Consider using '#align box_integral.box.coe_split_upper BoxIntegral.Box.coe_splitUpperₓ'. -/
 @[simp]
 theorem coe_splitUpper : (splitUpper I i x : Set (ι → ℝ)) = I ∩ { y | x < y i } :=
   by
@@ -159,22 +123,10 @@ theorem coe_splitUpper : (splitUpper I i x : Set (ι → ℝ)) = I ∩ { y | x <
   exact and_comm' _ _
 #align box_integral.box.coe_split_upper BoxIntegral.Box.coe_splitUpper
 
-/- warning: box_integral.box.split_upper_le -> BoxIntegral.Box.splitUpper_le is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toHasLe.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)))) (BoxIntegral.Box.splitUpper.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) I)
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toLE.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)))) (BoxIntegral.Box.splitUpper.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) I)
-Case conversion may be inaccurate. Consider using '#align box_integral.box.split_upper_le BoxIntegral.Box.splitUpper_leₓ'. -/
 theorem splitUpper_le : I.splitUpper i x ≤ I :=
   withBotCoe_subset_iff.1 <| by simp
 #align box_integral.box.split_upper_le BoxIntegral.Box.splitUpper_le
 
-/- warning: box_integral.box.split_upper_eq_bot -> BoxIntegral.Box.splitUpper_eq_bot is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) (Bot.bot.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasBot.{u1} (BoxIntegral.Box.{u1} ι)))) (LE.le.{0} Real Real.hasLe (BoxIntegral.Box.upper.{u1} ι I i) x)
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) (Bot.bot.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.bot.{u1} (BoxIntegral.Box.{u1} ι)))) (LE.le.{0} Real Real.instLEReal (BoxIntegral.Box.upper.{u1} ι I i) x)
-Case conversion may be inaccurate. Consider using '#align box_integral.box.split_upper_eq_bot BoxIntegral.Box.splitUpper_eq_botₓ'. -/
 @[simp]
 theorem splitUpper_eq_bot {i x} : I.splitUpper i x = ⊥ ↔ I.upper i ≤ x :=
   by
@@ -182,23 +134,11 @@ theorem splitUpper_eq_bot {i x} : I.splitUpper i x = ⊥ ↔ I.upper i ≤ x :=
   simp [(I.lower_lt_upper _).not_le]
 #align box_integral.box.split_upper_eq_bot BoxIntegral.Box.splitUpper_eq_bot
 
-/- warning: box_integral.box.split_upper_eq_self -> BoxIntegral.Box.splitUpper_eq_self is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) I)) (LE.le.{0} Real Real.hasLe x (BoxIntegral.Box.lower.{u1} ι I i))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) I)) (LE.le.{0} Real Real.instLEReal x (BoxIntegral.Box.lower.{u1} ι I i))
-Case conversion may be inaccurate. Consider using '#align box_integral.box.split_upper_eq_self BoxIntegral.Box.splitUpper_eq_selfₓ'. -/
 @[simp]
 theorem splitUpper_eq_self : I.splitUpper i x = I ↔ x ≤ I.lower i := by
   simp [split_upper, update_eq_iff]
 #align box_integral.box.split_upper_eq_self BoxIntegral.Box.splitUpper_eq_self
 
-/- warning: box_integral.box.split_upper_def -> BoxIntegral.Box.splitUpper_def is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioo.{0} Real Real.preorder (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.hasLt (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x j) (BoxIntegral.Box.upper.{u1} ι I j)) (Iff.mpr (forall (x_1 : ι), (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) x_1 (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x x_1)) (And ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) x (BoxIntegral.Box.lower.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j))) (And.intro ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) x (BoxIntegral.Box.lower.{u1} ι I x))) (And.right (LT.lt.{0} Real (Preorder.toHasLt.{0} Real Real.preorder) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toHasLt.{0} Real Real.preorder) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) (BoxIntegral.Box.mk.{u1} ι (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x) (BoxIntegral.Box.upper.{u1} ι I) h'))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioo.{0} Real Real.instPreorderReal (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.instLTReal (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x j) (BoxIntegral.Box.upper.{u1} ι I j)) (Iff.mpr (forall (x_1 : ι), LT.lt.{0} Real Real.instLTReal (Function.update.{succ u1, 1} ι (fun (a : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x x_1) (BoxIntegral.Box.upper.{u1} ι I x_1)) (And (LT.lt.{0} Real Real.instLTReal x (BoxIntegral.Box.upper.{u1} ι I i)) (forall (x : ι), (Ne.{succ u1} ι x i) -> (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x) (BoxIntegral.Box.upper.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.instLTReal y (BoxIntegral.Box.upper.{u1} ι I j))) (And.intro (LT.lt.{0} Real Real.instLTReal x (BoxIntegral.Box.upper.{u1} ι I i)) (forall (x : ι), (Ne.{succ u1} ι x i) -> (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x) (BoxIntegral.Box.upper.{u1} ι I x))) (And.right (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.instPreorderReal) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.instPreorderReal) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.mk.{u1} ι (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x) (BoxIntegral.Box.upper.{u1} ι I) h'))
-Case conversion may be inaccurate. Consider using '#align box_integral.box.split_upper_def BoxIntegral.Box.splitUpper_defₓ'. -/
 theorem splitUpper_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.upper i))
     (h' : ∀ j, update I.lower i x j < I.upper j :=
       (forall_update_iff I.lower fun j y => y < I.upper j).2
@@ -207,12 +147,6 @@ theorem splitUpper_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.uppe
   simp only [split_upper, mk'_eq_coe, max_eq_left h.1.le]; refine' ⟨_, rfl⟩; congr
 #align box_integral.box.split_upper_def BoxIntegral.Box.splitUpper_def
 
-/- warning: box_integral.box.disjoint_split_lower_split_upper -> BoxIntegral.Box.disjoint_splitLower_splitUpper is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} (I : BoxIntegral.Box.{u1} ι) (i : ι) (x : Real), Disjoint.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.partialOrder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)) (WithBot.orderBot.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) (BoxIntegral.Box.splitUpper.{u1} ι I i x)
-but is expected to have type
-  forall {ι : Type.{u1}} (I : BoxIntegral.Box.{u1} ι) (i : ι) (x : Real), Disjoint.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.partialOrder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)) (WithBot.orderBot.{u1} (BoxIntegral.Box.{u1} ι) (Preorder.toLE.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)))) (BoxIntegral.Box.splitLower.{u1} ι I i x) (BoxIntegral.Box.splitUpper.{u1} ι I i x)
-Case conversion may be inaccurate. Consider using '#align box_integral.box.disjoint_split_lower_split_upper BoxIntegral.Box.disjoint_splitLower_splitUpperₓ'. -/
 theorem disjoint_splitLower_splitUpper (I : Box ι) (i : ι) (x : ℝ) :
     Disjoint (I.splitLower i x) (I.splitUpper i x) :=
   by
@@ -263,12 +197,6 @@ theorem mem_split_iff : J ∈ split I i x ↔ ↑J = I.splitLower i x ∨ ↑J =
 #align box_integral.prepartition.mem_split_iff BoxIntegral.Prepartition.mem_split_iff
 -/
 
-/- warning: box_integral.prepartition.mem_split_iff' -> BoxIntegral.Prepartition.mem_split_iff' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) J (BoxIntegral.Prepartition.split.{u1} ι I i x)) (Or (Eq.{succ u1} (Set.{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} ι))) J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.hasInter.{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) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LE.le.{0} Real Real.hasLe (y i) x)))) (Eq.{succ u1} (Set.{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} ι))) J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.hasInter.{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) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LT.lt.{0} Real Real.hasLt x (y i))))))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) J (BoxIntegral.Prepartition.split.{u1} ι I i x)) (Or (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.instInterSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LE.le.{0} Real Real.instLEReal (y i) x)))) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.instInterSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LT.lt.{0} Real Real.instLTReal x (y i))))))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.mem_split_iff' BoxIntegral.Prepartition.mem_split_iff'ₓ'. -/
 theorem mem_split_iff' :
     J ∈ split I i x ↔
       (J : Set (ι → ℝ)) = I ∩ { y | y i ≤ x } ∨ (J : Set (ι → ℝ)) = I ∩ { y | x < y i } :=
@@ -288,23 +216,11 @@ theorem isPartitionSplit (I : Box ι) (i : ι) (x : ℝ) : IsPartition (split I
 #align box_integral.prepartition.is_partition_split BoxIntegral.Prepartition.isPartitionSplit
 -/
 
-/- warning: box_integral.prepartition.sum_split_boxes -> BoxIntegral.Prepartition.sum_split_boxes is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : AddCommMonoid.{u2} M] (I : BoxIntegral.Box.{u1} ι) (i : ι) (x : Real) (f : (BoxIntegral.Box.{u1} ι) -> M), Eq.{succ u2} M (Finset.sum.{u2, u1} M (BoxIntegral.Box.{u1} ι) _inst_1 (BoxIntegral.Prepartition.boxes.{u1} ι I (BoxIntegral.Prepartition.split.{u1} ι I i x)) (fun (J : BoxIntegral.Box.{u1} ι) => f J)) (HAdd.hAdd.{u2, u2, u2} M M M (instHAdd.{u2} M (AddZeroClass.toHasAdd.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_1)))) (Option.elim'.{u1, u2} (BoxIntegral.Box.{u1} ι) M (OfNat.ofNat.{u2} M 0 (OfNat.mk.{u2} M 0 (Zero.zero.{u2} M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_1)))))) f (BoxIntegral.Box.splitLower.{u1} ι I i x)) (Option.elim'.{u1, u2} (BoxIntegral.Box.{u1} ι) M (OfNat.ofNat.{u2} M 0 (OfNat.mk.{u2} M 0 (Zero.zero.{u2} M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_1)))))) f (BoxIntegral.Box.splitUpper.{u1} ι I i x)))
-but is expected to have type
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : AddCommMonoid.{u2} M] (I : BoxIntegral.Box.{u1} ι) (i : ι) (x : Real) (f : (BoxIntegral.Box.{u1} ι) -> M), Eq.{succ u2} M (Finset.sum.{u2, u1} M (BoxIntegral.Box.{u1} ι) _inst_1 (BoxIntegral.Prepartition.boxes.{u1} ι I (BoxIntegral.Prepartition.split.{u1} ι I i x)) (fun (J : BoxIntegral.Box.{u1} ι) => f J)) (HAdd.hAdd.{u2, u2, u2} M M M (instHAdd.{u2} M (AddZeroClass.toAdd.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_1)))) (Option.elim'.{u1, u2} (BoxIntegral.Box.{u1} ι) M (OfNat.ofNat.{u2} M 0 (Zero.toOfNat0.{u2} M (AddMonoid.toZero.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_1)))) f (BoxIntegral.Box.splitLower.{u1} ι I i x)) (Option.elim'.{u1, u2} (BoxIntegral.Box.{u1} ι) M (OfNat.ofNat.{u2} M 0 (Zero.toOfNat0.{u2} M (AddMonoid.toZero.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_1)))) f (BoxIntegral.Box.splitUpper.{u1} ι I i x)))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.sum_split_boxes BoxIntegral.Prepartition.sum_split_boxesₓ'. -/
 theorem sum_split_boxes {M : Type _} [AddCommMonoid M] (I : Box ι) (i : ι) (x : ℝ) (f : Box ι → M) :
     (∑ J in (split I i x).boxes, f J) = (I.splitLower i x).elim 0 f + (I.splitUpper i x).elim 0 f :=
   by rw [split, sum_of_with_bot, Finset.sum_pair (I.split_lower_ne_split_upper i x)]
 #align box_integral.prepartition.sum_split_boxes BoxIntegral.Prepartition.sum_split_boxes
 
-/- warning: box_integral.prepartition.split_of_not_mem_Ioo -> BoxIntegral.Prepartition.split_of_not_mem_Ioo is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, (Not (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioo.{0} Real Real.preorder (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i)))) -> (Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.split.{u1} ι I i x) (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toHasTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.orderTop.{u1} ι I))))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, (Not (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioo.{0} Real Real.instPreorderReal (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i)))) -> (Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.split.{u1} ι I i x) (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.instOrderTopPrepartitionInstLEPrepartition.{u1} ι I))))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.split_of_not_mem_Ioo BoxIntegral.Prepartition.split_of_not_mem_Iooₓ'. -/
 /-- If `x ∉ (I.lower i, I.upper i)`, then the hyperplane `{y | y i = x}` does not split `I`. -/
 theorem split_of_not_mem_Ioo (h : x ∉ Ioo (I.lower i) (I.upper i)) : split I i x = ⊤ :=
   by
@@ -317,23 +233,11 @@ theorem split_of_not_mem_Ioo (h : x ∉ Ioo (I.lower i) (I.upper i)) : split I i
   · rwa [eq_comm, box.split_lower_eq_self]
 #align box_integral.prepartition.split_of_not_mem_Ioo BoxIntegral.Prepartition.split_of_not_mem_Ioo
 
-/- warning: box_integral.prepartition.coe_eq_of_mem_split_of_mem_le -> BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_le is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real} {y : ι -> Real}, (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) J (BoxIntegral.Prepartition.split.{u1} ι I i x)) -> (Membership.Mem.{u1, u1} (ι -> Real) (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasMem.{u1} ι) y J) -> (LE.le.{0} Real Real.hasLe (y i) x) -> (Eq.{succ u1} (Set.{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} ι))) J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.hasInter.{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) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LE.le.{0} Real Real.hasLe (y i) x))))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real} {y : ι -> Real}, (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) J (BoxIntegral.Prepartition.split.{u1} ι I i x)) -> (Membership.mem.{u1, u1} (ι -> Real) (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instMembershipForAllRealBox.{u1} ι) y J) -> (LE.le.{0} Real Real.instLEReal (y i) x) -> (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.instInterSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LE.le.{0} Real Real.instLEReal (y i) x))))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.coe_eq_of_mem_split_of_mem_le BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_leₓ'. -/
 theorem coe_eq_of_mem_split_of_mem_le {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
     (h₃ : y i ≤ x) : (J : Set (ι → ℝ)) = I ∩ { y | y i ≤ x } :=
   (mem_split_iff'.1 h₁).resolve_right fun H => by rw [← box.mem_coe, H] at h₂; exact h₃.not_lt h₂.2
 #align box_integral.prepartition.coe_eq_of_mem_split_of_mem_le BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_le
 
-/- warning: box_integral.prepartition.coe_eq_of_mem_split_of_lt_mem -> BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_mem is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real} {y : ι -> Real}, (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) J (BoxIntegral.Prepartition.split.{u1} ι I i x)) -> (Membership.Mem.{u1, u1} (ι -> Real) (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasMem.{u1} ι) y J) -> (LT.lt.{0} Real Real.hasLt x (y i)) -> (Eq.{succ u1} (Set.{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} ι))) J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.hasInter.{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) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LT.lt.{0} Real Real.hasLt x (y i)))))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real} {y : ι -> Real}, (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) J (BoxIntegral.Prepartition.split.{u1} ι I i x)) -> (Membership.mem.{u1, u1} (ι -> Real) (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instMembershipForAllRealBox.{u1} ι) y J) -> (LT.lt.{0} Real Real.instLTReal x (y i)) -> (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.instInterSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LT.lt.{0} Real Real.instLTReal x (y i)))))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.coe_eq_of_mem_split_of_lt_mem BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_memₓ'. -/
 theorem coe_eq_of_mem_split_of_lt_mem {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
     (h₃ : x < y i) : (J : Set (ι → ℝ)) = I ∩ { y | x < y i } :=
   (mem_split_iff'.1 h₁).resolve_left fun H => by rw [← box.mem_coe, H] at h₂; exact h₃.not_le h₂.2
@@ -365,12 +269,6 @@ def splitMany (I : Box ι) (s : Finset (ι × ℝ)) : Prepartition I :=
 #align box_integral.prepartition.split_many BoxIntegral.Prepartition.splitMany
 -/
 
-/- warning: box_integral.prepartition.split_many_empty -> BoxIntegral.Prepartition.splitMany_empty is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} (I : BoxIntegral.Box.{u1} ι), Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.splitMany.{u1} ι I (EmptyCollection.emptyCollection.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.hasEmptyc.{u1} (Prod.{u1, 0} ι Real)))) (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toHasTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.orderTop.{u1} ι I)))
-but is expected to have type
-  forall {ι : Type.{u1}} (I : BoxIntegral.Box.{u1} ι), Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.splitMany.{u1} ι I (EmptyCollection.emptyCollection.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.instEmptyCollectionFinset.{u1} (Prod.{u1, 0} ι Real)))) (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.instOrderTopPrepartitionInstLEPrepartition.{u1} ι I)))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.split_many_empty BoxIntegral.Prepartition.splitMany_emptyₓ'. -/
 @[simp]
 theorem splitMany_empty (I : Box ι) : splitMany I ∅ = ⊤ :=
   Finset.inf_empty
@@ -384,12 +282,6 @@ theorem splitMany_insert (I : Box ι) (s : Finset (ι × ℝ)) (p : ι × ℝ) :
 #align box_integral.prepartition.split_many_insert BoxIntegral.Prepartition.splitMany_insert
 -/
 
-/- warning: box_integral.prepartition.split_many_le_split -> BoxIntegral.Prepartition.splitMany_le_split is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} (I : BoxIntegral.Box.{u1} ι) {s : Finset.{u1} (Prod.{u1, 0} ι Real)} {p : Prod.{u1, 0} ι Real}, (Membership.Mem.{u1, u1} (Prod.{u1, 0} ι Real) (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.hasMem.{u1} (Prod.{u1, 0} ι Real)) p s) -> (LE.le.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.splitMany.{u1} ι I s) (BoxIntegral.Prepartition.split.{u1} ι I (Prod.fst.{u1, 0} ι Real p) (Prod.snd.{u1, 0} ι Real p)))
-but is expected to have type
-  forall {ι : Type.{u1}} (I : BoxIntegral.Box.{u1} ι) {s : Finset.{u1} (Prod.{u1, 0} ι Real)} {p : Prod.{u1, 0} ι Real}, (Membership.mem.{u1, u1} (Prod.{u1, 0} ι Real) (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.instMembershipFinset.{u1} (Prod.{u1, 0} ι Real)) p s) -> (LE.le.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.splitMany.{u1} ι I s) (BoxIntegral.Prepartition.split.{u1} ι I (Prod.fst.{u1, 0} ι Real p) (Prod.snd.{u1, 0} ι Real p)))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.split_many_le_split BoxIntegral.Prepartition.splitMany_le_splitₓ'. -/
 theorem splitMany_le_split (I : Box ι) {s : Finset (ι × ℝ)} {p : ι × ℝ} (hp : p ∈ s) :
     splitMany I s ≤ split I p.1 p.2 :=
   Finset.inf_le hp
@@ -419,12 +311,6 @@ theorem inf_splitMany {I : Box ι} (π : Prepartition I) (s : Finset (ι × ℝ)
 #align box_integral.prepartition.inf_split_many BoxIntegral.Prepartition.inf_splitMany
 -/
 
-/- warning: box_integral.prepartition.not_disjoint_imp_le_of_subset_of_mem_split_many -> BoxIntegral.Prepartition.not_disjoint_imp_le_of_subset_of_mem_splitMany is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {Js : BoxIntegral.Box.{u1} ι} {s : Finset.{u1} (Prod.{u1, 0} ι Real)}, (forall (i : ι), HasSubset.Subset.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.hasSubset.{u1} (Prod.{u1, 0} ι Real)) (Insert.insert.{u1, u1} (Prod.{u1, 0} ι Real) (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.hasInsert.{u1} (Prod.{u1, 0} ι Real) (fun (a : Prod.{u1, 0} ι Real) (b : Prod.{u1, 0} ι Real) => Prod.Lex.decidableEq.{u1, 0} ι Real (fun (a : ι) (b : ι) => Classical.propDecidable (Eq.{succ u1} ι a b)) (fun (a : Real) (b : Real) => Real.decidableEq a b) a b)) (Prod.mk.{u1, 0} ι Real i (BoxIntegral.Box.lower.{u1} ι J i)) (Singleton.singleton.{u1, u1} (Prod.{u1, 0} ι Real) (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.hasSingleton.{u1} (Prod.{u1, 0} ι Real)) (Prod.mk.{u1, 0} ι Real i (BoxIntegral.Box.upper.{u1} ι J i)))) s) -> (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) Js (BoxIntegral.Prepartition.splitMany.{u1} ι I s)) -> (Not (Disjoint.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.partialOrder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)) (WithBot.orderBot.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) J) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) Js))) -> (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι) Js J)
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {Js : BoxIntegral.Box.{u1} ι} {s : Finset.{u1} (Prod.{u1, 0} ι Real)}, (forall (i : ι), HasSubset.Subset.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.instHasSubsetFinset.{u1} (Prod.{u1, 0} ι Real)) (Insert.insert.{u1, u1} (Prod.{u1, 0} ι Real) (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.instInsertFinset.{u1} (Prod.{u1, 0} ι Real) (fun (a : Prod.{u1, 0} ι Real) (b : Prod.{u1, 0} ι Real) => instDecidableEqProd.{u1, 0} ι Real (fun (a : ι) (b : ι) => Classical.propDecidable (Eq.{succ u1} ι a b)) (fun (a : Real) (b : Real) => Real.decidableEq a b) a b)) (Prod.mk.{u1, 0} ι Real i (BoxIntegral.Box.lower.{u1} ι J i)) (Singleton.singleton.{u1, u1} (Prod.{u1, 0} ι Real) (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.instSingletonFinset.{u1} (Prod.{u1, 0} ι Real)) (Prod.mk.{u1, 0} ι Real i (BoxIntegral.Box.upper.{u1} ι J i)))) s) -> (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) Js (BoxIntegral.Prepartition.splitMany.{u1} ι I s)) -> (Not (Disjoint.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.partialOrder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)) (WithBot.orderBot.{u1} (BoxIntegral.Box.{u1} ι) (Preorder.toLE.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)))) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) J) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) Js))) -> (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instLEBox.{u1} ι) Js J)
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.not_disjoint_imp_le_of_subset_of_mem_split_many BoxIntegral.Prepartition.not_disjoint_imp_le_of_subset_of_mem_splitManyₓ'. -/
 /-- Let `s : finset (ι × ℝ)` be a set of hyperplanes `{x : ι → ℝ | x i = r}` in `ι → ℝ` encoded as
 pairs `(i, r)`. Suppose that this set contains all faces of a box `J`. The hyperplanes of `s` split
 a box `I` into subboxes. Let `Js` be one of them. If `J` and `Js` have nonempty intersection, then
@@ -450,12 +336,6 @@ section Fintype
 
 variable [Finite ι]
 
-/- warning: box_integral.prepartition.eventually_not_disjoint_imp_le_of_mem_split_many -> BoxIntegral.Prepartition.eventually_not_disjoint_imp_le_of_mem_splitMany is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] (s : Finset.{u1} (BoxIntegral.Box.{u1} ι)), Filter.Eventually.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (fun (t : Finset.{u1} (Prod.{u1, 0} ι Real)) => forall (I : BoxIntegral.Box.{u1} ι) (J : BoxIntegral.Box.{u1} ι), (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (Finset.{u1} (BoxIntegral.Box.{u1} ι)) (Finset.hasMem.{u1} (BoxIntegral.Box.{u1} ι)) J s) -> (forall (J' : BoxIntegral.Box.{u1} ι), (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) J' (BoxIntegral.Prepartition.splitMany.{u1} ι I t)) -> (Not (Disjoint.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.partialOrder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)) (WithBot.orderBot.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) J) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) J'))) -> (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι) J' J))) (Filter.atTop.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (PartialOrder.toPreorder.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.partialOrder.{u1} (Prod.{u1, 0} ι Real))))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] (s : Finset.{u1} (BoxIntegral.Box.{u1} ι)), Filter.Eventually.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (fun (t : Finset.{u1} (Prod.{u1, 0} ι Real)) => forall (I : BoxIntegral.Box.{u1} ι) (J : BoxIntegral.Box.{u1} ι), (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (Finset.{u1} (BoxIntegral.Box.{u1} ι)) (Finset.instMembershipFinset.{u1} (BoxIntegral.Box.{u1} ι)) J s) -> (forall (J' : BoxIntegral.Box.{u1} ι), (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) J' (BoxIntegral.Prepartition.splitMany.{u1} ι I t)) -> (Not (Disjoint.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.partialOrder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)) (WithBot.orderBot.{u1} (BoxIntegral.Box.{u1} ι) (Preorder.toLE.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)))) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) J) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) J'))) -> (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instLEBox.{u1} ι) J' J))) (Filter.atTop.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (PartialOrder.toPreorder.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.partialOrder.{u1} (Prod.{u1, 0} ι Real))))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.eventually_not_disjoint_imp_le_of_mem_split_many BoxIntegral.Prepartition.eventually_not_disjoint_imp_le_of_mem_splitManyₓ'. -/
 /-- Let `s` be a finite set of boxes in `ℝⁿ = ι → ℝ`. Then there exists a finite set `t₀` of
 hyperplanes (namely, the set of all hyperfaces of boxes in `s`) such that for any `t ⊇ t₀`
 and any box `I` in `ℝⁿ` the following holds. The hyperplanes from `t` split `I` into subboxes.
@@ -502,12 +382,6 @@ theorem exists_splitMany_inf_eq_filter_of_finite (s : Set (Prepartition I)) (hs
 #align box_integral.prepartition.exists_split_many_inf_eq_filter_of_finite BoxIntegral.Prepartition.exists_splitMany_inf_eq_filter_of_finite
 -/
 
-/- warning: box_integral.prepartition.is_partition.exists_split_many_le -> BoxIntegral.Prepartition.IsPartition.exists_splitMany_le is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {I : BoxIntegral.Box.{u1} ι} {π : BoxIntegral.Prepartition.{u1} ι I}, (BoxIntegral.Prepartition.IsPartition.{u1} ι I π) -> (Exists.{succ u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (fun (s : Finset.{u1} (Prod.{u1, 0} ι Real)) => LE.le.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.splitMany.{u1} ι I s) π))
-but is expected to have type
-  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {I : BoxIntegral.Box.{u1} ι} {π : BoxIntegral.Prepartition.{u1} ι I}, (BoxIntegral.Prepartition.IsPartition.{u1} ι I π) -> (Exists.{succ u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (fun (s : Finset.{u1} (Prod.{u1, 0} ι Real)) => LE.le.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.splitMany.{u1} ι I s) π))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.is_partition.exists_split_many_le BoxIntegral.Prepartition.IsPartition.exists_splitMany_leₓ'. -/
 /-- If `π` is a partition of `I`, then there exists a finite set `s` of hyperplanes such that
 `split_many I s ≤ π`. -/
 theorem IsPartition.exists_splitMany_le {I : Box ι} {π : Prepartition I} (h : IsPartition π) :
@@ -516,12 +390,6 @@ theorem IsPartition.exists_splitMany_le {I : Box ι} {π : Prepartition I} (h :
     rwa [h.Union_eq, filter_of_true, inf_eq_right] at hs; exact fun J hJ => le_of_mem _ hJ
 #align box_integral.prepartition.is_partition.exists_split_many_le BoxIntegral.Prepartition.IsPartition.exists_splitMany_le
 
-/- warning: box_integral.prepartition.exists_Union_eq_diff -> BoxIntegral.Prepartition.exists_iUnion_eq_diff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Exists.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (fun (π' : BoxIntegral.Prepartition.{u1} ι I) => 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.Prepartition.iUnion.{u1} ι I π)))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Exists.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (fun (π' : BoxIntegral.Prepartition.{u1} ι I) => 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.Prepartition.iUnion.{u1} ι I π)))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.exists_Union_eq_diff BoxIntegral.Prepartition.exists_iUnion_eq_diffₓ'. -/
 /-- For every prepartition `π` of `I` there exists a prepartition that covers exactly
 `I \ π.Union`. -/
 theorem exists_iUnion_eq_diff (π : Prepartition I) :
@@ -540,12 +408,6 @@ def compl (π : Prepartition I) : Prepartition I :=
 #align box_integral.prepartition.compl BoxIntegral.Prepartition.compl
 -/
 
-/- warning: box_integral.prepartition.Union_compl -> BoxIntegral.Prepartition.iUnion_compl is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.iUnion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 π)) (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.Prepartition.iUnion.{u1} ι I π))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.iUnion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 π)) (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (Set.instSDiffSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (BoxIntegral.Prepartition.iUnion.{u1} ι I π))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.Union_compl BoxIntegral.Prepartition.iUnion_complₓ'. -/
 @[simp]
 theorem iUnion_compl (π : Prepartition I) : π.compl.iUnion = I \ π.iUnion :=
   π.exists_iUnion_eq_diff.choose_spec
@@ -559,22 +421,10 @@ theorem compl_congr {π₁ π₂ : Prepartition I} (h : π₁.iUnion = π₂.iUn
 #align box_integral.prepartition.compl_congr BoxIntegral.Prepartition.compl_congr
 -/
 
-/- warning: box_integral.prepartition.is_partition.compl_eq_bot -> BoxIntegral.Prepartition.IsPartition.compl_eq_bot is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] {π : BoxIntegral.Prepartition.{u1} ι I}, (BoxIntegral.Prepartition.IsPartition.{u1} ι I π) -> (Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 π) (Bot.bot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderBot.toHasBot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.orderBot.{u1} ι I))))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] {π : BoxIntegral.Prepartition.{u1} ι I}, (BoxIntegral.Prepartition.IsPartition.{u1} ι I π) -> (Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 π) (Bot.bot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderBot.toBot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.instOrderBotPrepartitionInstLEPrepartition.{u1} ι I))))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.is_partition.compl_eq_bot BoxIntegral.Prepartition.IsPartition.compl_eq_botₓ'. -/
 theorem IsPartition.compl_eq_bot {π : Prepartition I} (h : IsPartition π) : π.compl = ⊥ := by
   rw [← Union_eq_empty, Union_compl, h.Union_eq, diff_self]
 #align box_integral.prepartition.is_partition.compl_eq_bot BoxIntegral.Prepartition.IsPartition.compl_eq_bot
 
-/- warning: box_integral.prepartition.compl_top -> BoxIntegral.Prepartition.compl_top is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι], Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toHasTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.orderTop.{u1} ι I)))) (Bot.bot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderBot.toHasBot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.orderBot.{u1} ι I)))
-but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι], Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.instOrderTopPrepartitionInstLEPrepartition.{u1} ι I)))) (Bot.bot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderBot.toBot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.instOrderBotPrepartitionInstLEPrepartition.{u1} ι I)))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.compl_top BoxIntegral.Prepartition.compl_topₓ'. -/
 @[simp]
 theorem compl_top : (⊤ : Prepartition I).compl = ⊥ :=
   (isPartitionTop I).compl_eq_bot

9d2f0748

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -128,11 +128,8 @@ theorem splitLower_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.uppe
     (h' : ∀ j, I.lower j < update I.upper i x j :=
       (forall_update_iff I.upper fun j y => I.lower j < y).2
         ⟨h.1, fun j hne => I.lower_lt_upper _⟩) :
-    I.splitLower i x = (⟨I.lower, update I.upper i x, h'⟩ : Box ι) :=
-  by
-  simp only [split_lower, mk'_eq_coe, min_eq_left h.2.le]
-  use rfl
-  congr
+    I.splitLower i x = (⟨I.lower, update I.upper i x, h'⟩ : Box ι) := by
+  simp only [split_lower, mk'_eq_coe, min_eq_left h.2.le]; use rfl; congr
 #align box_integral.box.split_lower_def BoxIntegral.Box.splitLower_def
 
 #print BoxIntegral.Box.splitUpper /-
@@ -206,11 +203,8 @@ theorem splitUpper_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.uppe
     (h' : ∀ j, update I.lower i x j < I.upper j :=
       (forall_update_iff I.lower fun j y => y < I.upper j).2
         ⟨h.2, fun j hne => I.lower_lt_upper _⟩) :
-    I.splitUpper i x = (⟨update I.lower i x, I.upper, h'⟩ : Box ι) :=
-  by
-  simp only [split_upper, mk'_eq_coe, max_eq_left h.1.le]
-  refine' ⟨_, rfl⟩
-  congr
+    I.splitUpper i x = (⟨update I.lower i x, I.upper, h'⟩ : Box ι) := by
+  simp only [split_upper, mk'_eq_coe, max_eq_left h.1.le]; refine' ⟨_, rfl⟩; congr
 #align box_integral.box.split_upper_def BoxIntegral.Box.splitUpper_def
 
 /- warning: box_integral.box.disjoint_split_lower_split_upper -> BoxIntegral.Box.disjoint_splitLower_splitUpper is a dubious translation:
@@ -233,8 +227,7 @@ theorem splitLower_ne_splitUpper (I : Box ι) (i : ι) (x : ℝ) :
     I.splitLower i x ≠ I.splitUpper i x :=
   by
   cases le_or_lt x (I.lower i)
-  · rw [split_upper_eq_self.2 h, split_lower_eq_bot.2 h]
-    exact WithBot.bot_ne_coe
+  · rw [split_upper_eq_self.2 h, split_lower_eq_bot.2 h]; exact WithBot.bot_ne_coe
   · refine' (disjoint_split_lower_split_upper I i x).Ne _
     rwa [Ne.def, split_lower_eq_bot, not_le]
 #align box_integral.box.split_lower_ne_split_upper BoxIntegral.Box.splitLower_ne_splitUpper
@@ -332,10 +325,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.coe_eq_of_mem_split_of_mem_le BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_leₓ'. -/
 theorem coe_eq_of_mem_split_of_mem_le {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
     (h₃ : y i ≤ x) : (J : Set (ι → ℝ)) = I ∩ { y | y i ≤ x } :=
-  (mem_split_iff'.1 h₁).resolve_right fun H =>
-    by
-    rw [← box.mem_coe, H] at h₂
-    exact h₃.not_lt h₂.2
+  (mem_split_iff'.1 h₁).resolve_right fun H => by rw [← box.mem_coe, H] at h₂; exact h₃.not_lt h₂.2
 #align box_integral.prepartition.coe_eq_of_mem_split_of_mem_le BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_le
 
 /- warning: box_integral.prepartition.coe_eq_of_mem_split_of_lt_mem -> BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_mem is a dubious translation:
@@ -346,10 +336,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.coe_eq_of_mem_split_of_lt_mem BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_memₓ'. -/
 theorem coe_eq_of_mem_split_of_lt_mem {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
     (h₃ : x < y i) : (J : Set (ι → ℝ)) = I ∩ { y | x < y i } :=
-  (mem_split_iff'.1 h₁).resolve_left fun H =>
-    by
-    rw [← box.mem_coe, H] at h₂
-    exact h₃.not_le h₂.2
+  (mem_split_iff'.1 h₁).resolve_left fun H => by rw [← box.mem_coe, H] at h₂; exact h₃.not_le h₂.2
 #align box_integral.prepartition.coe_eq_of_mem_split_of_lt_mem BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_mem
 
 #print BoxIntegral.Prepartition.restrict_split /-
@@ -525,10 +512,8 @@ Case conversion may be inaccurate. Consider using '#align box_integral.prepartit
 `split_many I s ≤ π`. -/
 theorem IsPartition.exists_splitMany_le {I : Box ι} {π : Prepartition I} (h : IsPartition π) :
     ∃ s, splitMany I s ≤ π :=
-  (eventually_splitMany_inf_eq_filter π).exists.imp fun s hs =>
-    by
-    rwa [h.Union_eq, filter_of_true, inf_eq_right] at hs
-    exact fun J hJ => le_of_mem _ hJ
+  (eventually_splitMany_inf_eq_filter π).exists.imp fun s hs => by
+    rwa [h.Union_eq, filter_of_true, inf_eq_right] at hs; exact fun J hJ => le_of_mem _ hJ
 #align box_integral.prepartition.is_partition.exists_split_many_le BoxIntegral.Prepartition.IsPartition.exists_splitMany_le
 
 /- warning: box_integral.prepartition.exists_Union_eq_diff -> BoxIntegral.Prepartition.exists_iUnion_eq_diff is a dubious translation:
@@ -569,11 +554,8 @@ theorem iUnion_compl (π : Prepartition I) : π.compl.iUnion = I \ π.iUnion :=
 #print BoxIntegral.Prepartition.compl_congr /-
 /-- Since the definition of `box_integral.prepartition.compl` uses `Exists.some`,
 the result depends only on `π.Union`. -/
-theorem compl_congr {π₁ π₂ : Prepartition I} (h : π₁.iUnion = π₂.iUnion) : π₁.compl = π₂.compl :=
-  by
-  dsimp only [compl]
-  congr 1
-  rw [h]
+theorem compl_congr {π₁ π₂ : Prepartition I} (h : π₁.iUnion = π₂.iUnion) : π₁.compl = π₂.compl := by
+  dsimp only [compl]; congr 1; rw [h]
 #align box_integral.prepartition.compl_congr BoxIntegral.Prepartition.compl_congr
 -/

9d2f0748

bump to nightly-2023-05-24-06

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

fbc7b476

Diff

@@ -319,7 +319,7 @@ theorem split_of_not_mem_Ioo (h : x ∉ Ioo (I.lower i) (I.upper i)) : split I i
   rcases mem_top.1 hJ with rfl; clear hJ
   rw [mem_boxes, mem_split_iff]
   rw [mem_Ioo, not_and_or, not_lt, not_lt] at h
-  cases h <;> [right, left]
+  cases h <;> [right;left]
   · rwa [eq_comm, box.split_upper_eq_self]
   · rwa [eq_comm, box.split_lower_eq_self]
 #align box_integral.prepartition.split_of_not_mem_Ioo BoxIntegral.Prepartition.split_of_not_mem_Ioo
@@ -359,7 +359,7 @@ theorem restrict_split (h : I ≤ J) (i : ι) (x : ℝ) : (split J i x).restrict
   refine' ((is_partition_split J i x).restrict h).eq_of_boxes_subset _
   simp only [Finset.subset_iff, mem_boxes, mem_restrict', exists_prop, mem_split_iff']
   have : ∀ s, (I ∩ s : Set (ι → ℝ)) ⊆ J := fun s => (inter_subset_left _ _).trans h
-  rintro J₁ ⟨J₂, H₂ | H₂, H₁⟩ <;> [left, right] <;> simp [H₁, H₂, inter_left_comm ↑I, this]
+  rintro J₁ ⟨J₂, H₂ | H₂, H₁⟩ <;> [left;right] <;> simp [H₁, H₂, inter_left_comm ↑I, this]
 #align box_integral.prepartition.restrict_split BoxIntegral.Prepartition.restrict_split
 -/

9d2f0748

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -86,7 +86,7 @@ theorem coe_splitLower : (splitLower I i x : Set (ι → ℝ)) = I ∩ { y | y i
 
 /- warning: box_integral.box.split_lower_le -> BoxIntegral.Box.splitLower_le is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toLE.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)))) (BoxIntegral.Box.splitLower.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) I)
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toHasLe.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)))) (BoxIntegral.Box.splitLower.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) I)
 but is expected to have type
   forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toLE.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)))) (BoxIntegral.Box.splitLower.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) I)
 Case conversion may be inaccurate. Consider using '#align box_integral.box.split_lower_le BoxIntegral.Box.splitLower_leₓ'. -/
@@ -120,7 +120,7 @@ theorem splitLower_eq_self : I.splitLower i x = I ↔ I.upper i ≤ x := by
 
 /- warning: box_integral.box.split_lower_def -> BoxIntegral.Box.splitLower_def is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioo.{0} Real Real.preorder (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x j)) (Iff.mpr (forall (x_1 : ι), (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) x_1 (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x x_1)) (And ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) x (BoxIntegral.Box.upper.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y)) (And.intro ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) x (BoxIntegral.Box.upper.{u1} ι I x))) (And.left (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.preorder) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.preorder) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) (BoxIntegral.Box.mk.{u1} ι (BoxIntegral.Box.lower.{u1} ι I) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x) h'))
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioo.{0} Real Real.preorder (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x j)) (Iff.mpr (forall (x_1 : ι), (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) x_1 (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x x_1)) (And ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) x (BoxIntegral.Box.upper.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y)) (And.intro ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) x (BoxIntegral.Box.upper.{u1} ι I x))) (And.left (LT.lt.{0} Real (Preorder.toHasLt.{0} Real Real.preorder) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toHasLt.{0} Real Real.preorder) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) (BoxIntegral.Box.mk.{u1} ι (BoxIntegral.Box.lower.{u1} ι I) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x) h'))
 but is expected to have type
   forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioo.{0} Real Real.instPreorderReal (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I j) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x j)) (Iff.mpr (forall (x_1 : ι), LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x_1) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x x_1)) (And (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I i) x) (forall (x : ι), (Ne.{succ u1} ι x i) -> (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x) (BoxIntegral.Box.upper.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I j) y)) (And.intro (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I i) x) (forall (x : ι), (Ne.{succ u1} ι x i) -> (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x) (BoxIntegral.Box.upper.{u1} ι I x))) (And.left (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.instPreorderReal) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.instPreorderReal) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.mk.{u1} ι (BoxIntegral.Box.lower.{u1} ι I) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x) h'))
 Case conversion may be inaccurate. Consider using '#align box_integral.box.split_lower_def BoxIntegral.Box.splitLower_defₓ'. -/
@@ -164,7 +164,7 @@ theorem coe_splitUpper : (splitUpper I i x : Set (ι → ℝ)) = I ∩ { y | x <
 
 /- warning: box_integral.box.split_upper_le -> BoxIntegral.Box.splitUpper_le is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toLE.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)))) (BoxIntegral.Box.splitUpper.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) I)
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toHasLe.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)))) (BoxIntegral.Box.splitUpper.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) I)
 but is expected to have type
   forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toLE.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)))) (BoxIntegral.Box.splitUpper.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) I)
 Case conversion may be inaccurate. Consider using '#align box_integral.box.split_upper_le BoxIntegral.Box.splitUpper_leₓ'. -/
@@ -198,7 +198,7 @@ theorem splitUpper_eq_self : I.splitUpper i x = I ↔ x ≤ I.lower i := by
 
 /- warning: box_integral.box.split_upper_def -> BoxIntegral.Box.splitUpper_def is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioo.{0} Real Real.preorder (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.hasLt (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x j) (BoxIntegral.Box.upper.{u1} ι I j)) (Iff.mpr (forall (x_1 : ι), (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) x_1 (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x x_1)) (And ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) x (BoxIntegral.Box.lower.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j))) (And.intro ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) x (BoxIntegral.Box.lower.{u1} ι I x))) (And.right (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.preorder) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.preorder) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) (BoxIntegral.Box.mk.{u1} ι (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x) (BoxIntegral.Box.upper.{u1} ι I) h'))
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioo.{0} Real Real.preorder (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.hasLt (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x j) (BoxIntegral.Box.upper.{u1} ι I j)) (Iff.mpr (forall (x_1 : ι), (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) x_1 (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x x_1)) (And ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) x (BoxIntegral.Box.lower.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j))) (And.intro ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) x (BoxIntegral.Box.lower.{u1} ι I x))) (And.right (LT.lt.{0} Real (Preorder.toHasLt.{0} Real Real.preorder) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toHasLt.{0} Real Real.preorder) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) (BoxIntegral.Box.mk.{u1} ι (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x) (BoxIntegral.Box.upper.{u1} ι I) h'))
 but is expected to have type
   forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioo.{0} Real Real.instPreorderReal (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.instLTReal (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x j) (BoxIntegral.Box.upper.{u1} ι I j)) (Iff.mpr (forall (x_1 : ι), LT.lt.{0} Real Real.instLTReal (Function.update.{succ u1, 1} ι (fun (a : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x x_1) (BoxIntegral.Box.upper.{u1} ι I x_1)) (And (LT.lt.{0} Real Real.instLTReal x (BoxIntegral.Box.upper.{u1} ι I i)) (forall (x : ι), (Ne.{succ u1} ι x i) -> (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x) (BoxIntegral.Box.upper.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.instLTReal y (BoxIntegral.Box.upper.{u1} ι I j))) (And.intro (LT.lt.{0} Real Real.instLTReal x (BoxIntegral.Box.upper.{u1} ι I i)) (forall (x : ι), (Ne.{succ u1} ι x i) -> (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x) (BoxIntegral.Box.upper.{u1} ι I x))) (And.right (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.instPreorderReal) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.instPreorderReal) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.mk.{u1} ι (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x) (BoxIntegral.Box.upper.{u1} ι I) h'))
 Case conversion may be inaccurate. Consider using '#align box_integral.box.split_upper_def BoxIntegral.Box.splitUpper_defₓ'. -/

9d2f0748

bump to nightly-2023-05-14-08

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

d31da313

Diff

@@ -282,16 +282,16 @@ theorem mem_split_iff' :
   by simp [mem_split_iff, ← box.with_bot_coe_inj]
 #align box_integral.prepartition.mem_split_iff' BoxIntegral.Prepartition.mem_split_iff'
 
-#print BoxIntegral.Prepartition.unionᵢ_split /-
+#print BoxIntegral.Prepartition.iUnion_split /-
 @[simp]
-theorem unionᵢ_split (I : Box ι) (i : ι) (x : ℝ) : (split I i x).unionᵢ = I := by
+theorem iUnion_split (I : Box ι) (i : ι) (x : ℝ) : (split I i x).iUnion = I := by
   simp [split, ← inter_union_distrib_left, ← set_of_or, le_or_lt]
-#align box_integral.prepartition.Union_split BoxIntegral.Prepartition.unionᵢ_split
+#align box_integral.prepartition.Union_split BoxIntegral.Prepartition.iUnion_split
 -/
 
 #print BoxIntegral.Prepartition.isPartitionSplit /-
 theorem isPartitionSplit (I : Box ι) (i : ι) (x : ℝ) : IsPartition (split I i x) :=
-  isPartition_iff_unionᵢ_eq.2 <| unionᵢ_split I i x
+  isPartition_iff_iUnion_eq.2 <| iUnion_split I i x
 #align box_integral.prepartition.is_partition_split BoxIntegral.Prepartition.isPartitionSplit
 -/
 
@@ -365,8 +365,8 @@ theorem restrict_split (h : I ≤ J) (i : ι) (x : ℝ) : (split J i x).restrict
 
 #print BoxIntegral.Prepartition.inf_split /-
 theorem inf_split (π : Prepartition I) (i : ι) (x : ℝ) :
-    π ⊓ split I i x = π.bunionᵢ fun J => split J i x :=
-  bunionᵢ_congr_of_le rfl fun J hJ => restrict_split hJ i x
+    π ⊓ split I i x = π.biUnion fun J => split J i x :=
+  biUnion_congr_of_le rfl fun J hJ => restrict_split hJ i x
 #align box_integral.prepartition.inf_split BoxIntegral.Prepartition.inf_split
 -/
 
@@ -415,16 +415,16 @@ theorem isPartition_splitMany (I : Box ι) (s : Finset (ι × ℝ)) : IsPartitio
 #align box_integral.prepartition.is_partition_split_many BoxIntegral.Prepartition.isPartition_splitMany
 -/
 
-#print BoxIntegral.Prepartition.unionᵢ_splitMany /-
+#print BoxIntegral.Prepartition.iUnion_splitMany /-
 @[simp]
-theorem unionᵢ_splitMany (I : Box ι) (s : Finset (ι × ℝ)) : (splitMany I s).unionᵢ = I :=
-  (isPartition_splitMany I s).unionᵢ_eq
-#align box_integral.prepartition.Union_split_many BoxIntegral.Prepartition.unionᵢ_splitMany
+theorem iUnion_splitMany (I : Box ι) (s : Finset (ι × ℝ)) : (splitMany I s).iUnion = I :=
+  (isPartition_splitMany I s).iUnion_eq
+#align box_integral.prepartition.Union_split_many BoxIntegral.Prepartition.iUnion_splitMany
 -/
 
 #print BoxIntegral.Prepartition.inf_splitMany /-
 theorem inf_splitMany {I : Box ι} (π : Prepartition I) (s : Finset (ι × ℝ)) :
-    π ⊓ splitMany I s = π.bunionᵢ fun J => splitMany J s :=
+    π ⊓ splitMany I s = π.biUnion fun J => splitMany J s :=
   by
   induction' s using Finset.induction_on with p s hp ihp
   · simp
@@ -484,13 +484,13 @@ theorem eventually_not_disjoint_imp_le_of_mem_splitMany (s : Finset (Box ι)) :
       ⟨s.bUnion fun J => finset.univ.bUnion fun i => {(i, J i), (i, J.upper i)},
         fun t ht I J hJ J' hJ' => not_disjoint_imp_le_of_subset_of_mem_split_many (fun i => _) hJ'⟩
   exact fun p hp =>
-    ht (Finset.mem_bunionᵢ.2 ⟨J, hJ, Finset.mem_bunionᵢ.2 ⟨i, Finset.mem_univ _, hp⟩⟩)
+    ht (Finset.mem_biUnion.2 ⟨J, hJ, Finset.mem_biUnion.2 ⟨i, Finset.mem_univ _, hp⟩⟩)
 #align box_integral.prepartition.eventually_not_disjoint_imp_le_of_mem_split_many BoxIntegral.Prepartition.eventually_not_disjoint_imp_le_of_mem_splitMany
 
 #print BoxIntegral.Prepartition.eventually_splitMany_inf_eq_filter /-
 theorem eventually_splitMany_inf_eq_filter (π : Prepartition I) :
     ∀ᶠ t : Finset (ι × ℝ) in atTop,
-      π ⊓ splitMany I t = (splitMany I t).filterₓ fun J => ↑J ⊆ π.unionᵢ :=
+      π ⊓ splitMany I t = (splitMany I t).filterₓ fun J => ↑J ⊆ π.iUnion :=
   by
   refine' (eventually_not_disjoint_imp_le_of_mem_split_many π.boxes).mono fun t ht => _
   refine' le_antisymm ((bUnion_le_iff _).2 fun J hJ => _) (le_inf (fun J hJ => _) (filter_le _ _))
@@ -500,7 +500,7 @@ theorem eventually_splitMany_inf_eq_filter (π : Prepartition I) :
     refine' ⟨_, ⟨J₁, ⟨h₁, subset.trans _ (π.subset_Union hJ)⟩, rfl⟩, le_rfl⟩
     exact ht I J hJ J₁ h₁ (mt disjoint_iff.1 hne)
   · rw [mem_filter] at hJ
-    rcases Set.mem_unionᵢ₂.1 (hJ.2 J.upper_mem) with ⟨J', hJ', hmem⟩
+    rcases Set.mem_iUnion₂.1 (hJ.2 J.upper_mem) with ⟨J', hJ', hmem⟩
     refine' ⟨J', hJ', ht I _ hJ' _ hJ.1 <| box.not_disjoint_coe_iff_nonempty_inter.2 _⟩
     exact ⟨J.upper, hmem, J.upper_mem⟩
 #align box_integral.prepartition.eventually_split_many_inf_eq_filter BoxIntegral.Prepartition.eventually_splitMany_inf_eq_filter
@@ -509,7 +509,7 @@ theorem eventually_splitMany_inf_eq_filter (π : Prepartition I) :
 #print BoxIntegral.Prepartition.exists_splitMany_inf_eq_filter_of_finite /-
 theorem exists_splitMany_inf_eq_filter_of_finite (s : Set (Prepartition I)) (hs : s.Finite) :
     ∃ t : Finset (ι × ℝ),
-      ∀ π ∈ s, π ⊓ splitMany I t = (splitMany I t).filterₓ fun J => ↑J ⊆ π.unionᵢ :=
+      ∀ π ∈ s, π ⊓ splitMany I t = (splitMany I t).filterₓ fun J => ↑J ⊆ π.iUnion :=
   haveI := fun π (hπ : π ∈ s) => eventually_split_many_inf_eq_filter π
   (hs.eventually_all.2 this).exists
 #align box_integral.prepartition.exists_split_many_inf_eq_filter_of_finite BoxIntegral.Prepartition.exists_splitMany_inf_eq_filter_of_finite
@@ -531,45 +531,45 @@ theorem IsPartition.exists_splitMany_le {I : Box ι} {π : Prepartition I} (h :
     exact fun J hJ => le_of_mem _ hJ
 #align box_integral.prepartition.is_partition.exists_split_many_le BoxIntegral.Prepartition.IsPartition.exists_splitMany_le
 
-/- warning: box_integral.prepartition.exists_Union_eq_diff -> BoxIntegral.Prepartition.exists_unionᵢ_eq_diff is a dubious translation:
+/- warning: box_integral.prepartition.exists_Union_eq_diff -> BoxIntegral.Prepartition.exists_iUnion_eq_diff is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Exists.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (fun (π' : BoxIntegral.Prepartition.{u1} ι I) => Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.unionᵢ.{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.Prepartition.unionᵢ.{u1} ι I π)))
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Exists.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (fun (π' : BoxIntegral.Prepartition.{u1} ι I) => 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.Prepartition.iUnion.{u1} ι I π)))
 but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Exists.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (fun (π' : BoxIntegral.Prepartition.{u1} ι I) => Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.unionᵢ.{u1} ι I π') (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (Set.instSDiffSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (BoxIntegral.Prepartition.unionᵢ.{u1} ι I π)))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.exists_Union_eq_diff BoxIntegral.Prepartition.exists_unionᵢ_eq_diffₓ'. -/
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Exists.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (fun (π' : BoxIntegral.Prepartition.{u1} ι I) => 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.Prepartition.iUnion.{u1} ι I π)))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.exists_Union_eq_diff BoxIntegral.Prepartition.exists_iUnion_eq_diffₓ'. -/
 /-- For every prepartition `π` of `I` there exists a prepartition that covers exactly
 `I \ π.Union`. -/
-theorem exists_unionᵢ_eq_diff (π : Prepartition I) :
-    ∃ π' : Prepartition I, π'.unionᵢ = I \ π.unionᵢ :=
+theorem exists_iUnion_eq_diff (π : Prepartition I) :
+    ∃ π' : Prepartition I, π'.iUnion = I \ π.iUnion :=
   by
   rcases π.eventually_split_many_inf_eq_filter.exists with ⟨s, hs⟩
   use (split_many I s).filterₓ fun J => ¬(J : Set (ι → ℝ)) ⊆ π.Union
   simp [← hs]
-#align box_integral.prepartition.exists_Union_eq_diff BoxIntegral.Prepartition.exists_unionᵢ_eq_diff
+#align box_integral.prepartition.exists_Union_eq_diff BoxIntegral.Prepartition.exists_iUnion_eq_diff
 
 #print BoxIntegral.Prepartition.compl /-
 /-- If `π` is a prepartition of `I`, then `π.compl` is a prepartition of `I`
 such that `π.compl.Union = I \ π.Union`. -/
 def compl (π : Prepartition I) : Prepartition I :=
-  π.exists_unionᵢ_eq_diff.some
+  π.exists_iUnion_eq_diff.some
 #align box_integral.prepartition.compl BoxIntegral.Prepartition.compl
 -/
 
-/- warning: box_integral.prepartition.Union_compl -> BoxIntegral.Prepartition.unionᵢ_compl is a dubious translation:
+/- warning: box_integral.prepartition.Union_compl -> BoxIntegral.Prepartition.iUnion_compl is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.unionᵢ.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 π)) (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.Prepartition.unionᵢ.{u1} ι I π))
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.iUnion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 π)) (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.Prepartition.iUnion.{u1} ι I π))
 but is expected to have type
-  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.unionᵢ.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 π)) (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (Set.instSDiffSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (BoxIntegral.Prepartition.unionᵢ.{u1} ι I π))
-Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.Union_compl BoxIntegral.Prepartition.unionᵢ_complₓ'. -/
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.iUnion.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 π)) (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (Set.instSDiffSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (BoxIntegral.Prepartition.iUnion.{u1} ι I π))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.Union_compl BoxIntegral.Prepartition.iUnion_complₓ'. -/
 @[simp]
-theorem unionᵢ_compl (π : Prepartition I) : π.compl.unionᵢ = I \ π.unionᵢ :=
-  π.exists_unionᵢ_eq_diff.choose_spec
-#align box_integral.prepartition.Union_compl BoxIntegral.Prepartition.unionᵢ_compl
+theorem iUnion_compl (π : Prepartition I) : π.compl.iUnion = I \ π.iUnion :=
+  π.exists_iUnion_eq_diff.choose_spec
+#align box_integral.prepartition.Union_compl BoxIntegral.Prepartition.iUnion_compl
 
 #print BoxIntegral.Prepartition.compl_congr /-
 /-- Since the definition of `box_integral.prepartition.compl` uses `Exists.some`,
 the result depends only on `π.Union`. -/
-theorem compl_congr {π₁ π₂ : Prepartition I} (h : π₁.unionᵢ = π₂.unionᵢ) : π₁.compl = π₂.compl :=
+theorem compl_congr {π₁ π₂ : Prepartition I} (h : π₁.iUnion = π₂.iUnion) : π₁.compl = π₂.compl :=
   by
   dsimp only [compl]
   congr 1

9d2f0748

bump to nightly-2023-04-28-02

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

473bb540

Diff

@@ -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.split
-! leanprover-community/mathlib commit 6ca1a09bc9aa75824bf97388c9e3b441fc4ccf3f
+! leanprover-community/mathlib commit 9d2f0748e6c50d7a2657c564b1ff2c695b39148d
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.Analysis.BoxIntegral.Partition.Basic
 /-!
 # Split a box along one or more hyperplanes
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 ## Main definitions
 
 A hyperplane `{x : ι → ℝ | x i = a}` splits a rectangular box `I : box_integral.box ι` into two

6ca1a09b

bump to nightly-2023-04-26-14

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

1e7bac84

Diff

@@ -55,6 +55,7 @@ namespace Box
 
 variable {I : Box ι} {i : ι} {x : ℝ} {y : ι → ℝ}
 
+#print BoxIntegral.Box.splitLower /-
 /-- Given a box `I` and `x ∈ (I.lower i, I.upper i)`, the hyperplane `{y : ι → ℝ | y i = x}` splits
 `I` into two boxes. `box_integral.box.split_lower I i x` is the box `I ∩ {y | y i ≤ x}`
 (if it is nonempty). As usual, we represent a box that may be empty as
@@ -62,7 +63,14 @@ variable {I : Box ι} {i : ι} {x : ℝ} {y : ι → ℝ}
 def splitLower (I : Box ι) (i : ι) (x : ℝ) : WithBot (Box ι) :=
   mk' I.lower (update I.upper i (min x (I.upper i)))
 #align box_integral.box.split_lower BoxIntegral.Box.splitLower
+-/
 
+/- warning: box_integral.box.coe_split_lower -> BoxIntegral.Box.coe_splitLower is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Eq.{succ u1} (Set.{u1} (ι -> Real)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Set.{u1} (ι -> Real)) (HasLiftT.mk.{succ u1, succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Set.{u1} (ι -> Real)) (CoeTCₓ.coe.{succ u1, succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.withBotCoe.{u1} ι))) (BoxIntegral.Box.splitLower.{u1} ι I i x)) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.hasInter.{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) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LE.le.{0} Real Real.hasLe (y i) x)))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Box.withBotToSet.{u1} ι (BoxIntegral.Box.splitLower.{u1} ι I i x)) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.instInterSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LE.le.{0} Real Real.instLEReal (y i) x)))
+Case conversion may be inaccurate. Consider using '#align box_integral.box.coe_split_lower BoxIntegral.Box.coe_splitLowerₓ'. -/
 @[simp]
 theorem coe_splitLower : (splitLower I i x : Set (ι → ℝ)) = I ∩ { y | y i ≤ x } :=
   by
@@ -73,10 +81,22 @@ theorem coe_splitLower : (splitLower I i x : Set (ι → ℝ)) = I ∩ { y | y i
   rw [and_comm' (y i ≤ x), Pi.le_def]
 #align box_integral.box.coe_split_lower BoxIntegral.Box.coe_splitLower
 
+/- warning: box_integral.box.split_lower_le -> BoxIntegral.Box.splitLower_le is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toLE.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)))) (BoxIntegral.Box.splitLower.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) I)
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toLE.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)))) (BoxIntegral.Box.splitLower.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) I)
+Case conversion may be inaccurate. Consider using '#align box_integral.box.split_lower_le BoxIntegral.Box.splitLower_leₓ'. -/
 theorem splitLower_le : I.splitLower i x ≤ I :=
   withBotCoe_subset_iff.1 <| by simp
 #align box_integral.box.split_lower_le BoxIntegral.Box.splitLower_le
 
+/- warning: box_integral.box.split_lower_eq_bot -> BoxIntegral.Box.splitLower_eq_bot is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) (Bot.bot.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasBot.{u1} (BoxIntegral.Box.{u1} ι)))) (LE.le.{0} Real Real.hasLe x (BoxIntegral.Box.lower.{u1} ι I i))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) (Bot.bot.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.bot.{u1} (BoxIntegral.Box.{u1} ι)))) (LE.le.{0} Real Real.instLEReal x (BoxIntegral.Box.lower.{u1} ι I i))
+Case conversion may be inaccurate. Consider using '#align box_integral.box.split_lower_eq_bot BoxIntegral.Box.splitLower_eq_botₓ'. -/
 @[simp]
 theorem splitLower_eq_bot {i x} : I.splitLower i x = ⊥ ↔ x ≤ I.lower i :=
   by
@@ -84,11 +104,23 @@ theorem splitLower_eq_bot {i x} : I.splitLower i x = ⊥ ↔ x ≤ I.lower i :=
   simp [(I.lower_lt_upper _).not_le]
 #align box_integral.box.split_lower_eq_bot BoxIntegral.Box.splitLower_eq_bot
 
+/- warning: box_integral.box.split_lower_eq_self -> BoxIntegral.Box.splitLower_eq_self is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) I)) (LE.le.{0} Real Real.hasLe (BoxIntegral.Box.upper.{u1} ι I i) x)
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) I)) (LE.le.{0} Real Real.instLEReal (BoxIntegral.Box.upper.{u1} ι I i) x)
+Case conversion may be inaccurate. Consider using '#align box_integral.box.split_lower_eq_self BoxIntegral.Box.splitLower_eq_selfₓ'. -/
 @[simp]
 theorem splitLower_eq_self : I.splitLower i x = I ↔ I.upper i ≤ x := by
   simp [split_lower, update_eq_iff]
 #align box_integral.box.split_lower_eq_self BoxIntegral.Box.splitLower_eq_self
 
+/- warning: box_integral.box.split_lower_def -> BoxIntegral.Box.splitLower_def is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioo.{0} Real Real.preorder (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x j)) (Iff.mpr (forall (x_1 : ι), (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) x_1 (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x x_1)) (And ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) x (BoxIntegral.Box.upper.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y)) (And.intro ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt (BoxIntegral.Box.lower.{u1} ι I j) y) x (BoxIntegral.Box.upper.{u1} ι I x))) (And.left (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.preorder) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.preorder) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) (BoxIntegral.Box.mk.{u1} ι (BoxIntegral.Box.lower.{u1} ι I) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x) h'))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioo.{0} Real Real.instPreorderReal (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I j) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x j)) (Iff.mpr (forall (x_1 : ι), LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x_1) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x x_1)) (And (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I i) x) (forall (x : ι), (Ne.{succ u1} ι x i) -> (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x) (BoxIntegral.Box.upper.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I j) y)) (And.intro (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I i) x) (forall (x : ι), (Ne.{succ u1} ι x i) -> (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x) (BoxIntegral.Box.upper.{u1} ι I x))) (And.left (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.instPreorderReal) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.instPreorderReal) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.mk.{u1} ι (BoxIntegral.Box.lower.{u1} ι I) (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.upper.{u1} ι I) i x) h'))
+Case conversion may be inaccurate. Consider using '#align box_integral.box.split_lower_def BoxIntegral.Box.splitLower_defₓ'. -/
 theorem splitLower_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.upper i))
     (h' : ∀ j, I.lower j < update I.upper i x j :=
       (forall_update_iff I.upper fun j y => I.lower j < y).2
@@ -100,6 +132,7 @@ theorem splitLower_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.uppe
   congr
 #align box_integral.box.split_lower_def BoxIntegral.Box.splitLower_def
 
+#print BoxIntegral.Box.splitUpper /-
 /-- Given a box `I` and `x ∈ (I.lower i, I.upper i)`, the hyperplane `{y : ι → ℝ | y i = x}` splits
 `I` into two boxes. `box_integral.box.split_upper I i x` is the box `I ∩ {y | x < y i}`
 (if it is nonempty). As usual, we represent a box that may be empty as
@@ -107,7 +140,14 @@ theorem splitLower_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.uppe
 def splitUpper (I : Box ι) (i : ι) (x : ℝ) : WithBot (Box ι) :=
   mk' (update I.lower i (max x (I.lower i))) I.upper
 #align box_integral.box.split_upper BoxIntegral.Box.splitUpper
+-/
 
+/- warning: box_integral.box.coe_split_upper -> BoxIntegral.Box.coe_splitUpper is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Eq.{succ u1} (Set.{u1} (ι -> Real)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Set.{u1} (ι -> Real)) (HasLiftT.mk.{succ u1, succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Set.{u1} (ι -> Real)) (CoeTCₓ.coe.{succ u1, succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Set.{u1} (ι -> Real)) (BoxIntegral.Box.withBotCoe.{u1} ι))) (BoxIntegral.Box.splitUpper.{u1} ι I i x)) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.hasInter.{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) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LT.lt.{0} Real Real.hasLt x (y i))))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Box.withBotToSet.{u1} ι (BoxIntegral.Box.splitUpper.{u1} ι I i x)) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.instInterSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LT.lt.{0} Real Real.instLTReal x (y i))))
+Case conversion may be inaccurate. Consider using '#align box_integral.box.coe_split_upper BoxIntegral.Box.coe_splitUpperₓ'. -/
 @[simp]
 theorem coe_splitUpper : (splitUpper I i x : Set (ι → ℝ)) = I ∩ { y | x < y i } :=
   by
@@ -119,10 +159,22 @@ theorem coe_splitUpper : (splitUpper I i x : Set (ι → ℝ)) = I ∩ { y | x <
   exact and_comm' _ _
 #align box_integral.box.coe_split_upper BoxIntegral.Box.coe_splitUpper
 
+/- warning: box_integral.box.split_upper_le -> BoxIntegral.Box.splitUpper_le is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toLE.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)))) (BoxIntegral.Box.splitUpper.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) I)
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, LE.le.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (Preorder.toLE.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.preorder.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)))) (BoxIntegral.Box.splitUpper.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) I)
+Case conversion may be inaccurate. Consider using '#align box_integral.box.split_upper_le BoxIntegral.Box.splitUpper_leₓ'. -/
 theorem splitUpper_le : I.splitUpper i x ≤ I :=
   withBotCoe_subset_iff.1 <| by simp
 #align box_integral.box.split_upper_le BoxIntegral.Box.splitUpper_le
 
+/- warning: box_integral.box.split_upper_eq_bot -> BoxIntegral.Box.splitUpper_eq_bot is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) (Bot.bot.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasBot.{u1} (BoxIntegral.Box.{u1} ι)))) (LE.le.{0} Real Real.hasLe (BoxIntegral.Box.upper.{u1} ι I i) x)
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) (Bot.bot.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.bot.{u1} (BoxIntegral.Box.{u1} ι)))) (LE.le.{0} Real Real.instLEReal (BoxIntegral.Box.upper.{u1} ι I i) x)
+Case conversion may be inaccurate. Consider using '#align box_integral.box.split_upper_eq_bot BoxIntegral.Box.splitUpper_eq_botₓ'. -/
 @[simp]
 theorem splitUpper_eq_bot {i x} : I.splitUpper i x = ⊥ ↔ I.upper i ≤ x :=
   by
@@ -130,11 +182,23 @@ theorem splitUpper_eq_bot {i x} : I.splitUpper i x = ⊥ ↔ I.upper i ≤ x :=
   simp [(I.lower_lt_upper _).not_le]
 #align box_integral.box.split_upper_eq_bot BoxIntegral.Box.splitUpper_eq_bot
 
+/- warning: box_integral.box.split_upper_eq_self -> BoxIntegral.Box.splitUpper_eq_self is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) I)) (LE.le.{0} Real Real.hasLe x (BoxIntegral.Box.lower.{u1} ι I i))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) I)) (LE.le.{0} Real Real.instLEReal x (BoxIntegral.Box.lower.{u1} ι I i))
+Case conversion may be inaccurate. Consider using '#align box_integral.box.split_upper_eq_self BoxIntegral.Box.splitUpper_eq_selfₓ'. -/
 @[simp]
 theorem splitUpper_eq_self : I.splitUpper i x = I ↔ x ≤ I.lower i := by
   simp [split_upper, update_eq_iff]
 #align box_integral.box.split_upper_eq_self BoxIntegral.Box.splitUpper_eq_self
 
+/- warning: box_integral.box.split_upper_def -> BoxIntegral.Box.splitUpper_def is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioo.{0} Real Real.preorder (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.hasLt (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x j) (BoxIntegral.Box.upper.{u1} ι I j)) (Iff.mpr (forall (x_1 : ι), (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) x_1 (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x x_1)) (And ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) x (BoxIntegral.Box.lower.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j))) (And.intro ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) i x) (forall (x : ι), (Ne.{succ u1} ι x i) -> ((fun (j : ι) (y : Real) => LT.lt.{0} Real Real.hasLt y (BoxIntegral.Box.upper.{u1} ι I j)) x (BoxIntegral.Box.lower.{u1} ι I x))) (And.right (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.preorder) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.preorder) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) (BoxIntegral.Box.mk.{u1} ι (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x) (BoxIntegral.Box.upper.{u1} ι I) h'))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : DecidableEq.{succ u1} ι] {i : ι} {x : Real} (h : Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioo.{0} Real Real.instPreorderReal (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i))) (h' : optParam.{0} (forall (j : ι), LT.lt.{0} Real Real.instLTReal (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x j) (BoxIntegral.Box.upper.{u1} ι I j)) (Iff.mpr (forall (x_1 : ι), LT.lt.{0} Real Real.instLTReal (Function.update.{succ u1, 1} ι (fun (a : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x x_1) (BoxIntegral.Box.upper.{u1} ι I x_1)) (And (LT.lt.{0} Real Real.instLTReal x (BoxIntegral.Box.upper.{u1} ι I i)) (forall (x : ι), (Ne.{succ u1} ι x i) -> (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x) (BoxIntegral.Box.upper.{u1} ι I x)))) (Function.forall_update_iff.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x (fun (j : ι) (y : Real) => LT.lt.{0} Real Real.instLTReal y (BoxIntegral.Box.upper.{u1} ι I j))) (And.intro (LT.lt.{0} Real Real.instLTReal x (BoxIntegral.Box.upper.{u1} ι I i)) (forall (x : ι), (Ne.{succ u1} ι x i) -> (LT.lt.{0} Real Real.instLTReal (BoxIntegral.Box.lower.{u1} ι I x) (BoxIntegral.Box.upper.{u1} ι I x))) (And.right (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.instPreorderReal) (BoxIntegral.Box.lower.{u1} ι I i) x) (LT.lt.{0} Real (Preorder.toLT.{0} Real Real.instPreorderReal) x (BoxIntegral.Box.upper.{u1} ι I i)) h) (fun (j : ι) (hne : Ne.{succ u1} ι j i) => BoxIntegral.Box.lower_lt_upper.{u1} ι I j)))), Eq.{succ u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (BoxIntegral.Box.splitUpper.{u1} ι I i x) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.mk.{u1} ι (Function.update.{succ u1, 1} ι (fun (ᾰ : ι) => Real) (fun (a : ι) (b : ι) => _inst_1 a b) (BoxIntegral.Box.lower.{u1} ι I) i x) (BoxIntegral.Box.upper.{u1} ι I) h'))
+Case conversion may be inaccurate. Consider using '#align box_integral.box.split_upper_def BoxIntegral.Box.splitUpper_defₓ'. -/
 theorem splitUpper_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.upper i))
     (h' : ∀ j, update I.lower i x j < I.upper j :=
       (forall_update_iff I.lower fun j y => y < I.upper j).2
@@ -146,6 +210,12 @@ theorem splitUpper_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.uppe
   congr
 #align box_integral.box.split_upper_def BoxIntegral.Box.splitUpper_def
 
+/- warning: box_integral.box.disjoint_split_lower_split_upper -> BoxIntegral.Box.disjoint_splitLower_splitUpper is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} (I : BoxIntegral.Box.{u1} ι) (i : ι) (x : Real), Disjoint.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.partialOrder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)) (WithBot.orderBot.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) (BoxIntegral.Box.splitLower.{u1} ι I i x) (BoxIntegral.Box.splitUpper.{u1} ι I i x)
+but is expected to have type
+  forall {ι : Type.{u1}} (I : BoxIntegral.Box.{u1} ι) (i : ι) (x : Real), Disjoint.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.partialOrder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)) (WithBot.orderBot.{u1} (BoxIntegral.Box.{u1} ι) (Preorder.toLE.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)))) (BoxIntegral.Box.splitLower.{u1} ι I i x) (BoxIntegral.Box.splitUpper.{u1} ι I i x)
+Case conversion may be inaccurate. Consider using '#align box_integral.box.disjoint_split_lower_split_upper BoxIntegral.Box.disjoint_splitLower_splitUpperₓ'. -/
 theorem disjoint_splitLower_splitUpper (I : Box ι) (i : ι) (x : ℝ) :
     Disjoint (I.splitLower i x) (I.splitUpper i x) :=
   by
@@ -155,6 +225,7 @@ theorem disjoint_splitLower_splitUpper (I : Box ι) (i : ι) (x : ℝ) :
   exact fun y (hle : y i ≤ x) hlt => not_lt_of_le hle hlt
 #align box_integral.box.disjoint_split_lower_split_upper BoxIntegral.Box.disjoint_splitLower_splitUpper
 
+#print BoxIntegral.Box.splitLower_ne_splitUpper /-
 theorem splitLower_ne_splitUpper (I : Box ι) (i : ι) (x : ℝ) :
     I.splitLower i x ≠ I.splitUpper i x :=
   by
@@ -164,6 +235,7 @@ theorem splitLower_ne_splitUpper (I : Box ι) (i : ι) (x : ℝ) :
   · refine' (disjoint_split_lower_split_upper I i x).Ne _
     rwa [Ne.def, split_lower_eq_bot, not_le]
 #align box_integral.box.split_lower_ne_split_upper BoxIntegral.Box.splitLower_ne_splitUpper
+-/
 
 end Box
 
@@ -171,6 +243,7 @@ namespace Prepartition
 
 variable {I J : Box ι} {i : ι} {x : ℝ}
 
+#print BoxIntegral.Prepartition.split /-
 /-- The partition of `I : box ι` into the boxes `I ∩ {y | y ≤ x i}` and `I ∩ {y | x i < y}`.
 One of these boxes can be empty, then this partition is just the single-box partition `⊤`. -/
 def split (I : Box ι) (i : ι) (x : ℝ) : Prepartition I :=
@@ -185,32 +258,57 @@ def split (I : Box ι) (i : ι) (x : ℝ) : Prepartition I :=
       rintro J rfl -
       exact I.disjoint_split_lower_split_upper i x)
 #align box_integral.prepartition.split BoxIntegral.Prepartition.split
+-/
 
+#print BoxIntegral.Prepartition.mem_split_iff /-
 @[simp]
 theorem mem_split_iff : J ∈ split I i x ↔ ↑J = I.splitLower i x ∨ ↑J = I.splitUpper i x := by
   simp [split]
 #align box_integral.prepartition.mem_split_iff BoxIntegral.Prepartition.mem_split_iff
+-/
 
+/- warning: box_integral.prepartition.mem_split_iff' -> BoxIntegral.Prepartition.mem_split_iff' is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) J (BoxIntegral.Prepartition.split.{u1} ι I i x)) (Or (Eq.{succ u1} (Set.{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} ι))) J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.hasInter.{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) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LE.le.{0} Real Real.hasLe (y i) x)))) (Eq.{succ u1} (Set.{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} ι))) J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.hasInter.{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) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LT.lt.{0} Real Real.hasLt x (y i))))))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, Iff (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) J (BoxIntegral.Prepartition.split.{u1} ι I i x)) (Or (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.instInterSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LE.le.{0} Real Real.instLEReal (y i) x)))) (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.instInterSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LT.lt.{0} Real Real.instLTReal x (y i))))))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.mem_split_iff' BoxIntegral.Prepartition.mem_split_iff'ₓ'. -/
 theorem mem_split_iff' :
     J ∈ split I i x ↔
       (J : Set (ι → ℝ)) = I ∩ { y | y i ≤ x } ∨ (J : Set (ι → ℝ)) = I ∩ { y | x < y i } :=
   by simp [mem_split_iff, ← box.with_bot_coe_inj]
 #align box_integral.prepartition.mem_split_iff' BoxIntegral.Prepartition.mem_split_iff'
 
+#print BoxIntegral.Prepartition.unionᵢ_split /-
 @[simp]
 theorem unionᵢ_split (I : Box ι) (i : ι) (x : ℝ) : (split I i x).unionᵢ = I := by
   simp [split, ← inter_union_distrib_left, ← set_of_or, le_or_lt]
 #align box_integral.prepartition.Union_split BoxIntegral.Prepartition.unionᵢ_split
+-/
 
-theorem isPartition_split (I : Box ι) (i : ι) (x : ℝ) : IsPartition (split I i x) :=
+#print BoxIntegral.Prepartition.isPartitionSplit /-
+theorem isPartitionSplit (I : Box ι) (i : ι) (x : ℝ) : IsPartition (split I i x) :=
   isPartition_iff_unionᵢ_eq.2 <| unionᵢ_split I i x
-#align box_integral.prepartition.is_partition_split BoxIntegral.Prepartition.isPartition_split
+#align box_integral.prepartition.is_partition_split BoxIntegral.Prepartition.isPartitionSplit
+-/
 
+/- warning: box_integral.prepartition.sum_split_boxes -> BoxIntegral.Prepartition.sum_split_boxes is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : AddCommMonoid.{u2} M] (I : BoxIntegral.Box.{u1} ι) (i : ι) (x : Real) (f : (BoxIntegral.Box.{u1} ι) -> M), Eq.{succ u2} M (Finset.sum.{u2, u1} M (BoxIntegral.Box.{u1} ι) _inst_1 (BoxIntegral.Prepartition.boxes.{u1} ι I (BoxIntegral.Prepartition.split.{u1} ι I i x)) (fun (J : BoxIntegral.Box.{u1} ι) => f J)) (HAdd.hAdd.{u2, u2, u2} M M M (instHAdd.{u2} M (AddZeroClass.toHasAdd.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_1)))) (Option.elim'.{u1, u2} (BoxIntegral.Box.{u1} ι) M (OfNat.ofNat.{u2} M 0 (OfNat.mk.{u2} M 0 (Zero.zero.{u2} M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_1)))))) f (BoxIntegral.Box.splitLower.{u1} ι I i x)) (Option.elim'.{u1, u2} (BoxIntegral.Box.{u1} ι) M (OfNat.ofNat.{u2} M 0 (OfNat.mk.{u2} M 0 (Zero.zero.{u2} M (AddZeroClass.toHasZero.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_1)))))) f (BoxIntegral.Box.splitUpper.{u1} ι I i x)))
+but is expected to have type
+  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_1 : AddCommMonoid.{u2} M] (I : BoxIntegral.Box.{u1} ι) (i : ι) (x : Real) (f : (BoxIntegral.Box.{u1} ι) -> M), Eq.{succ u2} M (Finset.sum.{u2, u1} M (BoxIntegral.Box.{u1} ι) _inst_1 (BoxIntegral.Prepartition.boxes.{u1} ι I (BoxIntegral.Prepartition.split.{u1} ι I i x)) (fun (J : BoxIntegral.Box.{u1} ι) => f J)) (HAdd.hAdd.{u2, u2, u2} M M M (instHAdd.{u2} M (AddZeroClass.toAdd.{u2} M (AddMonoid.toAddZeroClass.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_1)))) (Option.elim'.{u1, u2} (BoxIntegral.Box.{u1} ι) M (OfNat.ofNat.{u2} M 0 (Zero.toOfNat0.{u2} M (AddMonoid.toZero.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_1)))) f (BoxIntegral.Box.splitLower.{u1} ι I i x)) (Option.elim'.{u1, u2} (BoxIntegral.Box.{u1} ι) M (OfNat.ofNat.{u2} M 0 (Zero.toOfNat0.{u2} M (AddMonoid.toZero.{u2} M (AddCommMonoid.toAddMonoid.{u2} M _inst_1)))) f (BoxIntegral.Box.splitUpper.{u1} ι I i x)))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.sum_split_boxes BoxIntegral.Prepartition.sum_split_boxesₓ'. -/
 theorem sum_split_boxes {M : Type _} [AddCommMonoid M] (I : Box ι) (i : ι) (x : ℝ) (f : Box ι → M) :
     (∑ J in (split I i x).boxes, f J) = (I.splitLower i x).elim 0 f + (I.splitUpper i x).elim 0 f :=
   by rw [split, sum_of_with_bot, Finset.sum_pair (I.split_lower_ne_split_upper i x)]
 #align box_integral.prepartition.sum_split_boxes BoxIntegral.Prepartition.sum_split_boxes
 
+/- warning: box_integral.prepartition.split_of_not_mem_Ioo -> BoxIntegral.Prepartition.split_of_not_mem_Ioo is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, (Not (Membership.Mem.{0, 0} Real (Set.{0} Real) (Set.hasMem.{0} Real) x (Set.Ioo.{0} Real Real.preorder (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i)))) -> (Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.split.{u1} ι I i x) (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toHasTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.orderTop.{u1} ι I))))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real}, (Not (Membership.mem.{0, 0} Real (Set.{0} Real) (Set.instMembershipSet.{0} Real) x (Set.Ioo.{0} Real Real.instPreorderReal (BoxIntegral.Box.lower.{u1} ι I i) (BoxIntegral.Box.upper.{u1} ι I i)))) -> (Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.split.{u1} ι I i x) (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.instOrderTopPrepartitionInstLEPrepartition.{u1} ι I))))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.split_of_not_mem_Ioo BoxIntegral.Prepartition.split_of_not_mem_Iooₓ'. -/
 /-- If `x ∉ (I.lower i, I.upper i)`, then the hyperplane `{y | y i = x}` does not split `I`. -/
 theorem split_of_not_mem_Ioo (h : x ∉ Ioo (I.lower i) (I.upper i)) : split I i x = ⊤ :=
   by
@@ -223,6 +321,12 @@ theorem split_of_not_mem_Ioo (h : x ∉ Ioo (I.lower i) (I.upper i)) : split I i
   · rwa [eq_comm, box.split_lower_eq_self]
 #align box_integral.prepartition.split_of_not_mem_Ioo BoxIntegral.Prepartition.split_of_not_mem_Ioo
 
+/- warning: box_integral.prepartition.coe_eq_of_mem_split_of_mem_le -> BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_le is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real} {y : ι -> Real}, (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) J (BoxIntegral.Prepartition.split.{u1} ι I i x)) -> (Membership.Mem.{u1, u1} (ι -> Real) (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasMem.{u1} ι) y J) -> (LE.le.{0} Real Real.hasLe (y i) x) -> (Eq.{succ u1} (Set.{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} ι))) J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.hasInter.{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) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LE.le.{0} Real Real.hasLe (y i) x))))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real} {y : ι -> Real}, (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) J (BoxIntegral.Prepartition.split.{u1} ι I i x)) -> (Membership.mem.{u1, u1} (ι -> Real) (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instMembershipForAllRealBox.{u1} ι) y J) -> (LE.le.{0} Real Real.instLEReal (y i) x) -> (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.instInterSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LE.le.{0} Real Real.instLEReal (y i) x))))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.coe_eq_of_mem_split_of_mem_le BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_leₓ'. -/
 theorem coe_eq_of_mem_split_of_mem_le {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
     (h₃ : y i ≤ x) : (J : Set (ι → ℝ)) = I ∩ { y | y i ≤ x } :=
   (mem_split_iff'.1 h₁).resolve_right fun H =>
@@ -231,6 +335,12 @@ theorem coe_eq_of_mem_split_of_mem_le {y : ι → ℝ} (h₁ : J ∈ split I i x
     exact h₃.not_lt h₂.2
 #align box_integral.prepartition.coe_eq_of_mem_split_of_mem_le BoxIntegral.Prepartition.coe_eq_of_mem_split_of_mem_le
 
+/- warning: box_integral.prepartition.coe_eq_of_mem_split_of_lt_mem -> BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_mem is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real} {y : ι -> Real}, (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) J (BoxIntegral.Prepartition.split.{u1} ι I i x)) -> (Membership.Mem.{u1, u1} (ι -> Real) (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasMem.{u1} ι) y J) -> (LT.lt.{0} Real Real.hasLt x (y i)) -> (Eq.{succ u1} (Set.{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} ι))) J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.hasInter.{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) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LT.lt.{0} Real Real.hasLt x (y i)))))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {i : ι} {x : Real} {y : ι -> Real}, (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) J (BoxIntegral.Prepartition.split.{u1} ι I i x)) -> (Membership.mem.{u1, u1} (ι -> Real) (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instMembershipForAllRealBox.{u1} ι) y J) -> (LT.lt.{0} Real Real.instLTReal x (y i)) -> (Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι J) (Inter.inter.{u1} (Set.{u1} (ι -> Real)) (Set.instInterSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (setOf.{u1} (ι -> Real) (fun (y : ι -> Real) => LT.lt.{0} Real Real.instLTReal x (y i)))))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.coe_eq_of_mem_split_of_lt_mem BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_memₓ'. -/
 theorem coe_eq_of_mem_split_of_lt_mem {y : ι → ℝ} (h₁ : J ∈ split I i x) (h₂ : y ∈ J)
     (h₃ : x < y i) : (J : Set (ι → ℝ)) = I ∩ { y | x < y i } :=
   (mem_split_iff'.1 h₁).resolve_left fun H =>
@@ -239,6 +349,7 @@ theorem coe_eq_of_mem_split_of_lt_mem {y : ι → ℝ} (h₁ : J ∈ split I i x
     exact h₃.not_le h₂.2
 #align box_integral.prepartition.coe_eq_of_mem_split_of_lt_mem BoxIntegral.Prepartition.coe_eq_of_mem_split_of_lt_mem
 
+#print BoxIntegral.Prepartition.restrict_split /-
 @[simp]
 theorem restrict_split (h : I ≤ J) (i : ι) (x : ℝ) : (split J i x).restrict I = split I i x :=
   by
@@ -247,44 +358,68 @@ theorem restrict_split (h : I ≤ J) (i : ι) (x : ℝ) : (split J i x).restrict
   have : ∀ s, (I ∩ s : Set (ι → ℝ)) ⊆ J := fun s => (inter_subset_left _ _).trans h
   rintro J₁ ⟨J₂, H₂ | H₂, H₁⟩ <;> [left, right] <;> simp [H₁, H₂, inter_left_comm ↑I, this]
 #align box_integral.prepartition.restrict_split BoxIntegral.Prepartition.restrict_split
+-/
 
+#print BoxIntegral.Prepartition.inf_split /-
 theorem inf_split (π : Prepartition I) (i : ι) (x : ℝ) :
     π ⊓ split I i x = π.bunionᵢ fun J => split J i x :=
   bunionᵢ_congr_of_le rfl fun J hJ => restrict_split hJ i x
 #align box_integral.prepartition.inf_split BoxIntegral.Prepartition.inf_split
+-/
 
+#print BoxIntegral.Prepartition.splitMany /-
 /-- Split a box along many hyperplanes `{y | y i = x}`; each hyperplane is given by the pair
 `(i x)`. -/
 def splitMany (I : Box ι) (s : Finset (ι × ℝ)) : Prepartition I :=
   s.inf fun p => split I p.1 p.2
 #align box_integral.prepartition.split_many BoxIntegral.Prepartition.splitMany
+-/
 
+/- warning: box_integral.prepartition.split_many_empty -> BoxIntegral.Prepartition.splitMany_empty is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} (I : BoxIntegral.Box.{u1} ι), Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.splitMany.{u1} ι I (EmptyCollection.emptyCollection.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.hasEmptyc.{u1} (Prod.{u1, 0} ι Real)))) (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toHasTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.orderTop.{u1} ι I)))
+but is expected to have type
+  forall {ι : Type.{u1}} (I : BoxIntegral.Box.{u1} ι), Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.splitMany.{u1} ι I (EmptyCollection.emptyCollection.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.instEmptyCollectionFinset.{u1} (Prod.{u1, 0} ι Real)))) (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.instOrderTopPrepartitionInstLEPrepartition.{u1} ι I)))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.split_many_empty BoxIntegral.Prepartition.splitMany_emptyₓ'. -/
 @[simp]
 theorem splitMany_empty (I : Box ι) : splitMany I ∅ = ⊤ :=
   Finset.inf_empty
 #align box_integral.prepartition.split_many_empty BoxIntegral.Prepartition.splitMany_empty
 
+#print BoxIntegral.Prepartition.splitMany_insert /-
 @[simp]
 theorem splitMany_insert (I : Box ι) (s : Finset (ι × ℝ)) (p : ι × ℝ) :
     splitMany I (insert p s) = splitMany I s ⊓ split I p.1 p.2 := by
   rw [split_many, Finset.inf_insert, inf_comm, split_many]
 #align box_integral.prepartition.split_many_insert BoxIntegral.Prepartition.splitMany_insert
+-/
 
+/- warning: box_integral.prepartition.split_many_le_split -> BoxIntegral.Prepartition.splitMany_le_split is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} (I : BoxIntegral.Box.{u1} ι) {s : Finset.{u1} (Prod.{u1, 0} ι Real)} {p : Prod.{u1, 0} ι Real}, (Membership.Mem.{u1, u1} (Prod.{u1, 0} ι Real) (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.hasMem.{u1} (Prod.{u1, 0} ι Real)) p s) -> (LE.le.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.splitMany.{u1} ι I s) (BoxIntegral.Prepartition.split.{u1} ι I (Prod.fst.{u1, 0} ι Real p) (Prod.snd.{u1, 0} ι Real p)))
+but is expected to have type
+  forall {ι : Type.{u1}} (I : BoxIntegral.Box.{u1} ι) {s : Finset.{u1} (Prod.{u1, 0} ι Real)} {p : Prod.{u1, 0} ι Real}, (Membership.mem.{u1, u1} (Prod.{u1, 0} ι Real) (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.instMembershipFinset.{u1} (Prod.{u1, 0} ι Real)) p s) -> (LE.le.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.splitMany.{u1} ι I s) (BoxIntegral.Prepartition.split.{u1} ι I (Prod.fst.{u1, 0} ι Real p) (Prod.snd.{u1, 0} ι Real p)))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.split_many_le_split BoxIntegral.Prepartition.splitMany_le_splitₓ'. -/
 theorem splitMany_le_split (I : Box ι) {s : Finset (ι × ℝ)} {p : ι × ℝ} (hp : p ∈ s) :
     splitMany I s ≤ split I p.1 p.2 :=
   Finset.inf_le hp
 #align box_integral.prepartition.split_many_le_split BoxIntegral.Prepartition.splitMany_le_split
 
+#print BoxIntegral.Prepartition.isPartition_splitMany /-
 theorem isPartition_splitMany (I : Box ι) (s : Finset (ι × ℝ)) : IsPartition (splitMany I s) :=
   Finset.induction_on s (by simp only [split_many_empty, is_partition_top]) fun a s ha hs => by
     simpa only [split_many_insert, inf_split] using hs.bUnion fun J hJ => is_partition_split _ _ _
 #align box_integral.prepartition.is_partition_split_many BoxIntegral.Prepartition.isPartition_splitMany
+-/
 
+#print BoxIntegral.Prepartition.unionᵢ_splitMany /-
 @[simp]
 theorem unionᵢ_splitMany (I : Box ι) (s : Finset (ι × ℝ)) : (splitMany I s).unionᵢ = I :=
   (isPartition_splitMany I s).unionᵢ_eq
 #align box_integral.prepartition.Union_split_many BoxIntegral.Prepartition.unionᵢ_splitMany
+-/
 
+#print BoxIntegral.Prepartition.inf_splitMany /-
 theorem inf_splitMany {I : Box ι} (π : Prepartition I) (s : Finset (ι × ℝ)) :
     π ⊓ splitMany I s = π.bunionᵢ fun J => splitMany J s :=
   by
@@ -292,7 +427,14 @@ theorem inf_splitMany {I : Box ι} (π : Prepartition I) (s : Finset (ι × ℝ)
   · simp
   · simp_rw [split_many_insert, ← inf_assoc, ihp, inf_split, bUnion_assoc]
 #align box_integral.prepartition.inf_split_many BoxIntegral.Prepartition.inf_splitMany
+-/
 
+/- warning: box_integral.prepartition.not_disjoint_imp_le_of_subset_of_mem_split_many -> BoxIntegral.Prepartition.not_disjoint_imp_le_of_subset_of_mem_splitMany is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {Js : BoxIntegral.Box.{u1} ι} {s : Finset.{u1} (Prod.{u1, 0} ι Real)}, (forall (i : ι), HasSubset.Subset.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.hasSubset.{u1} (Prod.{u1, 0} ι Real)) (Insert.insert.{u1, u1} (Prod.{u1, 0} ι Real) (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.hasInsert.{u1} (Prod.{u1, 0} ι Real) (fun (a : Prod.{u1, 0} ι Real) (b : Prod.{u1, 0} ι Real) => Prod.Lex.decidableEq.{u1, 0} ι Real (fun (a : ι) (b : ι) => Classical.propDecidable (Eq.{succ u1} ι a b)) (fun (a : Real) (b : Real) => Real.decidableEq a b) a b)) (Prod.mk.{u1, 0} ι Real i (BoxIntegral.Box.lower.{u1} ι J i)) (Singleton.singleton.{u1, u1} (Prod.{u1, 0} ι Real) (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.hasSingleton.{u1} (Prod.{u1, 0} ι Real)) (Prod.mk.{u1, 0} ι Real i (BoxIntegral.Box.upper.{u1} ι J i)))) s) -> (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) Js (BoxIntegral.Prepartition.splitMany.{u1} ι I s)) -> (Not (Disjoint.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.partialOrder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)) (WithBot.orderBot.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) J) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) Js))) -> (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι) Js J)
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} {J : BoxIntegral.Box.{u1} ι} {Js : BoxIntegral.Box.{u1} ι} {s : Finset.{u1} (Prod.{u1, 0} ι Real)}, (forall (i : ι), HasSubset.Subset.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.instHasSubsetFinset.{u1} (Prod.{u1, 0} ι Real)) (Insert.insert.{u1, u1} (Prod.{u1, 0} ι Real) (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.instInsertFinset.{u1} (Prod.{u1, 0} ι Real) (fun (a : Prod.{u1, 0} ι Real) (b : Prod.{u1, 0} ι Real) => instDecidableEqProd.{u1, 0} ι Real (fun (a : ι) (b : ι) => Classical.propDecidable (Eq.{succ u1} ι a b)) (fun (a : Real) (b : Real) => Real.decidableEq a b) a b)) (Prod.mk.{u1, 0} ι Real i (BoxIntegral.Box.lower.{u1} ι J i)) (Singleton.singleton.{u1, u1} (Prod.{u1, 0} ι Real) (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.instSingletonFinset.{u1} (Prod.{u1, 0} ι Real)) (Prod.mk.{u1, 0} ι Real i (BoxIntegral.Box.upper.{u1} ι J i)))) s) -> (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) Js (BoxIntegral.Prepartition.splitMany.{u1} ι I s)) -> (Not (Disjoint.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.partialOrder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)) (WithBot.orderBot.{u1} (BoxIntegral.Box.{u1} ι) (Preorder.toLE.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)))) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) J) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) Js))) -> (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instLEBox.{u1} ι) Js J)
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.not_disjoint_imp_le_of_subset_of_mem_split_many BoxIntegral.Prepartition.not_disjoint_imp_le_of_subset_of_mem_splitManyₓ'. -/
 /-- Let `s : finset (ι × ℝ)` be a set of hyperplanes `{x : ι → ℝ | x i = r}` in `ι → ℝ` encoded as
 pairs `(i, r)`. Suppose that this set contains all faces of a box `J`. The hyperplanes of `s` split
 a box `I` into subboxes. Let `Js` be one of them. If `J` and `Js` have nonempty intersection, then
@@ -318,6 +460,12 @@ section Fintype
 
 variable [Finite ι]
 
+/- warning: box_integral.prepartition.eventually_not_disjoint_imp_le_of_mem_split_many -> BoxIntegral.Prepartition.eventually_not_disjoint_imp_le_of_mem_splitMany is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] (s : Finset.{u1} (BoxIntegral.Box.{u1} ι)), Filter.Eventually.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (fun (t : Finset.{u1} (Prod.{u1, 0} ι Real)) => forall (I : BoxIntegral.Box.{u1} ι) (J : BoxIntegral.Box.{u1} ι), (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (Finset.{u1} (BoxIntegral.Box.{u1} ι)) (Finset.hasMem.{u1} (BoxIntegral.Box.{u1} ι)) J s) -> (forall (J' : BoxIntegral.Box.{u1} ι), (Membership.Mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasMem.{u1} ι I) J' (BoxIntegral.Prepartition.splitMany.{u1} ι I t)) -> (Not (Disjoint.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.partialOrder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.partialOrder.{u1} ι)) (WithBot.orderBot.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) J) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (HasLiftT.mk.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (CoeTCₓ.coe.{succ u1, succ u1} (BoxIntegral.Box.{u1} ι) (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.hasCoeT.{u1} (BoxIntegral.Box.{u1} ι)))) J'))) -> (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.hasLe.{u1} ι) J' J))) (Filter.atTop.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (PartialOrder.toPreorder.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.partialOrder.{u1} (Prod.{u1, 0} ι Real))))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] (s : Finset.{u1} (BoxIntegral.Box.{u1} ι)), Filter.Eventually.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (fun (t : Finset.{u1} (Prod.{u1, 0} ι Real)) => forall (I : BoxIntegral.Box.{u1} ι) (J : BoxIntegral.Box.{u1} ι), (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (Finset.{u1} (BoxIntegral.Box.{u1} ι)) (Finset.instMembershipFinset.{u1} (BoxIntegral.Box.{u1} ι)) J s) -> (forall (J' : BoxIntegral.Box.{u1} ι), (Membership.mem.{u1, u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instMembershipBoxPrepartition.{u1} ι I) J' (BoxIntegral.Prepartition.splitMany.{u1} ι I t)) -> (Not (Disjoint.{u1} (WithBot.{u1} (BoxIntegral.Box.{u1} ι)) (WithBot.partialOrder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)) (WithBot.orderBot.{u1} (BoxIntegral.Box.{u1} ι) (Preorder.toLE.{u1} (BoxIntegral.Box.{u1} ι) (PartialOrder.toPreorder.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instPartialOrderBox.{u1} ι)))) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) J) (WithBot.some.{u1} (BoxIntegral.Box.{u1} ι) J'))) -> (LE.le.{u1} (BoxIntegral.Box.{u1} ι) (BoxIntegral.Box.instLEBox.{u1} ι) J' J))) (Filter.atTop.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (PartialOrder.toPreorder.{u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (Finset.partialOrder.{u1} (Prod.{u1, 0} ι Real))))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.eventually_not_disjoint_imp_le_of_mem_split_many BoxIntegral.Prepartition.eventually_not_disjoint_imp_le_of_mem_splitManyₓ'. -/
 /-- Let `s` be a finite set of boxes in `ℝⁿ = ι → ℝ`. Then there exists a finite set `t₀` of
 hyperplanes (namely, the set of all hyperfaces of boxes in `s`) such that for any `t ⊇ t₀`
 and any box `I` in `ℝⁿ` the following holds. The hyperplanes from `t` split `I` into subboxes.
@@ -336,6 +484,7 @@ theorem eventually_not_disjoint_imp_le_of_mem_splitMany (s : Finset (Box ι)) :
     ht (Finset.mem_bunionᵢ.2 ⟨J, hJ, Finset.mem_bunionᵢ.2 ⟨i, Finset.mem_univ _, hp⟩⟩)
 #align box_integral.prepartition.eventually_not_disjoint_imp_le_of_mem_split_many BoxIntegral.Prepartition.eventually_not_disjoint_imp_le_of_mem_splitMany
 
+#print BoxIntegral.Prepartition.eventually_splitMany_inf_eq_filter /-
 theorem eventually_splitMany_inf_eq_filter (π : Prepartition I) :
     ∀ᶠ t : Finset (ι × ℝ) in atTop,
       π ⊓ splitMany I t = (splitMany I t).filterₓ fun J => ↑J ⊆ π.unionᵢ :=
@@ -352,14 +501,23 @@ theorem eventually_splitMany_inf_eq_filter (π : Prepartition I) :
     refine' ⟨J', hJ', ht I _ hJ' _ hJ.1 <| box.not_disjoint_coe_iff_nonempty_inter.2 _⟩
     exact ⟨J.upper, hmem, J.upper_mem⟩
 #align box_integral.prepartition.eventually_split_many_inf_eq_filter BoxIntegral.Prepartition.eventually_splitMany_inf_eq_filter
+-/
 
+#print BoxIntegral.Prepartition.exists_splitMany_inf_eq_filter_of_finite /-
 theorem exists_splitMany_inf_eq_filter_of_finite (s : Set (Prepartition I)) (hs : s.Finite) :
     ∃ t : Finset (ι × ℝ),
       ∀ π ∈ s, π ⊓ splitMany I t = (splitMany I t).filterₓ fun J => ↑J ⊆ π.unionᵢ :=
   haveI := fun π (hπ : π ∈ s) => eventually_split_many_inf_eq_filter π
   (hs.eventually_all.2 this).exists
 #align box_integral.prepartition.exists_split_many_inf_eq_filter_of_finite BoxIntegral.Prepartition.exists_splitMany_inf_eq_filter_of_finite
+-/
 
+/- warning: box_integral.prepartition.is_partition.exists_split_many_le -> BoxIntegral.Prepartition.IsPartition.exists_splitMany_le is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {I : BoxIntegral.Box.{u1} ι} {π : BoxIntegral.Prepartition.{u1} ι I}, (BoxIntegral.Prepartition.IsPartition.{u1} ι I π) -> (Exists.{succ u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (fun (s : Finset.{u1} (Prod.{u1, 0} ι Real)) => LE.le.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.splitMany.{u1} ι I s) π))
+but is expected to have type
+  forall {ι : Type.{u1}} [_inst_1 : Finite.{succ u1} ι] {I : BoxIntegral.Box.{u1} ι} {π : BoxIntegral.Prepartition.{u1} ι I}, (BoxIntegral.Prepartition.IsPartition.{u1} ι I π) -> (Exists.{succ u1} (Finset.{u1} (Prod.{u1, 0} ι Real)) (fun (s : Finset.{u1} (Prod.{u1, 0} ι Real)) => LE.le.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.splitMany.{u1} ι I s) π))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.is_partition.exists_split_many_le BoxIntegral.Prepartition.IsPartition.exists_splitMany_leₓ'. -/
 /-- If `π` is a partition of `I`, then there exists a finite set `s` of hyperplanes such that
 `split_many I s ≤ π`. -/
 theorem IsPartition.exists_splitMany_le {I : Box ι} {π : Prepartition I} (h : IsPartition π) :
@@ -370,6 +528,12 @@ theorem IsPartition.exists_splitMany_le {I : Box ι} {π : Prepartition I} (h :
     exact fun J hJ => le_of_mem _ hJ
 #align box_integral.prepartition.is_partition.exists_split_many_le BoxIntegral.Prepartition.IsPartition.exists_splitMany_le
 
+/- warning: box_integral.prepartition.exists_Union_eq_diff -> BoxIntegral.Prepartition.exists_unionᵢ_eq_diff is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Exists.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (fun (π' : BoxIntegral.Prepartition.{u1} ι I) => Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.unionᵢ.{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.Prepartition.unionᵢ.{u1} ι I π)))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Exists.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (fun (π' : BoxIntegral.Prepartition.{u1} ι I) => Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.unionᵢ.{u1} ι I π') (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (Set.instSDiffSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (BoxIntegral.Prepartition.unionᵢ.{u1} ι I π)))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.exists_Union_eq_diff BoxIntegral.Prepartition.exists_unionᵢ_eq_diffₓ'. -/
 /-- For every prepartition `π` of `I` there exists a prepartition that covers exactly
 `I \ π.Union`. -/
 theorem exists_unionᵢ_eq_diff (π : Prepartition I) :
@@ -380,17 +544,26 @@ theorem exists_unionᵢ_eq_diff (π : Prepartition I) :
   simp [← hs]
 #align box_integral.prepartition.exists_Union_eq_diff BoxIntegral.Prepartition.exists_unionᵢ_eq_diff
 
+#print BoxIntegral.Prepartition.compl /-
 /-- If `π` is a prepartition of `I`, then `π.compl` is a prepartition of `I`
 such that `π.compl.Union = I \ π.Union`. -/
 def compl (π : Prepartition I) : Prepartition I :=
   π.exists_unionᵢ_eq_diff.some
 #align box_integral.prepartition.compl BoxIntegral.Prepartition.compl
+-/
 
+/- warning: box_integral.prepartition.Union_compl -> BoxIntegral.Prepartition.unionᵢ_compl is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.unionᵢ.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 π)) (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.Prepartition.unionᵢ.{u1} ι I π))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] (π : BoxIntegral.Prepartition.{u1} ι I), Eq.{succ u1} (Set.{u1} (ι -> Real)) (BoxIntegral.Prepartition.unionᵢ.{u1} ι I (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 π)) (SDiff.sdiff.{u1} (Set.{u1} (ι -> Real)) (Set.instSDiffSet.{u1} (ι -> Real)) (BoxIntegral.Box.toSet.{u1} ι I) (BoxIntegral.Prepartition.unionᵢ.{u1} ι I π))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.Union_compl BoxIntegral.Prepartition.unionᵢ_complₓ'. -/
 @[simp]
 theorem unionᵢ_compl (π : Prepartition I) : π.compl.unionᵢ = I \ π.unionᵢ :=
   π.exists_unionᵢ_eq_diff.choose_spec
 #align box_integral.prepartition.Union_compl BoxIntegral.Prepartition.unionᵢ_compl
 
+#print BoxIntegral.Prepartition.compl_congr /-
 /-- Since the definition of `box_integral.prepartition.compl` uses `Exists.some`,
 the result depends only on `π.Union`. -/
 theorem compl_congr {π₁ π₂ : Prepartition I} (h : π₁.unionᵢ = π₂.unionᵢ) : π₁.compl = π₂.compl :=
@@ -399,11 +572,24 @@ theorem compl_congr {π₁ π₂ : Prepartition I} (h : π₁.unionᵢ = π₂.u
   congr 1
   rw [h]
 #align box_integral.prepartition.compl_congr BoxIntegral.Prepartition.compl_congr
+-/
 
+/- warning: box_integral.prepartition.is_partition.compl_eq_bot -> BoxIntegral.Prepartition.IsPartition.compl_eq_bot is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] {π : BoxIntegral.Prepartition.{u1} ι I}, (BoxIntegral.Prepartition.IsPartition.{u1} ι I π) -> (Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 π) (Bot.bot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderBot.toHasBot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.orderBot.{u1} ι I))))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι] {π : BoxIntegral.Prepartition.{u1} ι I}, (BoxIntegral.Prepartition.IsPartition.{u1} ι I π) -> (Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 π) (Bot.bot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderBot.toBot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.instOrderBotPrepartitionInstLEPrepartition.{u1} ι I))))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.is_partition.compl_eq_bot BoxIntegral.Prepartition.IsPartition.compl_eq_botₓ'. -/
 theorem IsPartition.compl_eq_bot {π : Prepartition I} (h : IsPartition π) : π.compl = ⊥ := by
   rw [← Union_eq_empty, Union_compl, h.Union_eq, diff_self]
 #align box_integral.prepartition.is_partition.compl_eq_bot BoxIntegral.Prepartition.IsPartition.compl_eq_bot
 
+/- warning: box_integral.prepartition.compl_top -> BoxIntegral.Prepartition.compl_top is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι], Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toHasTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.orderTop.{u1} ι I)))) (Bot.bot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderBot.toHasBot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.hasLe.{u1} ι I) (BoxIntegral.Prepartition.orderBot.{u1} ι I)))
+but is expected to have type
+  forall {ι : Type.{u1}} {I : BoxIntegral.Box.{u1} ι} [_inst_1 : Finite.{succ u1} ι], Eq.{succ u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.compl.{u1} ι I _inst_1 (Top.top.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderTop.toTop.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.instOrderTopPrepartitionInstLEPrepartition.{u1} ι I)))) (Bot.bot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (OrderBot.toBot.{u1} (BoxIntegral.Prepartition.{u1} ι I) (BoxIntegral.Prepartition.instLEPrepartition.{u1} ι I) (BoxIntegral.Prepartition.instOrderBotPrepartitionInstLEPrepartition.{u1} ι I)))
+Case conversion may be inaccurate. Consider using '#align box_integral.prepartition.compl_top BoxIntegral.Prepartition.compl_topₓ'. -/
 @[simp]
 theorem compl_top : (⊤ : Prepartition I).compl = ⊥ :=
   (isPartitionTop I).compl_eq_bot

6ca1a09b

bump to nightly-2023-04-26-06

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

dfb5811a

Diff

@@ -198,13 +198,13 @@ theorem mem_split_iff' :
 #align box_integral.prepartition.mem_split_iff' BoxIntegral.Prepartition.mem_split_iff'
 
 @[simp]
-theorem union_split (I : Box ι) (i : ι) (x : ℝ) : (split I i x).unionᵢ = I := by
+theorem unionᵢ_split (I : Box ι) (i : ι) (x : ℝ) : (split I i x).unionᵢ = I := by
   simp [split, ← inter_union_distrib_left, ← set_of_or, le_or_lt]
-#align box_integral.prepartition.Union_split BoxIntegral.Prepartition.union_split
+#align box_integral.prepartition.Union_split BoxIntegral.Prepartition.unionᵢ_split
 
-theorem isPartitionSplit (I : Box ι) (i : ι) (x : ℝ) : IsPartition (split I i x) :=
-  isPartition_iff_union_eq.2 <| union_split I i x
-#align box_integral.prepartition.is_partition_split BoxIntegral.Prepartition.isPartitionSplit
+theorem isPartition_split (I : Box ι) (i : ι) (x : ℝ) : IsPartition (split I i x) :=
+  isPartition_iff_unionᵢ_eq.2 <| unionᵢ_split I i x
+#align box_integral.prepartition.is_partition_split BoxIntegral.Prepartition.isPartition_split
 
 theorem sum_split_boxes {M : Type _} [AddCommMonoid M] (I : Box ι) (i : ι) (x : ℝ) (f : Box ι → M) :
     (∑ J in (split I i x).boxes, f J) = (I.splitLower i x).elim 0 f + (I.splitUpper i x).elim 0 f :=
@@ -250,7 +250,7 @@ theorem restrict_split (h : I ≤ J) (i : ι) (x : ℝ) : (split J i x).restrict
 
 theorem inf_split (π : Prepartition I) (i : ι) (x : ℝ) :
     π ⊓ split I i x = π.bunionᵢ fun J => split J i x :=
-  bUnion_congr_of_le rfl fun J hJ => restrict_split hJ i x
+  bunionᵢ_congr_of_le rfl fun J hJ => restrict_split hJ i x
 #align box_integral.prepartition.inf_split BoxIntegral.Prepartition.inf_split
 
 /-- Split a box along many hyperplanes `{y | y i = x}`; each hyperplane is given by the pair
@@ -275,15 +275,15 @@ theorem splitMany_le_split (I : Box ι) {s : Finset (ι × ℝ)} {p : ι × ℝ}
   Finset.inf_le hp
 #align box_integral.prepartition.split_many_le_split BoxIntegral.Prepartition.splitMany_le_split
 
-theorem isPartitionSplitMany (I : Box ι) (s : Finset (ι × ℝ)) : IsPartition (splitMany I s) :=
+theorem isPartition_splitMany (I : Box ι) (s : Finset (ι × ℝ)) : IsPartition (splitMany I s) :=
   Finset.induction_on s (by simp only [split_many_empty, is_partition_top]) fun a s ha hs => by
     simpa only [split_many_insert, inf_split] using hs.bUnion fun J hJ => is_partition_split _ _ _
-#align box_integral.prepartition.is_partition_split_many BoxIntegral.Prepartition.isPartitionSplitMany
+#align box_integral.prepartition.is_partition_split_many BoxIntegral.Prepartition.isPartition_splitMany
 
 @[simp]
-theorem union_splitMany (I : Box ι) (s : Finset (ι × ℝ)) : (splitMany I s).unionᵢ = I :=
-  (isPartitionSplitMany I s).unionᵢ_eq
-#align box_integral.prepartition.Union_split_many BoxIntegral.Prepartition.union_splitMany
+theorem unionᵢ_splitMany (I : Box ι) (s : Finset (ι × ℝ)) : (splitMany I s).unionᵢ = I :=
+  (isPartition_splitMany I s).unionᵢ_eq
+#align box_integral.prepartition.Union_split_many BoxIntegral.Prepartition.unionᵢ_splitMany
 
 theorem inf_splitMany {I : Box ι} (π : Prepartition I) (s : Finset (ι × ℝ)) :
     π ⊓ splitMany I s = π.bunionᵢ fun J => splitMany J s :=
@@ -372,24 +372,24 @@ theorem IsPartition.exists_splitMany_le {I : Box ι} {π : Prepartition I} (h :
 
 /-- For every prepartition `π` of `I` there exists a prepartition that covers exactly
 `I \ π.Union`. -/
-theorem exists_union_eq_diff (π : Prepartition I) :
+theorem exists_unionᵢ_eq_diff (π : Prepartition I) :
     ∃ π' : Prepartition I, π'.unionᵢ = I \ π.unionᵢ :=
   by
   rcases π.eventually_split_many_inf_eq_filter.exists with ⟨s, hs⟩
   use (split_many I s).filterₓ fun J => ¬(J : Set (ι → ℝ)) ⊆ π.Union
   simp [← hs]
-#align box_integral.prepartition.exists_Union_eq_diff BoxIntegral.Prepartition.exists_union_eq_diff
+#align box_integral.prepartition.exists_Union_eq_diff BoxIntegral.Prepartition.exists_unionᵢ_eq_diff
 
 /-- If `π` is a prepartition of `I`, then `π.compl` is a prepartition of `I`
 such that `π.compl.Union = I \ π.Union`. -/
 def compl (π : Prepartition I) : Prepartition I :=
-  π.exists_union_eq_diff.some
+  π.exists_unionᵢ_eq_diff.some
 #align box_integral.prepartition.compl BoxIntegral.Prepartition.compl
 
 @[simp]
-theorem union_compl (π : Prepartition I) : π.compl.unionᵢ = I \ π.unionᵢ :=
-  π.exists_union_eq_diff.choose_spec
-#align box_integral.prepartition.Union_compl BoxIntegral.Prepartition.union_compl
+theorem unionᵢ_compl (π : Prepartition I) : π.compl.unionᵢ = I \ π.unionᵢ :=
+  π.exists_unionᵢ_eq_diff.choose_spec
+#align box_integral.prepartition.Union_compl BoxIntegral.Prepartition.unionᵢ_compl
 
 /-- Since the definition of `box_integral.prepartition.compl` uses `Exists.some`,
 the result depends only on `π.Union`. -/

6ca1a09b

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

6ca1a09b

chore: avoid Ne.def (adaptation for nightly-2024-03-27) (#11801)

1b40c7bc

Diff

@@ -150,7 +150,7 @@ theorem splitLower_ne_splitUpper (I : Box ι) (i : ι) (x : ℝ) :
   · rw [splitUpper_eq_self.2 h, splitLower_eq_bot.2 h]
     exact WithBot.bot_ne_coe
   · refine' (disjoint_splitLower_splitUpper I i x).ne _
-    rwa [Ne.def, splitLower_eq_bot, not_le]
+    rwa [Ne, splitLower_eq_bot, not_le]
 #align box_integral.box.split_lower_ne_split_upper BoxIntegral.Box.splitLower_ne_splitUpper
 
 end Box

6ca1a09b

chore: scope open Classical (#11199)

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.

c747be0a

Diff

@@ -40,7 +40,8 @@ rectangular box, partition, hyperplane
 
 noncomputable section
 
-open Classical BigOperators Filter
+open scoped Classical
+open BigOperators Filter
 
 open Function Set Filter

6ca1a09b

chore: Remove unnecessary "rw"s (#10704)

Remove unnecessary "rw"s.

db5a9376

Diff

@@ -66,7 +66,7 @@ theorem coe_splitLower : (splitLower I i x : Set (ι → ℝ)) = ↑I ∩ { y |
   ext y
   simp only [mem_univ_pi, mem_Ioc, mem_inter_iff, mem_coe, mem_setOf_eq, forall_and, ← Pi.le_def,
     le_update_iff, le_min_iff, and_assoc, and_forall_ne (p := fun j => y j ≤ upper I j) i, mem_def]
-  rw [and_comm (a := y i ≤ x), Pi.le_def]
+  rw [and_comm (a := y i ≤ x)]
 #align box_integral.box.coe_split_lower BoxIntegral.Box.coe_splitLower
 
 theorem splitLower_le : I.splitLower i x ≤ I :=

6ca1a09b

chore(Analysis/BoxIntegral): Fintype -> Finite (#10292)

34bbb84e

Diff

@@ -297,7 +297,7 @@ theorem not_disjoint_imp_le_of_subset_of_mem_splitMany {I J Js : Box ι} {s : Fi
     exact (Hle hy).2
 #align box_integral.prepartition.not_disjoint_imp_le_of_subset_of_mem_split_many BoxIntegral.Prepartition.not_disjoint_imp_le_of_subset_of_mem_splitMany
 
-section Fintype
+section Finite
 
 variable [Finite ι]
 
@@ -386,7 +386,7 @@ theorem compl_top : (⊤ : Prepartition I).compl = ⊥ :=
   (isPartitionTop I).compl_eq_bot
 #align box_integral.prepartition.compl_top BoxIntegral.Prepartition.compl_top
 
-end Fintype
+end Finite
 
 end Prepartition

6ca1a09b

chore: bump to v4.3.0-rc2 (#8366)

PR contents

This is the supremum of

#8284
#8056
#8023
#8332
#8226 (already approved)
#7834 (already approved)

along with some minor fixes from failures on nightly-testing as Mathlib master is merged into it.

Note that some PRs for changes that are already compatible with the current toolchain and will be necessary have already been split out: #8380.

I am hopeful that in future we will be able to progressively merge adaptation PRs into a bump/v4.X.0 branch, so we never end up with a "big merge" like this. However one of these adaptation PRs (#8056) predates my new scheme for combined CI, and it wasn't possible to keep that PR viable in the meantime.

Lean PRs involved in this bump

In particular this includes adjustments for the Lean PRs

leanprover/lean4#2778

We can get rid of all the

local macro_rules | `($x ^ $y) => `(HPow.hPow $x $y) -- Porting note: See issue [lean4#2220](https://github.com/leanprover/lean4/pull/2220)

macros across Mathlib (and in any projects that want to write natural number powers of reals).

leanprover/lean4#2722

Changes the default behaviour of simp to (config := {decide := false}). This makes simp (and consequentially norm_num) less powerful, but also more consistent, and less likely to blow up in long failures. This requires a variety of changes: changing some previously by simp or norm_num to decide or rfl, or adding (config := {decide := true}).

leanprover/lean4#2783

This changed the behaviour of simp so that simp [f] will only unfold "fully applied" occurrences of f. The old behaviour can be recovered with simp (config := { unfoldPartialApp := true }). We may in future add a syntax for this, e.g. simp [!f]; please provide feedback! In the meantime, we have made the following changes:

switching to using explicit lemmas that have the intended level of application
(config := { unfoldPartialApp := true }) in some places, to recover the old behaviour
Using @[eqns] to manually adjust the equation lemmas for a particular definition, recovering the old behaviour just for that definition. See #8371, where we do this for Function.comp and Function.flip.

This change in Lean may require further changes down the line (e.g. adding the !f syntax, and/or upstreaming the special treatment for Function.comp and Function.flip, and/or removing this special treatment). Please keep an open and skeptical mind about these changes!

Co-authored-by: leanprover-community-mathlib4-bot <leanprover-community-mathlib4-bot@users.noreply.github.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Mauricio Collares <mauricio@collares.org>

40b64f79

Diff

@@ -89,7 +89,8 @@ theorem splitLower_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.uppe
       (forall_update_iff I.upper fun j y => I.lower j < y).2
         ⟨h.1, fun j _ => I.lower_lt_upper _⟩) :
     I.splitLower i x = (⟨I.lower, update I.upper i x, h'⟩ : Box ι) := by
-  simp only [splitLower, mk'_eq_coe, min_eq_left h.2.le, update]
+  simp (config := { unfoldPartialApp := true }) only [splitLower, mk'_eq_coe, min_eq_left h.2.le,
+    update, and_self]
 #align box_integral.box.split_lower_def BoxIntegral.Box.splitLower_def
 
 /-- Given a box `I` and `x ∈ (I.lower i, I.upper i)`, the hyperplane `{y : ι → ℝ | y i = x}` splits
@@ -130,7 +131,8 @@ theorem splitUpper_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.uppe
       (forall_update_iff I.lower fun j y => y < I.upper j).2
         ⟨h.2, fun j _ => I.lower_lt_upper _⟩) :
     I.splitUpper i x = (⟨update I.lower i x, I.upper, h'⟩ : Box ι) := by
-  simp only [splitUpper, mk'_eq_coe, max_eq_left h.1.le, update]
+  simp (config := { unfoldPartialApp := true }) only [splitUpper, mk'_eq_coe, max_eq_left h.1.le,
+    update, and_self]
 #align box_integral.box.split_upper_def BoxIntegral.Box.splitUpper_def
 
 theorem disjoint_splitLower_splitUpper (I : Box ι) (i : ι) (x : ℝ) :

6ca1a09b

chore: banish Type _ and Sort _ (#6499)

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

This has nice performance benefits.

32de3f67

Diff

@@ -46,7 +46,7 @@ open Function Set Filter
 
 namespace BoxIntegral
 
-variable {ι M : Type _} {n : ℕ}
+variable {ι M : Type*} {n : ℕ}
 
 namespace Box
 
@@ -191,7 +191,7 @@ theorem isPartitionSplit (I : Box ι) (i : ι) (x : ℝ) : IsPartition (split I
 #align box_integral.prepartition.is_partition_split BoxIntegral.Prepartition.isPartitionSplit
 
 -- Porting note: In the type, changed `Option.elim` to `Option.elim'`
-theorem sum_split_boxes {M : Type _} [AddCommMonoid M] (I : Box ι) (i : ι) (x : ℝ) (f : Box ι → M) :
+theorem sum_split_boxes {M : Type*} [AddCommMonoid M] (I : Box ι) (i : ι) (x : ℝ) (f : Box ι → M) :
     (∑ J in (split I i x).boxes, f J) =
       (I.splitLower i x).elim' 0 f + (I.splitUpper i x).elim' 0 f := by
   rw [split, sum_ofWithBot, Finset.sum_pair (I.splitLower_ne_splitUpper i x)]

6ca1a09b

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

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

89aa3a3b

Diff

@@ -2,14 +2,11 @@
 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.split
-! leanprover-community/mathlib commit 6ca1a09bc9aa75824bf97388c9e3b441fc4ccf3f
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Analysis.BoxIntegral.Partition.Basic
 
+#align_import analysis.box_integral.partition.split from "leanprover-community/mathlib"@"6ca1a09bc9aa75824bf97388c9e3b441fc4ccf3f"
+
 /-!
 # Split a box along one or more hyperplanes

6ca1a09b

feat(Data.Set.Basic/Data.Finset.Basic): rename insert_subset (#5450)

Currently, (for both Set and Finset) insert_subset is an iff lemma stating that insert a s ⊆ t if and only if a ∈ t and s ⊆ t. For both types, this PR renames this lemma to insert_subset_iff, and adds an insert_subset lemma that gives the implication just in the reverse direction : namely theorem insert_subset (ha : a ∈ t) (hs : s ⊆ t) : insert a s ⊆ t .

This both aligns the naming with union_subset and union_subset_iff, and removes the need for the awkward insert_subset.mpr ⟨_,_⟩ idiom. It touches a lot of files (too many to list), but in a trivial way.

d8b62864

Diff

@@ -285,7 +285,7 @@ a box `I` into subboxes. Let `Js` be one of them. If `J` and `Js` have nonempty
 theorem not_disjoint_imp_le_of_subset_of_mem_splitMany {I J Js : Box ι} {s : Finset (ι × ℝ)}
     (H : ∀ i, {(i, J.lower i), (i, J.upper i)} ⊆ s) (HJs : Js ∈ splitMany I s)
     (Hn : ¬Disjoint (J : WithBot (Box ι)) Js) : Js ≤ J := by
-  simp only [Finset.insert_subset, Finset.singleton_subset_iff] at H
+  simp only [Finset.insert_subset_iff, Finset.singleton_subset_iff] at H
   rcases Box.not_disjoint_coe_iff_nonempty_inter.mp Hn with ⟨x, hx, hxs⟩
   refine' fun y hy i => ⟨_, _⟩
   · rcases splitMany_le_split I (H i).1 HJs with ⟨Jl, Hmem : Jl ∈ split I i (J.lower i), Hle⟩

6ca1a09b

chore: update std 05-22 (#4248)

The main breaking change is that tac <;> [t1, t2] is now written tac <;> [t1; t2], to avoid clashing with tactics like cases and use that take comma-separated lists.

ac36b28e

Diff

@@ -206,7 +206,7 @@ theorem split_of_not_mem_Ioo (h : x ∉ Ioo (I.lower i) (I.upper i)) : split I i
   rcases mem_top.1 hJ with rfl; clear hJ
   rw [mem_boxes, mem_split_iff]
   rw [mem_Ioo, not_and_or, not_lt, not_lt] at h
-  cases h <;> [right, left]
+  cases h <;> [right; left]
   · rwa [eq_comm, Box.splitUpper_eq_self]
   · rwa [eq_comm, Box.splitLower_eq_self]
 #align box_integral.prepartition.split_of_not_mem_Ioo BoxIntegral.Prepartition.split_of_not_mem_Ioo
@@ -230,7 +230,7 @@ theorem restrict_split (h : I ≤ J) (i : ι) (x : ℝ) : (split J i x).restrict
   refine' ((isPartitionSplit J i x).restrict h).eq_of_boxes_subset _
   simp only [Finset.subset_iff, mem_boxes, mem_restrict', exists_prop, mem_split_iff']
   have : ∀ s, (I ∩ s : Set (ι → ℝ)) ⊆ J := fun s => (inter_subset_left _ _).trans h
-  rintro J₁ ⟨J₂, H₂ | H₂, H₁⟩ <;> [left, right] <;>
+  rintro J₁ ⟨J₂, H₂ | H₂, H₁⟩ <;> [left; right] <;>
     simp [H₁, H₂, inter_left_comm (I : Set (ι → ℝ)), this]
 #align box_integral.prepartition.restrict_split BoxIntegral.Prepartition.restrict_split

6ca1a09b

chore: Rename to sSup/iSup (#3938)

As discussed on Zulip

Renames

supₛ → sSup
infₛ → sInf
supᵢ → iSup
infᵢ → iInf
bsupₛ → bsSup
binfₛ → bsInf
bsupᵢ → biSup
binfᵢ → biInf
csupₛ → csSup
cinfₛ → csInf
csupᵢ → ciSup
cinfᵢ → ciInf
unionₛ → sUnion
interₛ → sInter
unionᵢ → iUnion
interᵢ → iInter
bunionₛ → bsUnion
binterₛ → bsInter
bunionᵢ → biUnion
binterᵢ → biInter

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

d1eb6264

Diff

@@ -31,8 +31,8 @@ We introduce the following definitions.
 
 ## Main results
 
-The main result `BoxIntegral.Prepartition.exists_unionᵢ_eq_diff` says that any prepartition `π` of
-`I` admits a prepartition `π'` of `I` that covers exactly `I \ π.unionᵢ`. One of these prepartitions
+The main result `BoxIntegral.Prepartition.exists_iUnion_eq_diff` says that any prepartition `π` of
+`I` admits a prepartition `π'` of `I` that covers exactly `I \ π.iUnion`. One of these prepartitions
 is available as `BoxIntegral.Prepartition.compl`.
 
 ## Tags
@@ -185,12 +185,12 @@ theorem mem_split_iff' : J ∈ split I i x ↔
 #align box_integral.prepartition.mem_split_iff' BoxIntegral.Prepartition.mem_split_iff'
 
 @[simp]
-theorem unionᵢ_split (I : Box ι) (i : ι) (x : ℝ) : (split I i x).unionᵢ = I := by
+theorem iUnion_split (I : Box ι) (i : ι) (x : ℝ) : (split I i x).iUnion = I := by
   simp [split, ← inter_union_distrib_left, ← setOf_or, le_or_lt]
-#align box_integral.prepartition.Union_split BoxIntegral.Prepartition.unionᵢ_split
+#align box_integral.prepartition.Union_split BoxIntegral.Prepartition.iUnion_split
 
 theorem isPartitionSplit (I : Box ι) (i : ι) (x : ℝ) : IsPartition (split I i x) :=
-  isPartition_iff_unionᵢ_eq.2 <| unionᵢ_split I i x
+  isPartition_iff_iUnion_eq.2 <| iUnion_split I i x
 #align box_integral.prepartition.is_partition_split BoxIntegral.Prepartition.isPartitionSplit
 
 -- Porting note: In the type, changed `Option.elim` to `Option.elim'`
@@ -235,8 +235,8 @@ theorem restrict_split (h : I ≤ J) (i : ι) (x : ℝ) : (split J i x).restrict
 #align box_integral.prepartition.restrict_split BoxIntegral.Prepartition.restrict_split
 
 theorem inf_split (π : Prepartition I) (i : ι) (x : ℝ) :
-    π ⊓ split I i x = π.bunionᵢ fun J => split J i x :=
-  bunionᵢ_congr_of_le rfl fun _ hJ => restrict_split hJ i x
+    π ⊓ split I i x = π.biUnion fun J => split J i x :=
+  biUnion_congr_of_le rfl fun _ hJ => restrict_split hJ i x
 #align box_integral.prepartition.inf_split BoxIntegral.Prepartition.inf_split
 
 /-- Split a box along many hyperplanes `{y | y i = x}`; each hyperplane is given by the pair
@@ -263,19 +263,19 @@ theorem splitMany_le_split (I : Box ι) {s : Finset (ι × ℝ)} {p : ι × ℝ}
 
 theorem isPartition_splitMany (I : Box ι) (s : Finset (ι × ℝ)) : IsPartition (splitMany I s) :=
   Finset.induction_on s (by simp only [splitMany_empty, isPartitionTop]) fun a s _ hs => by
-    simpa only [splitMany_insert, inf_split] using hs.bunionᵢ fun J _ => isPartitionSplit _ _ _
+    simpa only [splitMany_insert, inf_split] using hs.biUnion fun J _ => isPartitionSplit _ _ _
 #align box_integral.prepartition.is_partition_split_many BoxIntegral.Prepartition.isPartition_splitMany
 
 @[simp]
-theorem unionᵢ_splitMany (I : Box ι) (s : Finset (ι × ℝ)) : (splitMany I s).unionᵢ = I :=
-  (isPartition_splitMany I s).unionᵢ_eq
-#align box_integral.prepartition.Union_split_many BoxIntegral.Prepartition.unionᵢ_splitMany
+theorem iUnion_splitMany (I : Box ι) (s : Finset (ι × ℝ)) : (splitMany I s).iUnion = I :=
+  (isPartition_splitMany I s).iUnion_eq
+#align box_integral.prepartition.Union_split_many BoxIntegral.Prepartition.iUnion_splitMany
 
 theorem inf_splitMany {I : Box ι} (π : Prepartition I) (s : Finset (ι × ℝ)) :
-    π ⊓ splitMany I s = π.bunionᵢ fun J => splitMany J s := by
+    π ⊓ splitMany I s = π.biUnion fun J => splitMany J s := by
   induction' s using Finset.induction_on with p s _ ihp
   · simp
-  · simp_rw [splitMany_insert, ← inf_assoc, ihp, inf_split, bunionᵢ_assoc]
+  · simp_rw [splitMany_insert, ← inf_assoc, ihp, inf_split, biUnion_assoc]
 #align box_integral.prepartition.inf_split_many BoxIntegral.Prepartition.inf_splitMany
 
 /-- Let `s : Finset (ι × ℝ)` be a set of hyperplanes `{x : ι → ℝ | x i = r}` in `ι → ℝ` encoded as
@@ -312,31 +312,31 @@ theorem eventually_not_disjoint_imp_le_of_mem_splitMany (s : Finset (Box ι)) :
       ¬Disjoint (J : WithBot (Box ι)) J' → J' ≤ J := by
   cases nonempty_fintype ι
   refine' eventually_atTop.2
-    ⟨s.bunionᵢ fun J => Finset.univ.bunionᵢ fun i => {(i, J.lower i), (i, J.upper i)},
+    ⟨s.biUnion fun J => Finset.univ.biUnion fun i => {(i, J.lower i), (i, J.upper i)},
       fun t ht I J hJ J' hJ' => not_disjoint_imp_le_of_subset_of_mem_splitMany (fun i => _) hJ'⟩
   exact fun p hp =>
-    ht (Finset.mem_bunionᵢ.2 ⟨J, hJ, Finset.mem_bunionᵢ.2 ⟨i, Finset.mem_univ _, hp⟩⟩)
+    ht (Finset.mem_biUnion.2 ⟨J, hJ, Finset.mem_biUnion.2 ⟨i, Finset.mem_univ _, hp⟩⟩)
 #align box_integral.prepartition.eventually_not_disjoint_imp_le_of_mem_split_many BoxIntegral.Prepartition.eventually_not_disjoint_imp_le_of_mem_splitMany
 
 theorem eventually_splitMany_inf_eq_filter (π : Prepartition I) :
     ∀ᶠ t : Finset (ι × ℝ) in atTop,
-      π ⊓ splitMany I t = (splitMany I t).filter fun J => ↑J ⊆ π.unionᵢ := by
+      π ⊓ splitMany I t = (splitMany I t).filter fun J => ↑J ⊆ π.iUnion := by
   refine' (eventually_not_disjoint_imp_le_of_mem_splitMany π.boxes).mono fun t ht => _
-  refine' le_antisymm ((bunionᵢ_le_iff _).2 fun J hJ => _) (le_inf (fun J hJ => _) (filter_le _ _))
+  refine' le_antisymm ((biUnion_le_iff _).2 fun J hJ => _) (le_inf (fun J hJ => _) (filter_le _ _))
   · refine' ofWithBot_mono _
     simp only [Finset.mem_image, exists_prop, mem_boxes, mem_filter]
     rintro _ ⟨J₁, h₁, rfl⟩ hne
-    refine' ⟨_, ⟨J₁, ⟨h₁, Subset.trans _ (π.subset_unionᵢ hJ)⟩, rfl⟩, le_rfl⟩
+    refine' ⟨_, ⟨J₁, ⟨h₁, Subset.trans _ (π.subset_iUnion hJ)⟩, rfl⟩, le_rfl⟩
     exact ht I J hJ J₁ h₁ (mt disjoint_iff.1 hne)
   · rw [mem_filter] at hJ
-    rcases Set.mem_unionᵢ₂.1 (hJ.2 J.upper_mem) with ⟨J', hJ', hmem⟩
+    rcases Set.mem_iUnion₂.1 (hJ.2 J.upper_mem) with ⟨J', hJ', hmem⟩
     refine' ⟨J', hJ', ht I _ hJ' _ hJ.1 <| Box.not_disjoint_coe_iff_nonempty_inter.2 _⟩
     exact ⟨J.upper, hmem, J.upper_mem⟩
 #align box_integral.prepartition.eventually_split_many_inf_eq_filter BoxIntegral.Prepartition.eventually_splitMany_inf_eq_filter
 
 theorem exists_splitMany_inf_eq_filter_of_finite (s : Set (Prepartition I)) (hs : s.Finite) :
     ∃ t : Finset (ι × ℝ),
-      ∀ π ∈ s, π ⊓ splitMany I t = (splitMany I t).filter fun J => ↑J ⊆ π.unionᵢ :=
+      ∀ π ∈ s, π ⊓ splitMany I t = (splitMany I t).filter fun J => ↑J ⊆ π.iUnion :=
   haveI := fun π (_ : π ∈ s) => eventually_splitMany_inf_eq_filter π
   (hs.eventually_all.2 this).exists
 #align box_integral.prepartition.exists_split_many_inf_eq_filter_of_finite BoxIntegral.Prepartition.exists_splitMany_inf_eq_filter_of_finite
@@ -346,40 +346,40 @@ theorem exists_splitMany_inf_eq_filter_of_finite (s : Set (Prepartition I)) (hs
 theorem IsPartition.exists_splitMany_le {I : Box ι} {π : Prepartition I} (h : IsPartition π) :
     ∃ s, splitMany I s ≤ π := by
   refine' (eventually_splitMany_inf_eq_filter π).exists.imp fun s hs => _
-  rwa [h.unionᵢ_eq, filter_of_true, inf_eq_right] at hs
+  rwa [h.iUnion_eq, filter_of_true, inf_eq_right] at hs
   exact fun J hJ => le_of_mem _ hJ
 #align box_integral.prepartition.is_partition.exists_split_many_le BoxIntegral.Prepartition.IsPartition.exists_splitMany_le
 
 /-- For every prepartition `π` of `I` there exists a prepartition that covers exactly
-`I \ π.unionᵢ`. -/
-theorem exists_unionᵢ_eq_diff (π : Prepartition I) :
-    ∃ π' : Prepartition I, π'.unionᵢ = ↑I \ π.unionᵢ := by
+`I \ π.iUnion`. -/
+theorem exists_iUnion_eq_diff (π : Prepartition I) :
+    ∃ π' : Prepartition I, π'.iUnion = ↑I \ π.iUnion := by
   rcases π.eventually_splitMany_inf_eq_filter.exists with ⟨s, hs⟩
-  use (splitMany I s).filter fun J => ¬(J : Set (ι → ℝ)) ⊆ π.unionᵢ
+  use (splitMany I s).filter fun J => ¬(J : Set (ι → ℝ)) ⊆ π.iUnion
   simp [← hs]
-#align box_integral.prepartition.exists_Union_eq_diff BoxIntegral.Prepartition.exists_unionᵢ_eq_diff
+#align box_integral.prepartition.exists_Union_eq_diff BoxIntegral.Prepartition.exists_iUnion_eq_diff
 
 /-- If `π` is a prepartition of `I`, then `π.compl` is a prepartition of `I`
-such that `π.compl.unionᵢ = I \ π.unionᵢ`. -/
+such that `π.compl.iUnion = I \ π.iUnion`. -/
 def compl (π : Prepartition I) : Prepartition I :=
-  π.exists_unionᵢ_eq_diff.choose
+  π.exists_iUnion_eq_diff.choose
 #align box_integral.prepartition.compl BoxIntegral.Prepartition.compl
 
 @[simp]
-theorem unionᵢ_compl (π : Prepartition I) : π.compl.unionᵢ = ↑I \ π.unionᵢ :=
-  π.exists_unionᵢ_eq_diff.choose_spec
-#align box_integral.prepartition.Union_compl BoxIntegral.Prepartition.unionᵢ_compl
+theorem iUnion_compl (π : Prepartition I) : π.compl.iUnion = ↑I \ π.iUnion :=
+  π.exists_iUnion_eq_diff.choose_spec
+#align box_integral.prepartition.Union_compl BoxIntegral.Prepartition.iUnion_compl
 
 /-- Since the definition of `BoxIntegral.Prepartition.compl` uses `Exists.choose`,
-the result depends only on `π.unionᵢ`. -/
-theorem compl_congr {π₁ π₂ : Prepartition I} (h : π₁.unionᵢ = π₂.unionᵢ) : π₁.compl = π₂.compl := by
+the result depends only on `π.iUnion`. -/
+theorem compl_congr {π₁ π₂ : Prepartition I} (h : π₁.iUnion = π₂.iUnion) : π₁.compl = π₂.compl := by
   dsimp only [compl]
   congr 1
   rw [h]
 #align box_integral.prepartition.compl_congr BoxIntegral.Prepartition.compl_congr
 
 theorem IsPartition.compl_eq_bot {π : Prepartition I} (h : IsPartition π) : π.compl = ⊥ := by
-  rw [← unionᵢ_eq_empty, unionᵢ_compl, h.unionᵢ_eq, diff_self]
+  rw [← iUnion_eq_empty, iUnion_compl, h.iUnion_eq, diff_self]
 #align box_integral.prepartition.is_partition.compl_eq_bot BoxIntegral.Prepartition.IsPartition.compl_eq_bot
 
 @[simp]

6ca1a09b

feat: port Analysis.BoxIntegral.Partition.Split (#3658)

6aa4d442

`analysis.box_integral.partition.split` ⟷ `Mathlib.Analysis.BoxIntegral.Partition.Split`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Renames

Dependencies 10 + 448

analysis.box_integral.partition.split ⟷ Mathlib.Analysis.BoxIntegral.Partition.Split

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

PR contents

Lean PRs involved in this bump

leanprover/lean4#2778

leanprover/lean4#2722

leanprover/lean4#2783

Renames

Dependencies 10 + 448

`analysis.box_integral.partition.split` ⟷ `Mathlib.Analysis.BoxIntegral.Partition.Split`