measure_theory.measure.sub | Mathlib porting status

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

562bbf52

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

a2706b55

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -113,7 +113,7 @@ theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ 
       · apply @sInf_le (Measure α) measure.complete_semilattice_Inf
         simp [le_refl, add_comm, h_measure_sub_add]
       apply @le_sInf (Measure α) measure.complete_semilattice_Inf
-      intro d h_d; rw [← h_measure_sub_add, mem_set_of_eq, add_comm d] at h_d 
+      intro d h_d; rw [← h_measure_sub_add, mem_set_of_eq, add_comm d] at h_d
       apply measure.le_of_add_le_add_left h_d
     rw [h_measure_sub_eq]
     apply measure.of_measurable_apply _ h₁
@@ -137,7 +137,7 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
   rw [restrict_Inf_eq_Inf_restrict h_nonempty h_meas_s]
   apply le_antisymm
   · refine' sInf_le_sInf_of_forall_exists_le _
-    intro ν' h_ν'_in; rw [mem_set_of_eq] at h_ν'_in 
+    intro ν' h_ν'_in; rw [mem_set_of_eq] at h_ν'_in
     refine' ⟨ν'.restrict s, _, restrict_le_self⟩
     refine' ⟨ν' + (⊤ : Measure α).restrict (sᶜ), _, _⟩
     · rw [mem_set_of_eq, add_right_comm, measure.le_iff]

a2706b55

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) 2022 Martin Zinkevich. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Martin Zinkevich
 -/
-import Mathbin.MeasureTheory.Measure.MeasureSpace
+import MeasureTheory.Measure.MeasureSpace
 
 #align_import measure_theory.measure.sub from "leanprover-community/mathlib"@"a2706b55e8d7f7e9b1f93143f0b88f2e34a11eea"

a2706b55

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) 2022 Martin Zinkevich. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Martin Zinkevich
-
-! This file was ported from Lean 3 source module measure_theory.measure.sub
-! leanprover-community/mathlib commit a2706b55e8d7f7e9b1f93143f0b88f2e34a11eea
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.MeasureTheory.Measure.MeasureSpace
 
+#align_import measure_theory.measure.sub from "leanprover-community/mathlib"@"a2706b55e8d7f7e9b1f93143f0b88f2e34a11eea"
+
 /-!
 # Subtraction of measures

a2706b55

bump to nightly-2023-06-20-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/2a0ce625dbb0ffbc7d1316597de0b25c1ec75303

9b351f8c

Diff

@@ -106,7 +106,7 @@ theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ 
   -- Now, we demonstrate `μ - ν = measure_sub`, and apply it.
   · have h_measure_sub_add : ν + measure_sub = μ :=
       by
-      ext (t h_t_measurable_set)
+      ext t h_t_measurable_set
       simp only [Pi.add_apply, coe_add]
       rw [MeasureTheory.Measure.ofMeasurable_apply _ h_t_measurable_set, add_comm,
         tsub_add_cancel_of_le (h₂ t h_t_measurable_set)]
@@ -126,7 +126,7 @@ theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ 
 #print MeasureTheory.Measure.sub_add_cancel_of_le /-
 theorem sub_add_cancel_of_le [IsFiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ :=
   by
-  ext (s h_s_meas)
+  ext s h_s_meas
   rw [add_apply, sub_apply h_s_meas h₁, tsub_add_cancel_of_le (h₁ s h_s_meas)]
 #align measure_theory.measure.sub_add_cancel_of_le MeasureTheory.Measure.sub_add_cancel_of_le
 -/

a2706b55

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -45,9 +45,11 @@ noncomputable instance instSub {α : Type _} [MeasurableSpace α] : Sub (Measure
 
 variable {α : Type _} {m : MeasurableSpace α} {μ ν : Measure α} {s : Set α}
 
+#print MeasureTheory.Measure.sub_def /-
 theorem sub_def : μ - ν = sInf {d | μ ≤ d + ν} :=
   rfl
 #align measure_theory.measure.sub_def MeasureTheory.Measure.sub_def
+-/
 
 #print MeasureTheory.Measure.sub_le_of_le_add /-
 theorem sub_le_of_le_add {d} (h : μ ≤ d + ν) : μ - ν ≤ d :=
@@ -88,6 +90,7 @@ theorem sub_self : μ - μ = 0 :=
 #align measure_theory.measure.sub_self MeasureTheory.Measure.sub_self
 -/
 
+#print MeasureTheory.Measure.sub_apply /-
 /-- This application lemma only works in special circumstances. Given knowledge of
 when `μ ≤ ν` and `ν ≤ μ`, a more general application lemma can be written. -/
 theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ) : (μ - ν) s = μ s - ν s :=
@@ -118,6 +121,7 @@ theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ 
     rw [h_measure_sub_eq]
     apply measure.of_measurable_apply _ h₁
 #align measure_theory.measure.sub_apply MeasureTheory.Measure.sub_apply
+-/
 
 #print MeasureTheory.Measure.sub_add_cancel_of_le /-
 theorem sub_add_cancel_of_le [IsFiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ :=
@@ -161,10 +165,12 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
 #align measure_theory.measure.restrict_sub_eq_restrict_sub_restrict MeasureTheory.Measure.restrict_sub_eq_restrict_sub_restrict
 -/
 
+#print MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict /-
 theorem sub_apply_eq_zero_of_restrict_le_restrict (h_le : μ.restrict s ≤ ν.restrict s)
     (h_meas_s : MeasurableSet s) : (μ - ν) s = 0 := by
   rw [← restrict_apply_self, restrict_sub_eq_restrict_sub_restrict, sub_eq_zero_of_le] <;> simp [*]
 #align measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict
+-/
 
 #print MeasureTheory.Measure.isFiniteMeasure_sub /-
 instance isFiniteMeasure_sub [IsFiniteMeasure μ] : IsFiniteMeasure (μ - ν) :=

a2706b55

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -39,13 +39,13 @@ Specifically, note that if you have `α = {1,2}`, and  `μ {1} = 2`, `μ {2} = 0
 `ν {2} = 2`, `ν {1} = 0`, then `(μ - ν) {1, 2} = 2`. However, if `μ ≤ ν`, and
 `ν univ ≠ ∞`, then `(μ - ν) + ν = μ`. -/
 noncomputable instance instSub {α : Type _} [MeasurableSpace α] : Sub (Measure α) :=
-  ⟨fun μ ν => sInf { τ | μ ≤ τ + ν }⟩
+  ⟨fun μ ν => sInf {τ | μ ≤ τ + ν}⟩
 #align measure_theory.measure.has_sub MeasureTheory.Measure.instSub
 -/
 
 variable {α : Type _} {m : MeasurableSpace α} {μ ν : Measure α} {s : Set α}
 
-theorem sub_def : μ - ν = sInf { d | μ ≤ d + ν } :=
+theorem sub_def : μ - ν = sInf {d | μ ≤ d + ν} :=
   rfl
 #align measure_theory.measure.sub_def MeasureTheory.Measure.sub_def
 
@@ -90,7 +90,7 @@ theorem sub_self : μ - μ = 0 :=
 
 /-- This application lemma only works in special circumstances. Given knowledge of
 when `μ ≤ ν` and `ν ≤ μ`, a more general application lemma can be written. -/
-theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ) : (μ - ν) s = μ s - ν s :=
+theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ) : (μ - ν) s = μ s - ν s :=
   by
   -- We begin by defining `measure_sub`, which will be equal to `(μ - ν)`.
   let measure_sub : Measure α :=
@@ -120,7 +120,7 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
 #align measure_theory.measure.sub_apply MeasureTheory.Measure.sub_apply
 
 #print MeasureTheory.Measure.sub_add_cancel_of_le /-
-theorem sub_add_cancel_of_le [FiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ :=
+theorem sub_add_cancel_of_le [IsFiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ :=
   by
   ext (s h_s_meas)
   rw [add_apply, sub_apply h_s_meas h₁, tsub_add_cancel_of_le (h₁ s h_s_meas)]
@@ -132,7 +132,7 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
     (μ - ν).restrict s = μ.restrict s - ν.restrict s :=
   by
   repeat' rw [sub_def]
-  have h_nonempty : { d | μ ≤ d + ν }.Nonempty := ⟨μ, measure.le_add_right le_rfl⟩
+  have h_nonempty : {d | μ ≤ d + ν}.Nonempty := ⟨μ, measure.le_add_right le_rfl⟩
   rw [restrict_Inf_eq_Inf_restrict h_nonempty h_meas_s]
   apply le_antisymm
   · refine' sInf_le_sInf_of_forall_exists_le _
@@ -166,10 +166,10 @@ theorem sub_apply_eq_zero_of_restrict_le_restrict (h_le : μ.restrict s ≤ ν.r
   rw [← restrict_apply_self, restrict_sub_eq_restrict_sub_restrict, sub_eq_zero_of_le] <;> simp [*]
 #align measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict
 
-#print MeasureTheory.Measure.finiteMeasure_sub /-
-instance finiteMeasure_sub [FiniteMeasure μ] : FiniteMeasure (μ - ν) :=
-  finiteMeasureOfLe μ sub_le
-#align measure_theory.measure.is_finite_measure_sub MeasureTheory.Measure.finiteMeasure_sub
+#print MeasureTheory.Measure.isFiniteMeasure_sub /-
+instance isFiniteMeasure_sub [IsFiniteMeasure μ] : IsFiniteMeasure (μ - ν) :=
+  isFiniteMeasure_of_le μ sub_le
+#align measure_theory.measure.is_finite_measure_sub MeasureTheory.Measure.isFiniteMeasure_sub
 -/
 
 end Measure

a2706b55

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -99,7 +99,7 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
       (by
         intro g h_meas h_disj; simp only; rw [ENNReal.tsum_sub]
         repeat' rw [← MeasureTheory.measure_iUnion h_disj h_meas]
-        exacts[MeasureTheory.measure_ne_top _ _, fun i => h₂ _ (h_meas _)])
+        exacts [MeasureTheory.measure_ne_top _ _, fun i => h₂ _ (h_meas _)])
   -- Now, we demonstrate `μ - ν = measure_sub`, and apply it.
   · have h_measure_sub_add : ν + measure_sub = μ :=
       by
@@ -113,7 +113,7 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
       · apply @sInf_le (Measure α) measure.complete_semilattice_Inf
         simp [le_refl, add_comm, h_measure_sub_add]
       apply @le_sInf (Measure α) measure.complete_semilattice_Inf
-      intro d h_d; rw [← h_measure_sub_add, mem_set_of_eq, add_comm d] at h_d
+      intro d h_d; rw [← h_measure_sub_add, mem_set_of_eq, add_comm d] at h_d 
       apply measure.le_of_add_le_add_left h_d
     rw [h_measure_sub_eq]
     apply measure.of_measurable_apply _ h₁
@@ -136,7 +136,7 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
   rw [restrict_Inf_eq_Inf_restrict h_nonempty h_meas_s]
   apply le_antisymm
   · refine' sInf_le_sInf_of_forall_exists_le _
-    intro ν' h_ν'_in; rw [mem_set_of_eq] at h_ν'_in
+    intro ν' h_ν'_in; rw [mem_set_of_eq] at h_ν'_in 
     refine' ⟨ν'.restrict s, _, restrict_le_self⟩
     refine' ⟨ν' + (⊤ : Measure α).restrict (sᶜ), _, _⟩
     · rw [mem_set_of_eq, add_right_comm, measure.le_iff]

a2706b55

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -49,17 +49,23 @@ theorem sub_def : μ - ν = sInf { d | μ ≤ d + ν } :=
   rfl
 #align measure_theory.measure.sub_def MeasureTheory.Measure.sub_def
 
+#print MeasureTheory.Measure.sub_le_of_le_add /-
 theorem sub_le_of_le_add {d} (h : μ ≤ d + ν) : μ - ν ≤ d :=
   sInf_le h
 #align measure_theory.measure.sub_le_of_le_add MeasureTheory.Measure.sub_le_of_le_add
+-/
 
+#print MeasureTheory.Measure.sub_eq_zero_of_le /-
 theorem sub_eq_zero_of_le (h : μ ≤ ν) : μ - ν = 0 :=
   nonpos_iff_eq_zero'.1 <| sub_le_of_le_add <| by rwa [zero_add]
 #align measure_theory.measure.sub_eq_zero_of_le MeasureTheory.Measure.sub_eq_zero_of_le
+-/
 
+#print MeasureTheory.Measure.sub_le /-
 theorem sub_le : μ - ν ≤ μ :=
   sub_le_of_le_add <| Measure.le_add_right le_rfl
 #align measure_theory.measure.sub_le MeasureTheory.Measure.sub_le
+-/
 
 #print MeasureTheory.Measure.sub_top /-
 @[simp]
@@ -113,11 +119,13 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
     apply measure.of_measurable_apply _ h₁
 #align measure_theory.measure.sub_apply MeasureTheory.Measure.sub_apply
 
+#print MeasureTheory.Measure.sub_add_cancel_of_le /-
 theorem sub_add_cancel_of_le [FiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ :=
   by
   ext (s h_s_meas)
   rw [add_apply, sub_apply h_s_meas h₁, tsub_add_cancel_of_le (h₁ s h_s_meas)]
 #align measure_theory.measure.sub_add_cancel_of_le MeasureTheory.Measure.sub_add_cancel_of_le
+-/
 
 #print MeasureTheory.Measure.restrict_sub_eq_restrict_sub_restrict /-
 theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :

a2706b55

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -45,42 +45,18 @@ noncomputable instance instSub {α : Type _} [MeasurableSpace α] : Sub (Measure
 
 variable {α : Type _} {m : MeasurableSpace α} {μ ν : Measure α} {s : Set α}
 
-/- warning: measure_theory.measure.sub_def -> MeasureTheory.Measure.sub_def is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) (InfSet.sInf.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasInf.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
-but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) (InfSet.sInf.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instInfSetMeasure.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
-Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_def MeasureTheory.Measure.sub_defₓ'. -/
 theorem sub_def : μ - ν = sInf { d | μ ≤ d + ν } :=
   rfl
 #align measure_theory.measure.sub_def MeasureTheory.Measure.sub_def
 
-/- warning: measure_theory.measure.sub_le_of_le_add -> MeasureTheory.Measure.sub_le_of_le_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {d : MeasureTheory.Measure.{u1} α m}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν)) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) d)
-but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {d : MeasureTheory.Measure.{u1} α m}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν)) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) d)
-Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_le_of_le_add MeasureTheory.Measure.sub_le_of_le_addₓ'. -/
 theorem sub_le_of_le_add {d} (h : μ ≤ d + ν) : μ - ν ≤ d :=
   sInf_le h
 #align measure_theory.measure.sub_le_of_le_add MeasureTheory.Measure.sub_le_of_le_add
 
-/- warning: measure_theory.measure.sub_eq_zero_of_le -> MeasureTheory.Measure.sub_eq_zero_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ ν) -> (Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) (OfNat.ofNat.{u1} (MeasureTheory.Measure.{u1} α m) 0 (OfNat.mk.{u1} (MeasureTheory.Measure.{u1} α m) 0 (Zero.zero.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instZero.{u1} α m)))))
-but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ ν) -> (Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) (OfNat.ofNat.{u1} (MeasureTheory.Measure.{u1} α m) 0 (Zero.toOfNat0.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instZero.{u1} α m))))
-Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_eq_zero_of_le MeasureTheory.Measure.sub_eq_zero_of_leₓ'. -/
 theorem sub_eq_zero_of_le (h : μ ≤ ν) : μ - ν = 0 :=
   nonpos_iff_eq_zero'.1 <| sub_le_of_le_add <| by rwa [zero_add]
 #align measure_theory.measure.sub_eq_zero_of_le MeasureTheory.Measure.sub_eq_zero_of_le
 
-/- warning: measure_theory.measure.sub_le -> MeasureTheory.Measure.sub_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) μ
-but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) μ
-Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_le MeasureTheory.Measure.sub_leₓ'. -/
 theorem sub_le : μ - ν ≤ μ :=
   sub_le_of_le_add <| Measure.le_add_right le_rfl
 #align measure_theory.measure.sub_le MeasureTheory.Measure.sub_le
@@ -106,12 +82,6 @@ theorem sub_self : μ - μ = 0 :=
 #align measure_theory.measure.sub_self MeasureTheory.Measure.sub_self
 -/
 
-/- warning: measure_theory.measure.sub_apply -> MeasureTheory.Measure.sub_apply is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (MeasurableSet.{u1} α m s) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) s) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.hasSub) (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) μ s) (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) ν s)))
-but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (MeasurableSet.{u1} α m s) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν)) s) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.instSub) (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m μ) s) (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m ν) s)))
-Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_apply MeasureTheory.Measure.sub_applyₓ'. -/
 /-- This application lemma only works in special circumstances. Given knowledge of
 when `μ ≤ ν` and `ν ≤ μ`, a more general application lemma can be written. -/
 theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ) : (μ - ν) s = μ s - ν s :=
@@ -143,12 +113,6 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
     apply measure.of_measurable_apply _ h₁
 #align measure_theory.measure.sub_apply MeasureTheory.Measure.sub_apply
 
-/- warning: measure_theory.measure.sub_add_cancel_of_le -> MeasureTheory.Measure.sub_add_cancel_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) ν) μ)
-but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) ν) μ)
-Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_add_cancel_of_le MeasureTheory.Measure.sub_add_cancel_of_leₓ'. -/
 theorem sub_add_cancel_of_le [FiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ :=
   by
   ext (s h_s_meas)
@@ -189,12 +153,6 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
 #align measure_theory.measure.restrict_sub_eq_restrict_sub_restrict MeasureTheory.Measure.restrict_sub_eq_restrict_sub_restrict
 -/
 
-/- warning: measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict -> MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (MeasureTheory.Measure.restrict.{u1} α m μ s) (MeasureTheory.Measure.restrict.{u1} α m ν s)) -> (MeasurableSet.{u1} α m s) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) s) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero))))
-but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (MeasureTheory.Measure.restrict.{u1} α m μ s) (MeasureTheory.Measure.restrict.{u1} α m ν s)) -> (MeasurableSet.{u1} α m s) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν)) s) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero)))
-Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrictₓ'. -/
 theorem sub_apply_eq_zero_of_restrict_le_restrict (h_le : μ.restrict s ≤ ν.restrict s)
     (h_meas_s : MeasurableSet s) : (μ - ν) s = 0 := by
   rw [← restrict_apply_self, restrict_sub_eq_restrict_sub_restrict, sub_eq_zero_of_le] <;> simp [*]

a2706b55

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -133,13 +133,11 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
         tsub_add_cancel_of_le (h₂ t h_t_measurable_set)]
     have h_measure_sub_eq : μ - ν = measure_sub :=
       by
-      rw [MeasureTheory.Measure.sub_def]
-      apply le_antisymm
+      rw [MeasureTheory.Measure.sub_def]; apply le_antisymm
       · apply @sInf_le (Measure α) measure.complete_semilattice_Inf
         simp [le_refl, add_comm, h_measure_sub_add]
       apply @le_sInf (Measure α) measure.complete_semilattice_Inf
-      intro d h_d
-      rw [← h_measure_sub_add, mem_set_of_eq, add_comm d] at h_d
+      intro d h_d; rw [← h_measure_sub_add, mem_set_of_eq, add_comm d] at h_d
       apply measure.le_of_add_le_add_left h_d
     rw [h_measure_sub_eq]
     apply measure.of_measurable_apply _ h₁
@@ -166,8 +164,7 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
   rw [restrict_Inf_eq_Inf_restrict h_nonempty h_meas_s]
   apply le_antisymm
   · refine' sInf_le_sInf_of_forall_exists_le _
-    intro ν' h_ν'_in
-    rw [mem_set_of_eq] at h_ν'_in
+    intro ν' h_ν'_in; rw [mem_set_of_eq] at h_ν'_in
     refine' ⟨ν'.restrict s, _, restrict_le_self⟩
     refine' ⟨ν' + (⊤ : Measure α).restrict (sᶜ), _, _⟩
     · rw [mem_set_of_eq, add_right_comm, measure.le_iff]

a2706b55

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -47,7 +47,7 @@ variable {α : Type _} {m : MeasurableSpace α} {μ ν : Measure α} {s : Set α
 
 /- warning: measure_theory.measure.sub_def -> MeasureTheory.Measure.sub_def is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) (InfSet.sInf.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasInf.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) (InfSet.sInf.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasInf.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
 but is expected to have type
   forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) (InfSet.sInf.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instInfSetMeasure.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
 Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_def MeasureTheory.Measure.sub_defₓ'. -/
@@ -55,23 +55,35 @@ theorem sub_def : μ - ν = sInf { d | μ ≤ d + ν } :=
   rfl
 #align measure_theory.measure.sub_def MeasureTheory.Measure.sub_def
 
-#print MeasureTheory.Measure.sub_le_of_le_add /-
+/- warning: measure_theory.measure.sub_le_of_le_add -> MeasureTheory.Measure.sub_le_of_le_add is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {d : MeasureTheory.Measure.{u1} α m}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν)) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) d)
+but is expected to have type
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {d : MeasureTheory.Measure.{u1} α m}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν)) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) d)
+Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_le_of_le_add MeasureTheory.Measure.sub_le_of_le_addₓ'. -/
 theorem sub_le_of_le_add {d} (h : μ ≤ d + ν) : μ - ν ≤ d :=
   sInf_le h
 #align measure_theory.measure.sub_le_of_le_add MeasureTheory.Measure.sub_le_of_le_add
--/
 
-#print MeasureTheory.Measure.sub_eq_zero_of_le /-
+/- warning: measure_theory.measure.sub_eq_zero_of_le -> MeasureTheory.Measure.sub_eq_zero_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ ν) -> (Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) (OfNat.ofNat.{u1} (MeasureTheory.Measure.{u1} α m) 0 (OfNat.mk.{u1} (MeasureTheory.Measure.{u1} α m) 0 (Zero.zero.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instZero.{u1} α m)))))
+but is expected to have type
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ ν) -> (Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) (OfNat.ofNat.{u1} (MeasureTheory.Measure.{u1} α m) 0 (Zero.toOfNat0.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instZero.{u1} α m))))
+Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_eq_zero_of_le MeasureTheory.Measure.sub_eq_zero_of_leₓ'. -/
 theorem sub_eq_zero_of_le (h : μ ≤ ν) : μ - ν = 0 :=
   nonpos_iff_eq_zero'.1 <| sub_le_of_le_add <| by rwa [zero_add]
 #align measure_theory.measure.sub_eq_zero_of_le MeasureTheory.Measure.sub_eq_zero_of_le
--/
 
-#print MeasureTheory.Measure.sub_le /-
+/- warning: measure_theory.measure.sub_le -> MeasureTheory.Measure.sub_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) μ
+but is expected to have type
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) μ
+Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_le MeasureTheory.Measure.sub_leₓ'. -/
 theorem sub_le : μ - ν ≤ μ :=
   sub_le_of_le_add <| Measure.le_add_right le_rfl
 #align measure_theory.measure.sub_le MeasureTheory.Measure.sub_le
--/
 
 #print MeasureTheory.Measure.sub_top /-
 @[simp]
@@ -96,7 +108,7 @@ theorem sub_self : μ - μ = 0 :=
 
 /- warning: measure_theory.measure.sub_apply -> MeasureTheory.Measure.sub_apply is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (MeasurableSet.{u1} α m s) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) s) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.hasSub) (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) μ s) (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) ν s)))
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (MeasurableSet.{u1} α m s) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) s) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.hasSub) (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) μ s) (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) ν s)))
 but is expected to have type
   forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (MeasurableSet.{u1} α m s) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν)) s) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.instSub) (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m μ) s) (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m ν) s)))
 Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_apply MeasureTheory.Measure.sub_applyₓ'. -/
@@ -133,13 +145,17 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
     apply measure.of_measurable_apply _ h₁
 #align measure_theory.measure.sub_apply MeasureTheory.Measure.sub_apply
 
-#print MeasureTheory.Measure.sub_add_cancel_of_le /-
+/- warning: measure_theory.measure.sub_add_cancel_of_le -> MeasureTheory.Measure.sub_add_cancel_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) ν) μ)
+but is expected to have type
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) ν) μ)
+Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_add_cancel_of_le MeasureTheory.Measure.sub_add_cancel_of_leₓ'. -/
 theorem sub_add_cancel_of_le [FiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ :=
   by
   ext (s h_s_meas)
   rw [add_apply, sub_apply h_s_meas h₁, tsub_add_cancel_of_le (h₁ s h_s_meas)]
 #align measure_theory.measure.sub_add_cancel_of_le MeasureTheory.Measure.sub_add_cancel_of_le
--/
 
 #print MeasureTheory.Measure.restrict_sub_eq_restrict_sub_restrict /-
 theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
@@ -178,7 +194,7 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
 
 /- warning: measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict -> MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (MeasureTheory.Measure.restrict.{u1} α m μ s) (MeasureTheory.Measure.restrict.{u1} α m ν s)) -> (MeasurableSet.{u1} α m s) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) s) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero))))
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toHasLe.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (MeasureTheory.Measure.restrict.{u1} α m μ s) (MeasureTheory.Measure.restrict.{u1} α m ν s)) -> (MeasurableSet.{u1} α m s) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) s) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero))))
 but is expected to have type
   forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (MeasureTheory.Measure.restrict.{u1} α m μ s) (MeasureTheory.Measure.restrict.{u1} α m ν s)) -> (MeasurableSet.{u1} α m s) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν)) s) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero)))
 Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrictₓ'. -/

a2706b55

bump to nightly-2023-05-15-12

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

f3ad2973

Diff

@@ -31,25 +31,25 @@ namespace MeasureTheory
 
 namespace Measure
 
-#print MeasureTheory.Measure.hasSub /-
+#print MeasureTheory.Measure.instSub /-
 /-- The measure `μ - ν` is defined to be the least measure `τ` such that `μ ≤ τ + ν`.
 It is the equivalent of `(μ - ν) ⊔ 0` if `μ` and `ν` were signed measures.
 Compare with `ennreal.has_sub`.
 Specifically, note that if you have `α = {1,2}`, and  `μ {1} = 2`, `μ {2} = 0`, and
 `ν {2} = 2`, `ν {1} = 0`, then `(μ - ν) {1, 2} = 2`. However, if `μ ≤ ν`, and
 `ν univ ≠ ∞`, then `(μ - ν) + ν = μ`. -/
-noncomputable instance hasSub {α : Type _} [MeasurableSpace α] : Sub (Measure α) :=
+noncomputable instance instSub {α : Type _} [MeasurableSpace α] : Sub (Measure α) :=
   ⟨fun μ ν => sInf { τ | μ ≤ τ + ν }⟩
-#align measure_theory.measure.has_sub MeasureTheory.Measure.hasSub
+#align measure_theory.measure.has_sub MeasureTheory.Measure.instSub
 -/
 
 variable {α : Type _} {m : MeasurableSpace α} {μ ν : Measure α} {s : Set α}
 
 /- warning: measure_theory.measure.sub_def -> MeasureTheory.Measure.sub_def is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν) (InfSet.sInf.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasInf.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) (InfSet.sInf.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasInf.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
 but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν) (InfSet.sInf.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instInfSetMeasure.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) (InfSet.sInf.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instInfSetMeasure.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
 Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_def MeasureTheory.Measure.sub_defₓ'. -/
 theorem sub_def : μ - ν = sInf { d | μ ≤ d + ν } :=
   rfl
@@ -96,9 +96,9 @@ theorem sub_self : μ - μ = 0 :=
 
 /- warning: measure_theory.measure.sub_apply -> MeasureTheory.Measure.sub_apply is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (MeasurableSet.{u1} α m s) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν) s) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.hasSub) (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) μ s) (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) ν s)))
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (MeasurableSet.{u1} α m s) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) s) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.hasSub) (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) μ s) (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) ν s)))
 but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (MeasurableSet.{u1} α m s) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν)) s) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.instSubENNReal) (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m μ) s) (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m ν) s)))
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (MeasurableSet.{u1} α m s) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν)) s) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.instSub) (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m μ) s) (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m ν) s)))
 Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_apply MeasureTheory.Measure.sub_applyₓ'. -/
 /-- This application lemma only works in special circumstances. Given knowledge of
 when `μ ≤ ν` and `ν ≤ μ`, a more general application lemma can be written. -/
@@ -178,9 +178,9 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
 
 /- warning: measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict -> MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (MeasureTheory.Measure.restrict.{u1} α m μ s) (MeasureTheory.Measure.restrict.{u1} α m ν s)) -> (MeasurableSet.{u1} α m s) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν) s) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero))))
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (MeasureTheory.Measure.restrict.{u1} α m μ s) (MeasureTheory.Measure.restrict.{u1} α m ν s)) -> (MeasurableSet.{u1} α m s) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν) s) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero))))
 but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (MeasureTheory.Measure.restrict.{u1} α m μ s) (MeasureTheory.Measure.restrict.{u1} α m ν s)) -> (MeasurableSet.{u1} α m s) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν)) s) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero)))
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (MeasureTheory.Measure.restrict.{u1} α m μ s) (MeasureTheory.Measure.restrict.{u1} α m ν s)) -> (MeasurableSet.{u1} α m s) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instSub.{u1} α m)) μ ν)) s) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero)))
 Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrictₓ'. -/
 theorem sub_apply_eq_zero_of_restrict_le_restrict (h_le : μ.restrict s ≤ ν.restrict s)
     (h_meas_s : MeasurableSet s) : (μ - ν) s = 0 := by

a2706b55

bump to nightly-2023-05-14-08

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

d31da313

Diff

@@ -39,7 +39,7 @@ Specifically, note that if you have `α = {1,2}`, and  `μ {1} = 2`, `μ {2} = 0
 `ν {2} = 2`, `ν {1} = 0`, then `(μ - ν) {1, 2} = 2`. However, if `μ ≤ ν`, and
 `ν univ ≠ ∞`, then `(μ - ν) + ν = μ`. -/
 noncomputable instance hasSub {α : Type _} [MeasurableSpace α] : Sub (Measure α) :=
-  ⟨fun μ ν => infₛ { τ | μ ≤ τ + ν }⟩
+  ⟨fun μ ν => sInf { τ | μ ≤ τ + ν }⟩
 #align measure_theory.measure.has_sub MeasureTheory.Measure.hasSub
 -/
 
@@ -47,17 +47,17 @@ variable {α : Type _} {m : MeasurableSpace α} {μ ν : Measure α} {s : Set α
 
 /- warning: measure_theory.measure.sub_def -> MeasureTheory.Measure.sub_def is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν) (InfSet.infₛ.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasInf.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν) (InfSet.sInf.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasInf.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
 but is expected to have type
-  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν) (InfSet.infₛ.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instInfSetMeasure.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν) (InfSet.sInf.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instInfSetMeasure.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
 Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_def MeasureTheory.Measure.sub_defₓ'. -/
-theorem sub_def : μ - ν = infₛ { d | μ ≤ d + ν } :=
+theorem sub_def : μ - ν = sInf { d | μ ≤ d + ν } :=
   rfl
 #align measure_theory.measure.sub_def MeasureTheory.Measure.sub_def
 
 #print MeasureTheory.Measure.sub_le_of_le_add /-
 theorem sub_le_of_le_add {d} (h : μ ≤ d + ν) : μ - ν ≤ d :=
-  infₛ_le h
+  sInf_le h
 #align measure_theory.measure.sub_le_of_le_add MeasureTheory.Measure.sub_le_of_le_add
 -/
 
@@ -110,7 +110,7 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
       (fun (t : Set α) (h_t_measurable_set : MeasurableSet t) => μ t - ν t) (by simp)
       (by
         intro g h_meas h_disj; simp only; rw [ENNReal.tsum_sub]
-        repeat' rw [← MeasureTheory.measure_unionᵢ h_disj h_meas]
+        repeat' rw [← MeasureTheory.measure_iUnion h_disj h_meas]
         exacts[MeasureTheory.measure_ne_top _ _, fun i => h₂ _ (h_meas _)])
   -- Now, we demonstrate `μ - ν = measure_sub`, and apply it.
   · have h_measure_sub_add : ν + measure_sub = μ :=
@@ -123,9 +123,9 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
       by
       rw [MeasureTheory.Measure.sub_def]
       apply le_antisymm
-      · apply @infₛ_le (Measure α) measure.complete_semilattice_Inf
+      · apply @sInf_le (Measure α) measure.complete_semilattice_Inf
         simp [le_refl, add_comm, h_measure_sub_add]
-      apply @le_infₛ (Measure α) measure.complete_semilattice_Inf
+      apply @le_sInf (Measure α) measure.complete_semilattice_Inf
       intro d h_d
       rw [← h_measure_sub_add, mem_set_of_eq, add_comm d] at h_d
       apply measure.le_of_add_le_add_left h_d
@@ -149,7 +149,7 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
   have h_nonempty : { d | μ ≤ d + ν }.Nonempty := ⟨μ, measure.le_add_right le_rfl⟩
   rw [restrict_Inf_eq_Inf_restrict h_nonempty h_meas_s]
   apply le_antisymm
-  · refine' infₛ_le_infₛ_of_forall_exists_le _
+  · refine' sInf_le_sInf_of_forall_exists_le _
     intro ν' h_ν'_in
     rw [mem_set_of_eq] at h_ν'_in
     refine' ⟨ν'.restrict s, _, restrict_le_self⟩
@@ -169,7 +169,7 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
         exact measure.le_iff'.1 h_mu_le_add_top _
     · ext1 t h_meas_t
       simp [restrict_apply h_meas_t, restrict_apply (h_meas_t.inter h_meas_s), inter_assoc]
-  · refine' infₛ_le_infₛ_of_forall_exists_le _
+  · refine' sInf_le_sInf_of_forall_exists_le _
     refine' ball_image_iff.2 fun t h_t_in => ⟨t.restrict s, _, le_rfl⟩
     rw [Set.mem_setOf_eq, ← restrict_add]
     exact restrict_mono subset.rfl h_t_in

a2706b55

bump to nightly-2023-05-11-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/28b2a92f2996d28e580450863c130955de0ed398

1eda273d

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Martin Zinkevich
 
 ! This file was ported from Lean 3 source module measure_theory.measure.sub
-! leanprover-community/mathlib commit 562bbf524c595c153470e53d36c57b6f891cc480
+! leanprover-community/mathlib commit a2706b55e8d7f7e9b1f93143f0b88f2e34a11eea
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.MeasureTheory.Measure.MeasureSpace
 /-!
 # Subtraction of measures
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 In this file we define `μ - ν` to be the least measure `τ` such that `μ ≤ τ + ν`.
 It is the equivalent of `(μ - ν) ⊔ 0` if `μ` and `ν` were signed measures.
 Compare with `ennreal.has_sub`.

562bbf52

bump to nightly-2023-05-09-14

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

3276c9af

Diff

@@ -28,6 +28,7 @@ namespace MeasureTheory
 
 namespace Measure
 
+#print MeasureTheory.Measure.hasSub /-
 /-- The measure `μ - ν` is defined to be the least measure `τ` such that `μ ≤ τ + ν`.
 It is the equivalent of `(μ - ν) ⊔ 0` if `μ` and `ν` were signed measures.
 Compare with `ennreal.has_sub`.
@@ -37,40 +38,65 @@ Specifically, note that if you have `α = {1,2}`, and  `μ {1} = 2`, `μ {2} = 0
 noncomputable instance hasSub {α : Type _} [MeasurableSpace α] : Sub (Measure α) :=
   ⟨fun μ ν => infₛ { τ | μ ≤ τ + ν }⟩
 #align measure_theory.measure.has_sub MeasureTheory.Measure.hasSub
+-/
 
 variable {α : Type _} {m : MeasurableSpace α} {μ ν : Measure α} {s : Set α}
 
+/- warning: measure_theory.measure.sub_def -> MeasureTheory.Measure.sub_def is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν) (InfSet.infₛ.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasInf.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
+but is expected to have type
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m}, Eq.{succ u1} (MeasureTheory.Measure.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν) (InfSet.infₛ.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instInfSetMeasure.{u1} α m) (setOf.{u1} (MeasureTheory.Measure.{u1} α m) (fun (d : MeasureTheory.Measure.{u1} α m) => LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) μ (HAdd.hAdd.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHAdd.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instAdd.{u1} α m)) d ν))))
+Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_def MeasureTheory.Measure.sub_defₓ'. -/
 theorem sub_def : μ - ν = infₛ { d | μ ≤ d + ν } :=
   rfl
 #align measure_theory.measure.sub_def MeasureTheory.Measure.sub_def
 
+#print MeasureTheory.Measure.sub_le_of_le_add /-
 theorem sub_le_of_le_add {d} (h : μ ≤ d + ν) : μ - ν ≤ d :=
   infₛ_le h
 #align measure_theory.measure.sub_le_of_le_add MeasureTheory.Measure.sub_le_of_le_add
+-/
 
+#print MeasureTheory.Measure.sub_eq_zero_of_le /-
 theorem sub_eq_zero_of_le (h : μ ≤ ν) : μ - ν = 0 :=
   nonpos_iff_eq_zero'.1 <| sub_le_of_le_add <| by rwa [zero_add]
 #align measure_theory.measure.sub_eq_zero_of_le MeasureTheory.Measure.sub_eq_zero_of_le
+-/
 
+#print MeasureTheory.Measure.sub_le /-
 theorem sub_le : μ - ν ≤ μ :=
   sub_le_of_le_add <| Measure.le_add_right le_rfl
 #align measure_theory.measure.sub_le MeasureTheory.Measure.sub_le
+-/
 
+#print MeasureTheory.Measure.sub_top /-
 @[simp]
 theorem sub_top : μ - ⊤ = 0 :=
   sub_eq_zero_of_le le_top
 #align measure_theory.measure.sub_top MeasureTheory.Measure.sub_top
+-/
 
+#print MeasureTheory.Measure.zero_sub /-
 @[simp]
 theorem zero_sub : 0 - μ = 0 :=
   sub_eq_zero_of_le μ.zero_le
 #align measure_theory.measure.zero_sub MeasureTheory.Measure.zero_sub
+-/
 
+#print MeasureTheory.Measure.sub_self /-
 @[simp]
 theorem sub_self : μ - μ = 0 :=
   sub_eq_zero_of_le le_rfl
 #align measure_theory.measure.sub_self MeasureTheory.Measure.sub_self
+-/
 
+/- warning: measure_theory.measure.sub_apply -> MeasureTheory.Measure.sub_apply is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (MeasurableSet.{u1} α m s) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν) s) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.hasSub) (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) μ s) (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) ν s)))
+but is expected to have type
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α} [_inst_1 : MeasureTheory.FiniteMeasure.{u1} α m ν], (MeasurableSet.{u1} α m s) -> (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) ν μ) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν)) s) (HSub.hSub.{0, 0, 0} ENNReal ENNReal ENNReal (instHSub.{0} ENNReal ENNReal.instSubENNReal) (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m μ) s) (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m ν) s)))
+Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_apply MeasureTheory.Measure.sub_applyₓ'. -/
 /-- This application lemma only works in special circumstances. Given knowledge of
 when `μ ≤ ν` and `ν ≤ μ`, a more general application lemma can be written. -/
 theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ) : (μ - ν) s = μ s - ν s :=
@@ -104,12 +130,15 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
     apply measure.of_measurable_apply _ h₁
 #align measure_theory.measure.sub_apply MeasureTheory.Measure.sub_apply
 
+#print MeasureTheory.Measure.sub_add_cancel_of_le /-
 theorem sub_add_cancel_of_le [FiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ :=
   by
   ext (s h_s_meas)
   rw [add_apply, sub_apply h_s_meas h₁, tsub_add_cancel_of_le (h₁ s h_s_meas)]
 #align measure_theory.measure.sub_add_cancel_of_le MeasureTheory.Measure.sub_add_cancel_of_le
+-/
 
+#print MeasureTheory.Measure.restrict_sub_eq_restrict_sub_restrict /-
 theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
     (μ - ν).restrict s = μ.restrict s - ν.restrict s :=
   by
@@ -142,15 +171,24 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
     rw [Set.mem_setOf_eq, ← restrict_add]
     exact restrict_mono subset.rfl h_t_in
 #align measure_theory.measure.restrict_sub_eq_restrict_sub_restrict MeasureTheory.Measure.restrict_sub_eq_restrict_sub_restrict
+-/
 
+/- warning: measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict -> MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (MeasureTheory.Measure.restrict.{u1} α m μ s) (MeasureTheory.Measure.restrict.{u1} α m ν s)) -> (MeasurableSet.{u1} α m s) -> (Eq.{1} ENNReal (coeFn.{succ u1, succ u1} (MeasureTheory.Measure.{u1} α m) (fun (_x : MeasureTheory.Measure.{u1} α m) => (Set.{u1} α) -> ENNReal) (MeasureTheory.Measure.instCoeFun.{u1} α m) (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν) s) (OfNat.ofNat.{0} ENNReal 0 (OfNat.mk.{0} ENNReal 0 (Zero.zero.{0} ENNReal ENNReal.hasZero))))
+but is expected to have type
+  forall {α : Type.{u1}} {m : MeasurableSpace.{u1} α} {μ : MeasureTheory.Measure.{u1} α m} {ν : MeasureTheory.Measure.{u1} α m} {s : Set.{u1} α}, (LE.le.{u1} (MeasureTheory.Measure.{u1} α m) (Preorder.toLE.{u1} (MeasureTheory.Measure.{u1} α m) (PartialOrder.toPreorder.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.instPartialOrder.{u1} α m))) (MeasureTheory.Measure.restrict.{u1} α m μ s) (MeasureTheory.Measure.restrict.{u1} α m ν s)) -> (MeasurableSet.{u1} α m s) -> (Eq.{1} ENNReal (MeasureTheory.OuterMeasure.measureOf.{u1} α (MeasureTheory.Measure.toOuterMeasure.{u1} α m (HSub.hSub.{u1, u1, u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.{u1} α m) (instHSub.{u1} (MeasureTheory.Measure.{u1} α m) (MeasureTheory.Measure.hasSub.{u1} α m)) μ ν)) s) (OfNat.ofNat.{0} ENNReal 0 (Zero.toOfNat0.{0} ENNReal instENNRealZero)))
+Case conversion may be inaccurate. Consider using '#align measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrictₓ'. -/
 theorem sub_apply_eq_zero_of_restrict_le_restrict (h_le : μ.restrict s ≤ ν.restrict s)
     (h_meas_s : MeasurableSet s) : (μ - ν) s = 0 := by
   rw [← restrict_apply_self, restrict_sub_eq_restrict_sub_restrict, sub_eq_zero_of_le] <;> simp [*]
 #align measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict
 
+#print MeasureTheory.Measure.finiteMeasure_sub /-
 instance finiteMeasure_sub [FiniteMeasure μ] : FiniteMeasure (μ - ν) :=
   finiteMeasureOfLe μ sub_le
 #align measure_theory.measure.is_finite_measure_sub MeasureTheory.Measure.finiteMeasure_sub
+-/
 
 end Measure

562bbf52

bump to nightly-2023-05-09-08

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

244524af

Diff

@@ -73,7 +73,7 @@ theorem sub_self : μ - μ = 0 :=
 
 /-- This application lemma only works in special circumstances. Given knowledge of
 when `μ ≤ ν` and `ν ≤ μ`, a more general application lemma can be written. -/
-theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ) : (μ - ν) s = μ s - ν s :=
+theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ) : (μ - ν) s = μ s - ν s :=
   by
   -- We begin by defining `measure_sub`, which will be equal to `(μ - ν)`.
   let measure_sub : Measure α :=
@@ -104,7 +104,7 @@ theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ 
     apply measure.of_measurable_apply _ h₁
 #align measure_theory.measure.sub_apply MeasureTheory.Measure.sub_apply
 
-theorem sub_add_cancel_of_le [IsFiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ :=
+theorem sub_add_cancel_of_le [FiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ :=
   by
   ext (s h_s_meas)
   rw [add_apply, sub_apply h_s_meas h₁, tsub_add_cancel_of_le (h₁ s h_s_meas)]
@@ -148,9 +148,9 @@ theorem sub_apply_eq_zero_of_restrict_le_restrict (h_le : μ.restrict s ≤ ν.r
   rw [← restrict_apply_self, restrict_sub_eq_restrict_sub_restrict, sub_eq_zero_of_le] <;> simp [*]
 #align measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict
 
-instance isFiniteMeasure_sub [IsFiniteMeasure μ] : IsFiniteMeasure (μ - ν) :=
-  isFiniteMeasure_of_le μ sub_le
-#align measure_theory.measure.is_finite_measure_sub MeasureTheory.Measure.isFiniteMeasure_sub
+instance finiteMeasure_sub [FiniteMeasure μ] : FiniteMeasure (μ - ν) :=
+  finiteMeasureOfLe μ sub_le
+#align measure_theory.measure.is_finite_measure_sub MeasureTheory.Measure.finiteMeasure_sub
 
 end Measure

562bbf52

bump to nightly-2023-05-04-10

mathlib commit https://github.com/leanprover-community/mathlib/commit/92c69b77c5a7dc0f7eeddb552508633305157caa

3d8894bd

Diff

@@ -148,9 +148,9 @@ theorem sub_apply_eq_zero_of_restrict_le_restrict (h_le : μ.restrict s ≤ ν.r
   rw [← restrict_apply_self, restrict_sub_eq_restrict_sub_restrict, sub_eq_zero_of_le] <;> simp [*]
 #align measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict
 
-instance isFiniteMeasureSub [IsFiniteMeasure μ] : IsFiniteMeasure (μ - ν) :=
-  isFiniteMeasureOfLe μ sub_le
-#align measure_theory.measure.is_finite_measure_sub MeasureTheory.Measure.isFiniteMeasureSub
+instance isFiniteMeasure_sub [IsFiniteMeasure μ] : IsFiniteMeasure (μ - ν) :=
+  isFiniteMeasure_of_le μ sub_le
+#align measure_theory.measure.is_finite_measure_sub MeasureTheory.Measure.isFiniteMeasure_sub
 
 end Measure

562bbf52

bump to nightly-2023-02-27-10

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

49ff026a

Diff

@@ -80,7 +80,7 @@ theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ 
     @MeasureTheory.Measure.ofMeasurable α _
       (fun (t : Set α) (h_t_measurable_set : MeasurableSet t) => μ t - ν t) (by simp)
       (by
-        intro g h_meas h_disj; simp only; rw [Ennreal.tsum_sub]
+        intro g h_meas h_disj; simp only; rw [ENNReal.tsum_sub]
         repeat' rw [← MeasureTheory.measure_unionᵢ h_disj h_meas]
         exacts[MeasureTheory.measure_ne_top _ _, fun i => h₂ _ (h_meas _)])
   -- Now, we demonstrate `μ - ν = measure_sub`, and apply it.

562bbf52

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

562bbf52

chore: adapt to multiple goal linter 1 (#12338)

A PR accompanying #12339.

Zulip discussion

45f93f3f

Diff

@@ -104,7 +104,7 @@ theorem sub_add_cancel_of_le [IsFiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν +
 
 theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
     (μ - ν).restrict s = μ.restrict s - ν.restrict s := by
-  repeat' rw [sub_def]
+  repeat rw [sub_def]
   have h_nonempty : { d | μ ≤ d + ν }.Nonempty := ⟨μ, Measure.le_add_right le_rfl⟩
   rw [restrict_sInf_eq_sInf_restrict h_nonempty h_meas_s]
   apply le_antisymm
@@ -115,7 +115,7 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
     refine' ⟨ν' + (⊤ : Measure α).restrict sᶜ, _, _⟩
     · rw [mem_setOf_eq, add_right_comm, Measure.le_iff]
       intro t h_meas_t
-      repeat' rw [← measure_inter_add_diff t h_meas_s]
+      repeat rw [← measure_inter_add_diff t h_meas_s]
       refine' add_le_add _ _
       · rw [add_apply, add_apply]
         apply le_add_right _

562bbf52

chore: Remove ball and bex from lemma names (#10816)

ball for "bounded forall" and bex for "bounded exists" are from experience very confusing abbreviations. This PR renames them to forall_mem and exists_mem in the few Set lemma names that mention them.

Also deprecate ball_image_of_ball, mem_image_elim, mem_image_elim_on since those lemmas are duplicates of the renamed lemmas (apart from argument order and implicitness, which I am also fixing by making the binder in the RHS of forall_mem_image semi-implicit), have obscure names and are completely unused.

c697e040

Diff

@@ -129,7 +129,7 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
     · ext1 t h_meas_t
       simp [restrict_apply h_meas_t, restrict_apply (h_meas_t.inter h_meas_s), inter_assoc]
   · refine' sInf_le_sInf_of_forall_exists_le _
-    refine' ball_image_iff.2 fun t h_t_in => ⟨t.restrict s, _, le_rfl⟩
+    refine' forall_mem_image.2 fun t h_t_in => ⟨t.restrict s, _, le_rfl⟩
     rw [Set.mem_setOf_eq, ← restrict_add]
     exact restrict_mono Subset.rfl h_t_in
 #align measure_theory.measure.restrict_sub_eq_restrict_sub_restrict MeasureTheory.Measure.restrict_sub_eq_restrict_sub_restrict

562bbf52

refactor(MeasureTheory): redefine ≤ on measures (#10714)

Redefine ≤ on MeasureTheory.Measure so that μ ≤ ν ↔ ∀ s, μ s ≤ ν s by definition instead of ∀ s, MeasurableSet s → μ s ≤ ν s.

Reasons

this way it is defeq to ≤ on outer measures;
if we decide to introduce an order on all DFunLike types and migrate measures to FunLike, then this is unavoidable;
the reasoning for the old definition was "it's slightly easier to prove μ ≤ ν this way"; the counter-argument is "it's slightly harder to apply μ ≤ ν this way".

Other changes

golf some proofs broken by this change;
add @[gcongr] tags to some ENNReal lemmas;
fix the name ENNReal.coe_lt_coe_of_le -> ENNReal.ENNReal.coe_lt_coe_of_lt;
drop an unneeded MeasurableSet assumption in set_lintegral_pdf_le_map

f17e2324

Diff

@@ -73,16 +73,17 @@ theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ 
   -- We begin by defining `measure_sub`, which will be equal to `(μ - ν)`.
   let measure_sub : Measure α := MeasureTheory.Measure.ofMeasurable
     (fun (t : Set α) (_ : MeasurableSet t) => μ t - ν t) (by simp)
-    (by
-      intro g h_meas h_disj; simp only; rw [ENNReal.tsum_sub]
-      repeat' rw [← MeasureTheory.measure_iUnion h_disj h_meas]
-      exacts [MeasureTheory.measure_ne_top _ _, fun i => h₂ _ (h_meas _)])
+    (fun g h_meas h_disj ↦ by
+      simp only [measure_iUnion h_disj h_meas]
+      rw [ENNReal.tsum_sub _ (h₂ <| g ·)]
+      rw [← measure_iUnion h_disj h_meas]
+      apply measure_ne_top)
   -- Now, we demonstrate `μ - ν = measure_sub`, and apply it.
   have h_measure_sub_add : ν + measure_sub = μ := by
     ext1 t h_t_measurable_set
     simp only [Pi.add_apply, coe_add]
     rw [MeasureTheory.Measure.ofMeasurable_apply _ h_t_measurable_set, add_comm,
-      tsub_add_cancel_of_le (h₂ t h_t_measurable_set)]
+      tsub_add_cancel_of_le (h₂ t)]
   have h_measure_sub_eq : μ - ν = measure_sub := by
     rw [MeasureTheory.Measure.sub_def]
     apply le_antisymm
@@ -98,7 +99,7 @@ theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ 
 
 theorem sub_add_cancel_of_le [IsFiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ := by
   ext1 s h_s_meas
-  rw [add_apply, sub_apply h_s_meas h₁, tsub_add_cancel_of_le (h₁ s h_s_meas)]
+  rw [add_apply, sub_apply h_s_meas h₁, tsub_add_cancel_of_le (h₁ s)]
 #align measure_theory.measure.sub_add_cancel_of_le MeasureTheory.Measure.sub_add_cancel_of_le
 
 theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
@@ -120,7 +121,7 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
         apply le_add_right _
         rw [← restrict_eq_self μ (inter_subset_right _ _),
           ← restrict_eq_self ν (inter_subset_right _ _)]
-        apply h_ν'_in _ (h_meas_t.inter h_meas_s)
+        apply h_ν'_in
       · rw [add_apply, restrict_apply (h_meas_t.diff h_meas_s), diff_eq, inter_assoc, inter_self,
           ← add_apply]
         have h_mu_le_add_top : μ ≤ ν' + ν + ⊤ := by simp only [add_top, le_top]

562bbf52

chore: split MeasureSpace.lean into 3 files (#8389)

The original file MeasureSpace.lean is a mess of 4580 lines, with a lot of changes of namespaces, active variables, and so on. We split it into three files:

MeasureSpace, with 2095 lines left (some stuff could still be moved to other files, but it already makes much more sense)
Restrict, with everything on restriction of measures (1100 lines)
Typeclasses, defining finite measures, sigma-finite measures, and so on (1443 lines)

The new files are still large, but less so. This is 99% moving around and ensuring that variables and namespaces remain the same (#align statements have been very useful for this), and 1% adding classical in proofs and [Decidable ...] assumptions in statements, as I haven't opened Classical in the new files.

5c9c13df

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2022 Martin Zinkevich. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Martin Zinkevich
 -/
-import Mathlib.MeasureTheory.Measure.MeasureSpace
+import Mathlib.MeasureTheory.Measure.Typeclasses
 
 #align_import measure_theory.measure.sub from "leanprover-community/mathlib"@"562bbf524c595c153470e53d36c57b6f891cc480"

562bbf52

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

@@ -30,11 +30,11 @@ Compare with `ENNReal.instSub`.
 Specifically, note that if you have `α = {1,2}`, and `μ {1} = 2`, `μ {2} = 0`, and
 `ν {2} = 2`, `ν {1} = 0`, then `(μ - ν) {1, 2} = 2`. However, if `μ ≤ ν`, and
 `ν univ ≠ ∞`, then `(μ - ν) + ν = μ`. -/
-noncomputable instance instSub {α : Type _} [MeasurableSpace α] : Sub (Measure α) :=
+noncomputable instance instSub {α : Type*} [MeasurableSpace α] : Sub (Measure α) :=
   ⟨fun μ ν => sInf { τ | μ ≤ τ + ν }⟩
 #align measure_theory.measure.has_sub MeasureTheory.Measure.instSub
 
-variable {α : Type _} {m : MeasurableSpace α} {μ ν : Measure α} {s : Set α}
+variable {α : Type*} {m : MeasurableSpace α} {μ ν : Measure α} {s : Set α}
 
 theorem sub_def : μ - ν = sInf { d | μ ≤ d + ν } := rfl
 #align measure_theory.measure.sub_def MeasureTheory.Measure.sub_def

562bbf52

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) 2022 Martin Zinkevich. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Martin Zinkevich
-
-! This file was ported from Lean 3 source module measure_theory.measure.sub
-! leanprover-community/mathlib commit 562bbf524c595c153470e53d36c57b6f891cc480
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.MeasureTheory.Measure.MeasureSpace
 
+#align_import measure_theory.measure.sub from "leanprover-community/mathlib"@"562bbf524c595c153470e53d36c57b6f891cc480"
+
 /-!
 # Subtraction of measures

562bbf52

fix: change compl precedence (#5586)

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

4d4f0f25

Diff

@@ -114,7 +114,7 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
     intro ν' h_ν'_in
     rw [mem_setOf_eq] at h_ν'_in
     refine' ⟨ν'.restrict s, _, restrict_le_self⟩
-    refine' ⟨ν' + (⊤ : Measure α).restrict (sᶜ), _, _⟩
+    refine' ⟨ν' + (⊤ : Measure α).restrict sᶜ, _, _⟩
     · rw [mem_setOf_eq, add_right_comm, Measure.le_iff]
       intro t h_meas_t
       repeat' rw [← measure_inter_add_diff t h_meas_s]

562bbf52

style: recover Is of Foo which is ported from is_foo (#4639)

I have misported is_foo to Foo because I misunderstood the rule for IsLawfulFoo. This PR recover Is of Foo which is ported from is_foo. This PR also renames some misported theorems.

0b92c7b7

Diff

@@ -71,7 +71,7 @@ theorem sub_self : μ - μ = 0 :=
 
 /-- This application lemma only works in special circumstances. Given knowledge of
 when `μ ≤ ν` and `ν ≤ μ`, a more general application lemma can be written. -/
-theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ) :
+theorem sub_apply [IsFiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ) :
     (μ - ν) s = μ s - ν s := by
   -- We begin by defining `measure_sub`, which will be equal to `(μ - ν)`.
   let measure_sub : Measure α := MeasureTheory.Measure.ofMeasurable
@@ -99,7 +99,7 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
   apply Measure.ofMeasurable_apply _ h₁
 #align measure_theory.measure.sub_apply MeasureTheory.Measure.sub_apply
 
-theorem sub_add_cancel_of_le [FiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ := by
+theorem sub_add_cancel_of_le [IsFiniteMeasure ν] (h₁ : ν ≤ μ) : μ - ν + ν = μ := by
   ext1 s h_s_meas
   rw [add_apply, sub_apply h_s_meas h₁, tsub_add_cancel_of_le (h₁ s h_s_meas)]
 #align measure_theory.measure.sub_add_cancel_of_le MeasureTheory.Measure.sub_add_cancel_of_le
@@ -141,9 +141,9 @@ theorem sub_apply_eq_zero_of_restrict_le_restrict (h_le : μ.restrict s ≤ ν.r
   rw [← restrict_apply_self, restrict_sub_eq_restrict_sub_restrict, sub_eq_zero_of_le] <;> simp [*]
 #align measure_theory.measure.sub_apply_eq_zero_of_restrict_le_restrict MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict
 
-instance finiteMeasure_sub [FiniteMeasure μ] : FiniteMeasure (μ - ν) :=
-  finiteMeasureOfLe μ sub_le
-#align measure_theory.measure.is_finite_measure_sub MeasureTheory.Measure.finiteMeasure_sub
+instance isFiniteMeasure_sub [IsFiniteMeasure μ] : IsFiniteMeasure (μ - ν) :=
+  isFiniteMeasure_of_le μ sub_le
+#align measure_theory.measure.is_finite_measure_sub MeasureTheory.Measure.isFiniteMeasure_sub
 
 end Measure

562bbf52

chore: tidy various files (#3996)

9ec7de3c

Diff

@@ -15,13 +15,12 @@ import Mathlib.MeasureTheory.Measure.MeasureSpace
 
 In this file we define `μ - ν` to be the least measure `τ` such that `μ ≤ τ + ν`.
 It is the equivalent of `(μ - ν) ⊔ 0` if `μ` and `ν` were signed measures.
-Compare with `ENNReal.hasSub`.
+Compare with `ENNReal.instSub`.
 Specifically, note that if you have `α = {1,2}`, and `μ {1} = 2`, `μ {2} = 0`, and
 `ν {2} = 2`, `ν {1} = 0`, then `(μ - ν) {1, 2} = 2`. However, if `μ ≤ ν`, and
 `ν univ ≠ ∞`, then `(μ - ν) + ν = μ`.
 -/
 
-
 open Set
 
 namespace MeasureTheory
@@ -30,13 +29,13 @@ namespace Measure
 
 /-- The measure `μ - ν` is defined to be the least measure `τ` such that `μ ≤ τ + ν`.
 It is the equivalent of `(μ - ν) ⊔ 0` if `μ` and `ν` were signed measures.
-Compare with `ENNReal.hasSub`.
+Compare with `ENNReal.instSub`.
 Specifically, note that if you have `α = {1,2}`, and `μ {1} = 2`, `μ {2} = 0`, and
 `ν {2} = 2`, `ν {1} = 0`, then `(μ - ν) {1, 2} = 2`. However, if `μ ≤ ν`, and
 `ν univ ≠ ∞`, then `(μ - ν) + ν = μ`. -/
-noncomputable instance hasSub {α : Type _} [MeasurableSpace α] : Sub (Measure α) :=
+noncomputable instance instSub {α : Type _} [MeasurableSpace α] : Sub (Measure α) :=
   ⟨fun μ ν => sInf { τ | μ ≤ τ + ν }⟩
-#align measure_theory.measure.has_sub MeasureTheory.Measure.hasSub
+#align measure_theory.measure.has_sub MeasureTheory.Measure.instSub
 
 variable {α : Type _} {m : MeasurableSpace α} {μ ν : Measure α} {s : Set α}
 
@@ -90,9 +89,9 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
   have h_measure_sub_eq : μ - ν = measure_sub := by
     rw [MeasureTheory.Measure.sub_def]
     apply le_antisymm
-    · apply @sInf_le (Measure α) Measure.instCompleteSemilatticeInf
+    · apply sInf_le
       simp [le_refl, add_comm, h_measure_sub_add]
-    apply @le_sInf (Measure α) Measure.instCompleteSemilatticeInf
+    apply le_sInf
     intro d h_d
     rw [← h_measure_sub_add, mem_setOf_eq, add_comm d] at h_d
     apply Measure.le_of_add_le_add_left h_d

562bbf52

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

@@ -35,16 +35,16 @@ Specifically, note that if you have `α = {1,2}`, and `μ {1} = 2`, `μ {2} = 0`
 `ν {2} = 2`, `ν {1} = 0`, then `(μ - ν) {1, 2} = 2`. However, if `μ ≤ ν`, and
 `ν univ ≠ ∞`, then `(μ - ν) + ν = μ`. -/
 noncomputable instance hasSub {α : Type _} [MeasurableSpace α] : Sub (Measure α) :=
-  ⟨fun μ ν => infₛ { τ | μ ≤ τ + ν }⟩
+  ⟨fun μ ν => sInf { τ | μ ≤ τ + ν }⟩
 #align measure_theory.measure.has_sub MeasureTheory.Measure.hasSub
 
 variable {α : Type _} {m : MeasurableSpace α} {μ ν : Measure α} {s : Set α}
 
-theorem sub_def : μ - ν = infₛ { d | μ ≤ d + ν } := rfl
+theorem sub_def : μ - ν = sInf { d | μ ≤ d + ν } := rfl
 #align measure_theory.measure.sub_def MeasureTheory.Measure.sub_def
 
 theorem sub_le_of_le_add {d} (h : μ ≤ d + ν) : μ - ν ≤ d :=
-  infₛ_le h
+  sInf_le h
 #align measure_theory.measure.sub_le_of_le_add MeasureTheory.Measure.sub_le_of_le_add
 
 theorem sub_eq_zero_of_le (h : μ ≤ ν) : μ - ν = 0 :=
@@ -79,7 +79,7 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
     (fun (t : Set α) (_ : MeasurableSet t) => μ t - ν t) (by simp)
     (by
       intro g h_meas h_disj; simp only; rw [ENNReal.tsum_sub]
-      repeat' rw [← MeasureTheory.measure_unionᵢ h_disj h_meas]
+      repeat' rw [← MeasureTheory.measure_iUnion h_disj h_meas]
       exacts [MeasureTheory.measure_ne_top _ _, fun i => h₂ _ (h_meas _)])
   -- Now, we demonstrate `μ - ν = measure_sub`, and apply it.
   have h_measure_sub_add : ν + measure_sub = μ := by
@@ -90,9 +90,9 @@ theorem sub_apply [FiniteMeasure ν] (h₁ : MeasurableSet s) (h₂ : ν ≤ μ)
   have h_measure_sub_eq : μ - ν = measure_sub := by
     rw [MeasureTheory.Measure.sub_def]
     apply le_antisymm
-    · apply @infₛ_le (Measure α) Measure.instCompleteSemilatticeInf
+    · apply @sInf_le (Measure α) Measure.instCompleteSemilatticeInf
       simp [le_refl, add_comm, h_measure_sub_add]
-    apply @le_infₛ (Measure α) Measure.instCompleteSemilatticeInf
+    apply @le_sInf (Measure α) Measure.instCompleteSemilatticeInf
     intro d h_d
     rw [← h_measure_sub_add, mem_setOf_eq, add_comm d] at h_d
     apply Measure.le_of_add_le_add_left h_d
@@ -109,9 +109,9 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
     (μ - ν).restrict s = μ.restrict s - ν.restrict s := by
   repeat' rw [sub_def]
   have h_nonempty : { d | μ ≤ d + ν }.Nonempty := ⟨μ, Measure.le_add_right le_rfl⟩
-  rw [restrict_infₛ_eq_infₛ_restrict h_nonempty h_meas_s]
+  rw [restrict_sInf_eq_sInf_restrict h_nonempty h_meas_s]
   apply le_antisymm
-  · refine' infₛ_le_infₛ_of_forall_exists_le _
+  · refine' sInf_le_sInf_of_forall_exists_le _
     intro ν' h_ν'_in
     rw [mem_setOf_eq] at h_ν'_in
     refine' ⟨ν'.restrict s, _, restrict_le_self⟩
@@ -131,7 +131,7 @@ theorem restrict_sub_eq_restrict_sub_restrict (h_meas_s : MeasurableSet s) :
         exact Measure.le_iff'.1 h_mu_le_add_top _
     · ext1 t h_meas_t
       simp [restrict_apply h_meas_t, restrict_apply (h_meas_t.inter h_meas_s), inter_assoc]
-  · refine' infₛ_le_infₛ_of_forall_exists_le _
+  · refine' sInf_le_sInf_of_forall_exists_le _
     refine' ball_image_iff.2 fun t h_t_in => ⟨t.restrict s, _, le_rfl⟩
     rw [Set.mem_setOf_eq, ← restrict_add]
     exact restrict_mono Subset.rfl h_t_in

562bbf52

feat: port MeasureTheory.Measure.Sub (#3866)

d4ad63cd

`measure_theory.measure.sub` ⟷ `Mathlib.MeasureTheory.Measure.Sub`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Reasons

Other changes

Renames

Dependencies 10 + 609

measure_theory.measure.sub ⟷ Mathlib.MeasureTheory.Measure.Sub

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Reasons

Other changes

Renames

Dependencies 10 + 609

`measure_theory.measure.sub` ⟷ `Mathlib.MeasureTheory.Measure.Sub`