topology.bornology.constructions | 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

e3d9ab8f

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

a11f9106

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -159,7 +159,7 @@ theorem isBounded_pi : IsBounded (pi univ S) ↔ (∃ i, S i = ∅) ∨ ∀ i, I
   by_cases hne : ∃ i, S i = ∅
   · simp [hne, univ_pi_eq_empty_iff.2 hne]
   · simp only [hne, false_or_iff]
-    simp only [not_exists, ← Ne.def, ← nonempty_iff_ne_empty, ← univ_pi_nonempty_iff] at hne 
+    simp only [not_exists, ← Ne.def, ← nonempty_iff_ne_empty, ← univ_pi_nonempty_iff] at hne
     exact is_bounded_pi_of_nonempty hne
 #align bornology.is_bounded_pi Bornology.isBounded_pi
 -/

a11f9106

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 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 -/
-import Mathbin.Topology.Bornology.Basic
+import Topology.Bornology.Basic
 
 #align_import topology.bornology.constructions from "leanprover-community/mathlib"@"a11f9106a169dd302a285019e5165f8ab32ff433"

a11f9106

bump to nightly-2023-08-23-23

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

f612b9e0

Diff

@@ -217,10 +217,10 @@ theorem boundedSpace_val_set_iff {s : Set α} : BoundedSpace s ↔ IsBounded s :
 #align bounded_space_coe_set_iff boundedSpace_val_set_iff
 -/
 
-alias boundedSpace_subtype_iff ↔ _ Bornology.IsBounded.boundedSpace_subtype
+alias ⟨_, Bornology.IsBounded.boundedSpace_subtype⟩ := boundedSpace_subtype_iff
 #align bornology.is_bounded.bounded_space_subtype Bornology.IsBounded.boundedSpace_subtype
 
-alias boundedSpace_val_set_iff ↔ _ Bornology.IsBounded.boundedSpace_val
+alias ⟨_, Bornology.IsBounded.boundedSpace_val⟩ := boundedSpace_val_set_iff
 #align bornology.is_bounded.bounded_space_coe Bornology.IsBounded.boundedSpace_val
 
 instance [BoundedSpace α] {p : α → Prop} : BoundedSpace (Subtype p) :=

a11f9106

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 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
-
-! This file was ported from Lean 3 source module topology.bornology.constructions
-! leanprover-community/mathlib commit a11f9106a169dd302a285019e5165f8ab32ff433
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Topology.Bornology.Basic
 
+#align_import topology.bornology.constructions from "leanprover-community/mathlib"@"a11f9106a169dd302a285019e5165f8ab32ff433"
+
 /-!
 # Bornology structure on products and subtypes

a11f9106

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -60,9 +60,11 @@ namespace Bornology
 -/
 
 
+#print Bornology.cobounded_prod /-
 theorem cobounded_prod : cobounded (α × β) = (cobounded α).coprod (cobounded β) :=
   rfl
 #align bornology.cobounded_prod Bornology.cobounded_prod
+-/
 
 #print Bornology.isBounded_image_fst_and_snd /-
 theorem isBounded_image_fst_and_snd {s : Set (α × β)} :
@@ -74,35 +76,45 @@ theorem isBounded_image_fst_and_snd {s : Set (α × β)} :
 variable {s : Set α} {t : Set β} {S : ∀ i, Set (π i)}
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Bornology.IsBounded.fst_of_prod /-
 theorem IsBounded.fst_of_prod (h : IsBounded (s ×ˢ t)) (ht : t.Nonempty) : IsBounded s :=
   fst_image_prod s ht ▸ (isBounded_image_fst_and_snd.2 h).1
 #align bornology.is_bounded.fst_of_prod Bornology.IsBounded.fst_of_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Bornology.IsBounded.snd_of_prod /-
 theorem IsBounded.snd_of_prod (h : IsBounded (s ×ˢ t)) (hs : s.Nonempty) : IsBounded t :=
   snd_image_prod hs t ▸ (isBounded_image_fst_and_snd.2 h).2
 #align bornology.is_bounded.snd_of_prod Bornology.IsBounded.snd_of_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Bornology.IsBounded.prod /-
 theorem IsBounded.prod (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s ×ˢ t) :=
   isBounded_image_fst_and_snd.1
     ⟨hs.Subset <| fst_image_prod_subset _ _, ht.Subset <| snd_image_prod_subset _ _⟩
 #align bornology.is_bounded.prod Bornology.IsBounded.prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Bornology.isBounded_prod_of_nonempty /-
 theorem isBounded_prod_of_nonempty (hne : Set.Nonempty (s ×ˢ t)) :
     IsBounded (s ×ˢ t) ↔ IsBounded s ∧ IsBounded t :=
   ⟨fun h => ⟨h.fst_of_prod hne.snd, h.snd_of_prod hne.fst⟩, fun h => h.1.Prod h.2⟩
 #align bornology.is_bounded_prod_of_nonempty Bornology.isBounded_prod_of_nonempty
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Bornology.isBounded_prod /-
 theorem isBounded_prod : IsBounded (s ×ˢ t) ↔ s = ∅ ∨ t = ∅ ∨ IsBounded s ∧ IsBounded t :=
   by
   rcases s.eq_empty_or_nonempty with (rfl | hs); · simp
   rcases t.eq_empty_or_nonempty with (rfl | ht); · simp
   simp only [hs.ne_empty, ht.ne_empty, is_bounded_prod_of_nonempty (hs.prod ht), false_or_iff]
 #align bornology.is_bounded_prod Bornology.isBounded_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Bornology.isBounded_prod_self /-
@@ -118,14 +130,18 @@ theorem isBounded_prod_self : IsBounded (s ×ˢ s) ↔ IsBounded s :=
 -/
 
 
+#print Bornology.cobounded_pi /-
 theorem cobounded_pi : cobounded (∀ i, π i) = Filter.coprodᵢ fun i => cobounded (π i) :=
   rfl
 #align bornology.cobounded_pi Bornology.cobounded_pi
+-/
 
+#print Bornology.forall_isBounded_image_eval_iff /-
 theorem forall_isBounded_image_eval_iff {s : Set (∀ i, π i)} :
     (∀ i, IsBounded (eval i '' s)) ↔ IsBounded s :=
   compl_mem_coprodᵢ.symm
 #align bornology.forall_is_bounded_image_eval_iff Bornology.forall_isBounded_image_eval_iff
+-/
 
 #print Bornology.IsBounded.pi /-
 theorem IsBounded.pi (h : ∀ i, IsBounded (S i)) : IsBounded (pi univ S) :=
@@ -133,10 +149,12 @@ theorem IsBounded.pi (h : ∀ i, IsBounded (S i)) : IsBounded (pi univ S) :=
 #align bornology.is_bounded.pi Bornology.IsBounded.pi
 -/
 
+#print Bornology.isBounded_pi_of_nonempty /-
 theorem isBounded_pi_of_nonempty (hne : (pi univ S).Nonempty) :
     IsBounded (pi univ S) ↔ ∀ i, IsBounded (S i) :=
   ⟨fun H i => @eval_image_univ_pi _ _ _ i hne ▸ forall_isBounded_image_eval_iff.2 H i, IsBounded.pi⟩
 #align bornology.is_bounded_pi_of_nonempty Bornology.isBounded_pi_of_nonempty
+-/
 
 #print Bornology.isBounded_pi /-
 theorem isBounded_pi : IsBounded (pi univ S) ↔ (∃ i, S i = ∅) ∨ ∀ i, IsBounded (S i) :=
@@ -154,10 +172,12 @@ theorem isBounded_pi : IsBounded (pi univ S) ↔ (∃ i, S i = ∅) ∨ ∀ i, I
 -/
 
 
+#print Bornology.isBounded_induced /-
 theorem isBounded_induced {α β : Type _} [Bornology β] {f : α → β} {s : Set α} :
     @IsBounded α (Bornology.induced f) s ↔ IsBounded (f '' s) :=
   compl_mem_comap
 #align bornology.is_bounded_induced Bornology.isBounded_induced
+-/
 
 #print Bornology.isBounded_image_subtype_val /-
 theorem isBounded_image_subtype_val {p : α → Prop} {s : Set { x // p x }} :
@@ -181,10 +201,12 @@ instance [BoundedSpace α] [BoundedSpace β] : BoundedSpace (α × β) := by
 instance [∀ i, BoundedSpace (π i)] : BoundedSpace (∀ i, π i) := by
   simp [← cobounded_eq_bot_iff, cobounded_pi]
 
+#print boundedSpace_induced_iff /-
 theorem boundedSpace_induced_iff {α β : Type _} [Bornology β] {f : α → β} :
     @BoundedSpace α (Bornology.induced f) ↔ IsBounded (range f) := by
   rw [← is_bounded_univ, is_bounded_induced, image_univ]
 #align bounded_space_induced_iff boundedSpace_induced_iff
+-/
 
 #print boundedSpace_subtype_iff /-
 theorem boundedSpace_subtype_iff {p : α → Prop} : BoundedSpace (Subtype p) ↔ IsBounded {x | p x} :=

a11f9106

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -187,9 +187,8 @@ theorem boundedSpace_induced_iff {α β : Type _} [Bornology β] {f : α → β}
 #align bounded_space_induced_iff boundedSpace_induced_iff
 
 #print boundedSpace_subtype_iff /-
-theorem boundedSpace_subtype_iff {p : α → Prop} :
-    BoundedSpace (Subtype p) ↔ IsBounded { x | p x } := by
-  rw [boundedSpace_induced_iff, Subtype.range_coe_subtype]
+theorem boundedSpace_subtype_iff {p : α → Prop} : BoundedSpace (Subtype p) ↔ IsBounded {x | p x} :=
+  by rw [boundedSpace_induced_iff, Subtype.range_coe_subtype]
 #align bounded_space_subtype_iff boundedSpace_subtype_iff
 -/
 
@@ -206,7 +205,7 @@ alias boundedSpace_val_set_iff ↔ _ Bornology.IsBounded.boundedSpace_val
 #align bornology.is_bounded.bounded_space_coe Bornology.IsBounded.boundedSpace_val
 
 instance [BoundedSpace α] {p : α → Prop} : BoundedSpace (Subtype p) :=
-  (IsBounded.all { x | p x }).boundedSpace_subtype
+  (IsBounded.all {x | p x}).boundedSpace_subtype
 
 /-!
 ### `additive`, `multiplicative`

a11f9106

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -144,7 +144,7 @@ theorem isBounded_pi : IsBounded (pi univ S) ↔ (∃ i, S i = ∅) ∨ ∀ i, I
   by_cases hne : ∃ i, S i = ∅
   · simp [hne, univ_pi_eq_empty_iff.2 hne]
   · simp only [hne, false_or_iff]
-    simp only [not_exists, ← Ne.def, ← nonempty_iff_ne_empty, ← univ_pi_nonempty_iff] at hne
+    simp only [not_exists, ← Ne.def, ← nonempty_iff_ne_empty, ← univ_pi_nonempty_iff] at hne 
     exact is_bounded_pi_of_nonempty hne
 #align bornology.is_bounded_pi Bornology.isBounded_pi
 -/

a11f9106

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -24,7 +24,7 @@ on these types.
 
 open Set Filter Bornology Function
 
-open Filter
+open scoped Filter
 
 variable {α β ι : Type _} {π : ι → Type _} [Fintype ι] [Bornology α] [Bornology β]
   [∀ i, Bornology (π i)]

a11f9106

bump to nightly-2023-05-28-16

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

b51961d2

Diff

@@ -74,18 +74,14 @@ theorem isBounded_image_fst_and_snd {s : Set (α × β)} :
 variable {s : Set α} {t : Set β} {S : ∀ i, Set (π i)}
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print Bornology.IsBounded.fst_of_prod /-
 theorem IsBounded.fst_of_prod (h : IsBounded (s ×ˢ t)) (ht : t.Nonempty) : IsBounded s :=
   fst_image_prod s ht ▸ (isBounded_image_fst_and_snd.2 h).1
 #align bornology.is_bounded.fst_of_prod Bornology.IsBounded.fst_of_prod
--/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print Bornology.IsBounded.snd_of_prod /-
 theorem IsBounded.snd_of_prod (h : IsBounded (s ×ˢ t)) (hs : s.Nonempty) : IsBounded t :=
   snd_image_prod hs t ▸ (isBounded_image_fst_and_snd.2 h).2
 #align bornology.is_bounded.snd_of_prod Bornology.IsBounded.snd_of_prod
--/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem IsBounded.prod (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s ×ˢ t) :=
@@ -95,22 +91,18 @@ theorem IsBounded.prod (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s ×ˢ
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print Bornology.isBounded_prod_of_nonempty /-
 theorem isBounded_prod_of_nonempty (hne : Set.Nonempty (s ×ˢ t)) :
     IsBounded (s ×ˢ t) ↔ IsBounded s ∧ IsBounded t :=
   ⟨fun h => ⟨h.fst_of_prod hne.snd, h.snd_of_prod hne.fst⟩, fun h => h.1.Prod h.2⟩
 #align bornology.is_bounded_prod_of_nonempty Bornology.isBounded_prod_of_nonempty
--/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print Bornology.isBounded_prod /-
 theorem isBounded_prod : IsBounded (s ×ˢ t) ↔ s = ∅ ∨ t = ∅ ∨ IsBounded s ∧ IsBounded t :=
   by
   rcases s.eq_empty_or_nonempty with (rfl | hs); · simp
   rcases t.eq_empty_or_nonempty with (rfl | ht); · simp
   simp only [hs.ne_empty, ht.ne_empty, is_bounded_prod_of_nonempty (hs.prod ht), false_or_iff]
 #align bornology.is_bounded_prod Bornology.isBounded_prod
--/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Bornology.isBounded_prod_self /-

a11f9106

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -60,12 +60,6 @@ namespace Bornology
 -/
 
 
-/- warning: bornology.cobounded_prod -> Bornology.cobounded_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β], Eq.{succ (max u1 u2)} (Filter.{max u1 u2} (Prod.{u1, u2} α β)) (Bornology.cobounded.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instBornology.{u1, u2} α β _inst_2 _inst_3)) (Filter.coprod.{u1, u2} α β (Bornology.cobounded.{u1} α _inst_2) (Bornology.cobounded.{u2} β _inst_3))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_2 : Bornology.{u2} α] [_inst_3 : Bornology.{u1} β], Eq.{max (succ u2) (succ u1)} (Filter.{max u1 u2} (Prod.{u2, u1} α β)) (Bornology.cobounded.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instBornology.{u2, u1} α β _inst_2 _inst_3)) (Filter.coprod.{u2, u1} α β (Bornology.cobounded.{u2} α _inst_2) (Bornology.cobounded.{u1} β _inst_3))
-Case conversion may be inaccurate. Consider using '#align bornology.cobounded_prod Bornology.cobounded_prodₓ'. -/
 theorem cobounded_prod : cobounded (α × β) = (cobounded α).coprod (cobounded β) :=
   rfl
 #align bornology.cobounded_prod Bornology.cobounded_prod
@@ -93,12 +87,6 @@ theorem IsBounded.snd_of_prod (h : IsBounded (s ×ˢ t)) (hs : s.Nonempty) : IsB
 #align bornology.is_bounded.snd_of_prod Bornology.IsBounded.snd_of_prod
 -/
 
-/- warning: bornology.is_bounded.prod -> Bornology.IsBounded.prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β] {s : Set.{u1} α} {t : Set.{u2} β}, (Bornology.IsBounded.{u1} α _inst_2 s) -> (Bornology.IsBounded.{u2} β _inst_3 t) -> (Bornology.IsBounded.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instBornology.{u1, u2} α β _inst_2 _inst_3) (Set.prod.{u1, u2} α β s t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_2 : Bornology.{u2} α] [_inst_3 : Bornology.{u1} β] {s : Set.{u2} α} {t : Set.{u1} β}, (Bornology.IsBounded.{u2} α _inst_2 s) -> (Bornology.IsBounded.{u1} β _inst_3 t) -> (Bornology.IsBounded.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instBornology.{u2, u1} α β _inst_2 _inst_3) (Set.prod.{u2, u1} α β s t))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded.prod Bornology.IsBounded.prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem IsBounded.prod (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s ×ˢ t) :=
   isBounded_image_fst_and_snd.1
@@ -138,22 +126,10 @@ theorem isBounded_prod_self : IsBounded (s ×ˢ s) ↔ IsBounded s :=
 -/
 
 
-/- warning: bornology.cobounded_pi -> Bornology.cobounded_pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_4 : forall (i : ι), Bornology.{u2} (π i)], Eq.{succ (max u1 u2)} (Filter.{max u1 u2} (forall (i : ι), π i)) (Bornology.cobounded.{max u1 u2} (forall (i : ι), π i) (Pi.instBornology.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i))) (Filter.coprodᵢ.{u1, u2} ι (fun (i : ι) => π i) (fun (i : ι) => Bornology.cobounded.{u2} (π i) (_inst_4 i)))
-but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_4 : forall (i : ι), Bornology.{u1} (π i)], Eq.{max (succ u2) (succ u1)} (Filter.{max u2 u1} (forall (i : ι), π i)) (Bornology.cobounded.{max u2 u1} (forall (i : ι), π i) (Pi.instBornology.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i))) (Filter.coprodᵢ.{u2, u1} ι (fun (i : ι) => π i) (fun (i : ι) => Bornology.cobounded.{u1} (π i) (_inst_4 i)))
-Case conversion may be inaccurate. Consider using '#align bornology.cobounded_pi Bornology.cobounded_piₓ'. -/
 theorem cobounded_pi : cobounded (∀ i, π i) = Filter.coprodᵢ fun i => cobounded (π i) :=
   rfl
 #align bornology.cobounded_pi Bornology.cobounded_pi
 
-/- warning: bornology.forall_is_bounded_image_eval_iff -> Bornology.forall_isBounded_image_eval_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_4 : forall (i : ι), Bornology.{u2} (π i)] {s : Set.{max u1 u2} (forall (i : ι), π i)}, Iff (forall (i : ι), Bornology.IsBounded.{u2} (π i) (_inst_4 i) (Set.image.{max u1 u2, u2} (forall (x : ι), π x) (π i) (Function.eval.{succ u1, succ u2} ι (fun (i : ι) => π i) i) s)) (Bornology.IsBounded.{max u1 u2} (forall (i : ι), π i) (Pi.instBornology.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) s)
-but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_4 : forall (i : ι), Bornology.{u1} (π i)] {s : Set.{max u2 u1} (forall (i : ι), π i)}, Iff (forall (i : ι), Bornology.IsBounded.{u1} (π i) (_inst_4 i) (Set.image.{max u2 u1, u1} (forall (x : ι), π x) (π i) (Function.eval.{succ u2, succ u1} ι (fun (i : ι) => π i) i) s)) (Bornology.IsBounded.{max u2 u1} (forall (i : ι), π i) (Pi.instBornology.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) s)
-Case conversion may be inaccurate. Consider using '#align bornology.forall_is_bounded_image_eval_iff Bornology.forall_isBounded_image_eval_iffₓ'. -/
 theorem forall_isBounded_image_eval_iff {s : Set (∀ i, π i)} :
     (∀ i, IsBounded (eval i '' s)) ↔ IsBounded s :=
   compl_mem_coprodᵢ.symm
@@ -165,12 +141,6 @@ theorem IsBounded.pi (h : ∀ i, IsBounded (S i)) : IsBounded (pi univ S) :=
 #align bornology.is_bounded.pi Bornology.IsBounded.pi
 -/
 
-/- warning: bornology.is_bounded_pi_of_nonempty -> Bornology.isBounded_pi_of_nonempty is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_4 : forall (i : ι), Bornology.{u2} (π i)] {S : forall (i : ι), Set.{u2} (π i)}, (Set.Nonempty.{max u1 u2} (forall (i : ι), π i) (Set.pi.{u1, u2} ι (fun (i : ι) => π i) (Set.univ.{u1} ι) S)) -> (Iff (Bornology.IsBounded.{max u1 u2} (forall (i : ι), π i) (Pi.instBornology.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) (Set.pi.{u1, u2} ι (fun (i : ι) => π i) (Set.univ.{u1} ι) S)) (forall (i : ι), Bornology.IsBounded.{u2} (π i) (_inst_4 i) (S i)))
-but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_4 : forall (i : ι), Bornology.{u1} (π i)] {S : forall (i : ι), Set.{u1} (π i)}, (Set.Nonempty.{max u2 u1} (forall (i : ι), π i) (Set.pi.{u2, u1} ι (fun (i : ι) => π i) (Set.univ.{u2} ι) S)) -> (Iff (Bornology.IsBounded.{max u1 u2} (forall (i : ι), π i) (Pi.instBornology.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) (Set.pi.{u2, u1} ι (fun (i : ι) => π i) (Set.univ.{u2} ι) S)) (forall (i : ι), Bornology.IsBounded.{u1} (π i) (_inst_4 i) (S i)))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_pi_of_nonempty Bornology.isBounded_pi_of_nonemptyₓ'. -/
 theorem isBounded_pi_of_nonempty (hne : (pi univ S).Nonempty) :
     IsBounded (pi univ S) ↔ ∀ i, IsBounded (S i) :=
   ⟨fun H i => @eval_image_univ_pi _ _ _ i hne ▸ forall_isBounded_image_eval_iff.2 H i, IsBounded.pi⟩
@@ -192,12 +162,6 @@ theorem isBounded_pi : IsBounded (pi univ S) ↔ (∃ i, S i = ∅) ∨ ∀ i, I
 -/
 
 
-/- warning: bornology.is_bounded_induced -> Bornology.isBounded_induced is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_5 : Bornology.{u2} β] {f : α -> β} {s : Set.{u1} α}, Iff (Bornology.IsBounded.{u1} α (Bornology.induced.{u1, u2} α β _inst_5 f) s) (Bornology.IsBounded.{u2} β _inst_5 (Set.image.{u1, u2} α β f s))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_5 : Bornology.{u1} β] {f : α -> β} {s : Set.{u2} α}, Iff (Bornology.IsBounded.{u2} α (Bornology.induced.{u2, u1} α β _inst_5 f) s) (Bornology.IsBounded.{u1} β _inst_5 (Set.image.{u2, u1} α β f s))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_induced Bornology.isBounded_inducedₓ'. -/
 theorem isBounded_induced {α β : Type _} [Bornology β] {f : α → β} {s : Set α} :
     @IsBounded α (Bornology.induced f) s ↔ IsBounded (f '' s) :=
   compl_mem_comap
@@ -225,12 +189,6 @@ instance [BoundedSpace α] [BoundedSpace β] : BoundedSpace (α × β) := by
 instance [∀ i, BoundedSpace (π i)] : BoundedSpace (∀ i, π i) := by
   simp [← cobounded_eq_bot_iff, cobounded_pi]
 
-/- warning: bounded_space_induced_iff -> boundedSpace_induced_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_5 : Bornology.{u2} β] {f : α -> β}, Iff (BoundedSpace.{u1} α (Bornology.induced.{u1, u2} α β _inst_5 f)) (Bornology.IsBounded.{u2} β _inst_5 (Set.range.{u2, succ u1} β α f))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_5 : Bornology.{u1} β] {f : α -> β}, Iff (BoundedSpace.{u2} α (Bornology.induced.{u2, u1} α β _inst_5 f)) (Bornology.IsBounded.{u1} β _inst_5 (Set.range.{u1, succ u2} β α f))
-Case conversion may be inaccurate. Consider using '#align bounded_space_induced_iff boundedSpace_induced_iffₓ'. -/
 theorem boundedSpace_induced_iff {α β : Type _} [Bornology β] {f : α → β} :
     @BoundedSpace α (Bornology.induced f) ↔ IsBounded (range f) := by
   rw [← is_bounded_univ, is_bounded_induced, image_univ]

a11f9106

bump to nightly-2023-05-28-03

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

6c6011cf

Diff

@@ -62,54 +62,42 @@ namespace Bornology
 
 /- warning: bornology.cobounded_prod -> Bornology.cobounded_prod is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β], Eq.{succ (max u1 u2)} (Filter.{max u1 u2} (Prod.{u1, u2} α β)) (Bornology.cobounded.{max u1 u2} (Prod.{u1, u2} α β) (Prod.bornology.{u1, u2} α β _inst_2 _inst_3)) (Filter.coprod.{u1, u2} α β (Bornology.cobounded.{u1} α _inst_2) (Bornology.cobounded.{u2} β _inst_3))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β], Eq.{succ (max u1 u2)} (Filter.{max u1 u2} (Prod.{u1, u2} α β)) (Bornology.cobounded.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instBornology.{u1, u2} α β _inst_2 _inst_3)) (Filter.coprod.{u1, u2} α β (Bornology.cobounded.{u1} α _inst_2) (Bornology.cobounded.{u2} β _inst_3))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_2 : Bornology.{u2} α] [_inst_3 : Bornology.{u1} β], Eq.{max (succ u2) (succ u1)} (Filter.{max u1 u2} (Prod.{u2, u1} α β)) (Bornology.cobounded.{max u1 u2} (Prod.{u2, u1} α β) (instBornologyProd.{u2, u1} α β _inst_2 _inst_3)) (Filter.coprod.{u2, u1} α β (Bornology.cobounded.{u2} α _inst_2) (Bornology.cobounded.{u1} β _inst_3))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_2 : Bornology.{u2} α] [_inst_3 : Bornology.{u1} β], Eq.{max (succ u2) (succ u1)} (Filter.{max u1 u2} (Prod.{u2, u1} α β)) (Bornology.cobounded.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instBornology.{u2, u1} α β _inst_2 _inst_3)) (Filter.coprod.{u2, u1} α β (Bornology.cobounded.{u2} α _inst_2) (Bornology.cobounded.{u1} β _inst_3))
 Case conversion may be inaccurate. Consider using '#align bornology.cobounded_prod Bornology.cobounded_prodₓ'. -/
 theorem cobounded_prod : cobounded (α × β) = (cobounded α).coprod (cobounded β) :=
   rfl
 #align bornology.cobounded_prod Bornology.cobounded_prod
 
-/- warning: bornology.is_bounded_image_fst_and_snd -> Bornology.isBounded_image_fst_and_snd is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β] {s : Set.{max u1 u2} (Prod.{u1, u2} α β)}, Iff (And (Bornology.IsBounded.{u1} α _inst_2 (Set.image.{max u1 u2, u1} (Prod.{u1, u2} α β) α (Prod.fst.{u1, u2} α β) s)) (Bornology.IsBounded.{u2} β _inst_3 (Set.image.{max u1 u2, u2} (Prod.{u1, u2} α β) β (Prod.snd.{u1, u2} α β) s))) (Bornology.IsBounded.{max u1 u2} (Prod.{u1, u2} α β) (Prod.bornology.{u1, u2} α β _inst_2 _inst_3) s)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β] {s : Set.{max u2 u1} (Prod.{u1, u2} α β)}, Iff (And (Bornology.IsBounded.{u1} α _inst_2 (Set.image.{max u2 u1, u1} (Prod.{u1, u2} α β) α (Prod.fst.{u1, u2} α β) s)) (Bornology.IsBounded.{u2} β _inst_3 (Set.image.{max u2 u1, u2} (Prod.{u1, u2} α β) β (Prod.snd.{u1, u2} α β) s))) (Bornology.IsBounded.{max u1 u2} (Prod.{u1, u2} α β) (instBornologyProd.{u1, u2} α β _inst_2 _inst_3) s)
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_image_fst_and_snd Bornology.isBounded_image_fst_and_sndₓ'. -/
+#print Bornology.isBounded_image_fst_and_snd /-
 theorem isBounded_image_fst_and_snd {s : Set (α × β)} :
     IsBounded (Prod.fst '' s) ∧ IsBounded (Prod.snd '' s) ↔ IsBounded s :=
   compl_mem_coprod.symm
 #align bornology.is_bounded_image_fst_and_snd Bornology.isBounded_image_fst_and_snd
+-/
 
 variable {s : Set α} {t : Set β} {S : ∀ i, Set (π i)}
 
-/- warning: bornology.is_bounded.fst_of_prod -> Bornology.IsBounded.fst_of_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β] {s : Set.{u1} α} {t : Set.{u2} β}, (Bornology.IsBounded.{max u1 u2} (Prod.{u1, u2} α β) (Prod.bornology.{u1, u2} α β _inst_2 _inst_3) (Set.prod.{u1, u2} α β s t)) -> (Set.Nonempty.{u2} β t) -> (Bornology.IsBounded.{u1} α _inst_2 s)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β] {s : Set.{u1} α} {t : Set.{u2} β}, (Bornology.IsBounded.{max u2 u1} (Prod.{u1, u2} α β) (instBornologyProd.{u1, u2} α β _inst_2 _inst_3) (Set.prod.{u1, u2} α β s t)) -> (Set.Nonempty.{u2} β t) -> (Bornology.IsBounded.{u1} α _inst_2 s)
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded.fst_of_prod Bornology.IsBounded.fst_of_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Bornology.IsBounded.fst_of_prod /-
 theorem IsBounded.fst_of_prod (h : IsBounded (s ×ˢ t)) (ht : t.Nonempty) : IsBounded s :=
   fst_image_prod s ht ▸ (isBounded_image_fst_and_snd.2 h).1
 #align bornology.is_bounded.fst_of_prod Bornology.IsBounded.fst_of_prod
+-/
 
-/- warning: bornology.is_bounded.snd_of_prod -> Bornology.IsBounded.snd_of_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β] {s : Set.{u1} α} {t : Set.{u2} β}, (Bornology.IsBounded.{max u1 u2} (Prod.{u1, u2} α β) (Prod.bornology.{u1, u2} α β _inst_2 _inst_3) (Set.prod.{u1, u2} α β s t)) -> (Set.Nonempty.{u1} α s) -> (Bornology.IsBounded.{u2} β _inst_3 t)
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β] {s : Set.{u1} α} {t : Set.{u2} β}, (Bornology.IsBounded.{max u2 u1} (Prod.{u1, u2} α β) (instBornologyProd.{u1, u2} α β _inst_2 _inst_3) (Set.prod.{u1, u2} α β s t)) -> (Set.Nonempty.{u1} α s) -> (Bornology.IsBounded.{u2} β _inst_3 t)
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded.snd_of_prod Bornology.IsBounded.snd_of_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Bornology.IsBounded.snd_of_prod /-
 theorem IsBounded.snd_of_prod (h : IsBounded (s ×ˢ t)) (hs : s.Nonempty) : IsBounded t :=
   snd_image_prod hs t ▸ (isBounded_image_fst_and_snd.2 h).2
 #align bornology.is_bounded.snd_of_prod Bornology.IsBounded.snd_of_prod
+-/
 
 /- warning: bornology.is_bounded.prod -> Bornology.IsBounded.prod is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β] {s : Set.{u1} α} {t : Set.{u2} β}, (Bornology.IsBounded.{u1} α _inst_2 s) -> (Bornology.IsBounded.{u2} β _inst_3 t) -> (Bornology.IsBounded.{max u1 u2} (Prod.{u1, u2} α β) (Prod.bornology.{u1, u2} α β _inst_2 _inst_3) (Set.prod.{u1, u2} α β s t))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β] {s : Set.{u1} α} {t : Set.{u2} β}, (Bornology.IsBounded.{u1} α _inst_2 s) -> (Bornology.IsBounded.{u2} β _inst_3 t) -> (Bornology.IsBounded.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instBornology.{u1, u2} α β _inst_2 _inst_3) (Set.prod.{u1, u2} α β s t))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_2 : Bornology.{u2} α] [_inst_3 : Bornology.{u1} β] {s : Set.{u2} α} {t : Set.{u1} β}, (Bornology.IsBounded.{u2} α _inst_2 s) -> (Bornology.IsBounded.{u1} β _inst_3 t) -> (Bornology.IsBounded.{max u1 u2} (Prod.{u2, u1} α β) (instBornologyProd.{u2, u1} α β _inst_2 _inst_3) (Set.prod.{u2, u1} α β s t))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_2 : Bornology.{u2} α] [_inst_3 : Bornology.{u1} β] {s : Set.{u2} α} {t : Set.{u1} β}, (Bornology.IsBounded.{u2} α _inst_2 s) -> (Bornology.IsBounded.{u1} β _inst_3 t) -> (Bornology.IsBounded.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instBornology.{u2, u1} α β _inst_2 _inst_3) (Set.prod.{u2, u1} α β s t))
 Case conversion may be inaccurate. Consider using '#align bornology.is_bounded.prod Bornology.IsBounded.prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem IsBounded.prod (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s ×ˢ t) :=
@@ -117,45 +105,33 @@ theorem IsBounded.prod (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s ×ˢ
     ⟨hs.Subset <| fst_image_prod_subset _ _, ht.Subset <| snd_image_prod_subset _ _⟩
 #align bornology.is_bounded.prod Bornology.IsBounded.prod
 
-/- warning: bornology.is_bounded_prod_of_nonempty -> Bornology.isBounded_prod_of_nonempty is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β] {s : Set.{u1} α} {t : Set.{u2} β}, (Set.Nonempty.{max u1 u2} (Prod.{u1, u2} α β) (Set.prod.{u1, u2} α β s t)) -> (Iff (Bornology.IsBounded.{max u1 u2} (Prod.{u1, u2} α β) (Prod.bornology.{u1, u2} α β _inst_2 _inst_3) (Set.prod.{u1, u2} α β s t)) (And (Bornology.IsBounded.{u1} α _inst_2 s) (Bornology.IsBounded.{u2} β _inst_3 t)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β] {s : Set.{u1} α} {t : Set.{u2} β}, (Set.Nonempty.{max u2 u1} (Prod.{u1, u2} α β) (Set.prod.{u1, u2} α β s t)) -> (Iff (Bornology.IsBounded.{max u2 u1} (Prod.{u1, u2} α β) (instBornologyProd.{u1, u2} α β _inst_2 _inst_3) (Set.prod.{u1, u2} α β s t)) (And (Bornology.IsBounded.{u1} α _inst_2 s) (Bornology.IsBounded.{u2} β _inst_3 t)))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_prod_of_nonempty Bornology.isBounded_prod_of_nonemptyₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Bornology.isBounded_prod_of_nonempty /-
 theorem isBounded_prod_of_nonempty (hne : Set.Nonempty (s ×ˢ t)) :
     IsBounded (s ×ˢ t) ↔ IsBounded s ∧ IsBounded t :=
   ⟨fun h => ⟨h.fst_of_prod hne.snd, h.snd_of_prod hne.fst⟩, fun h => h.1.Prod h.2⟩
 #align bornology.is_bounded_prod_of_nonempty Bornology.isBounded_prod_of_nonempty
+-/
 
-/- warning: bornology.is_bounded_prod -> Bornology.isBounded_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β] {s : Set.{u1} α} {t : Set.{u2} β}, Iff (Bornology.IsBounded.{max u1 u2} (Prod.{u1, u2} α β) (Prod.bornology.{u1, u2} α β _inst_2 _inst_3) (Set.prod.{u1, u2} α β s t)) (Or (Eq.{succ u1} (Set.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α))) (Or (Eq.{succ u2} (Set.{u2} β) t (EmptyCollection.emptyCollection.{u2} (Set.{u2} β) (Set.hasEmptyc.{u2} β))) (And (Bornology.IsBounded.{u1} α _inst_2 s) (Bornology.IsBounded.{u2} β _inst_3 t))))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_2 : Bornology.{u1} α] [_inst_3 : Bornology.{u2} β] {s : Set.{u1} α} {t : Set.{u2} β}, Iff (Bornology.IsBounded.{max u2 u1} (Prod.{u1, u2} α β) (instBornologyProd.{u1, u2} α β _inst_2 _inst_3) (Set.prod.{u1, u2} α β s t)) (Or (Eq.{succ u1} (Set.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α))) (Or (Eq.{succ u2} (Set.{u2} β) t (EmptyCollection.emptyCollection.{u2} (Set.{u2} β) (Set.instEmptyCollectionSet.{u2} β))) (And (Bornology.IsBounded.{u1} α _inst_2 s) (Bornology.IsBounded.{u2} β _inst_3 t))))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_prod Bornology.isBounded_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Bornology.isBounded_prod /-
 theorem isBounded_prod : IsBounded (s ×ˢ t) ↔ s = ∅ ∨ t = ∅ ∨ IsBounded s ∧ IsBounded t :=
   by
   rcases s.eq_empty_or_nonempty with (rfl | hs); · simp
   rcases t.eq_empty_or_nonempty with (rfl | ht); · simp
   simp only [hs.ne_empty, ht.ne_empty, is_bounded_prod_of_nonempty (hs.prod ht), false_or_iff]
 #align bornology.is_bounded_prod Bornology.isBounded_prod
+-/
 
-/- warning: bornology.is_bounded_prod_self -> Bornology.isBounded_prod_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_2 : Bornology.{u1} α] {s : Set.{u1} α}, Iff (Bornology.IsBounded.{u1} (Prod.{u1, u1} α α) (Prod.bornology.{u1, u1} α α _inst_2 _inst_2) (Set.prod.{u1, u1} α α s s)) (Bornology.IsBounded.{u1} α _inst_2 s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_2 : Bornology.{u1} α] {s : Set.{u1} α}, Iff (Bornology.IsBounded.{u1} (Prod.{u1, u1} α α) (instBornologyProd.{u1, u1} α α _inst_2 _inst_2) (Set.prod.{u1, u1} α α s s)) (Bornology.IsBounded.{u1} α _inst_2 s)
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_prod_self Bornology.isBounded_prod_selfₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Bornology.isBounded_prod_self /-
 theorem isBounded_prod_self : IsBounded (s ×ˢ s) ↔ IsBounded s :=
   by
   rcases s.eq_empty_or_nonempty with (rfl | hs); · simp
   exact (is_bounded_prod_of_nonempty (hs.prod hs)).trans (and_self_iff _)
 #align bornology.is_bounded_prod_self Bornology.isBounded_prod_self
+-/
 
 /-!
 ### Bounded sets in `Π i, π i`
@@ -164,9 +140,9 @@ theorem isBounded_prod_self : IsBounded (s ×ˢ s) ↔ IsBounded s :=
 
 /- warning: bornology.cobounded_pi -> Bornology.cobounded_pi is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_4 : forall (i : ι), Bornology.{u2} (π i)], Eq.{succ (max u1 u2)} (Filter.{max u1 u2} (forall (i : ι), π i)) (Bornology.cobounded.{max u1 u2} (forall (i : ι), π i) (Pi.bornology.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i))) (Filter.coprodᵢ.{u1, u2} ι (fun (i : ι) => π i) (fun (i : ι) => Bornology.cobounded.{u2} (π i) (_inst_4 i)))
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_4 : forall (i : ι), Bornology.{u2} (π i)], Eq.{succ (max u1 u2)} (Filter.{max u1 u2} (forall (i : ι), π i)) (Bornology.cobounded.{max u1 u2} (forall (i : ι), π i) (Pi.instBornology.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i))) (Filter.coprodᵢ.{u1, u2} ι (fun (i : ι) => π i) (fun (i : ι) => Bornology.cobounded.{u2} (π i) (_inst_4 i)))
 but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_4 : forall (i : ι), Bornology.{u1} (π i)], Eq.{max (succ u2) (succ u1)} (Filter.{max u2 u1} (forall (i : ι), π i)) (Bornology.cobounded.{max u2 u1} (forall (i : ι), π i) (instBornologyForAll.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i))) (Filter.coprodᵢ.{u2, u1} ι (fun (i : ι) => π i) (fun (i : ι) => Bornology.cobounded.{u1} (π i) (_inst_4 i)))
+  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_4 : forall (i : ι), Bornology.{u1} (π i)], Eq.{max (succ u2) (succ u1)} (Filter.{max u2 u1} (forall (i : ι), π i)) (Bornology.cobounded.{max u2 u1} (forall (i : ι), π i) (Pi.instBornology.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i))) (Filter.coprodᵢ.{u2, u1} ι (fun (i : ι) => π i) (fun (i : ι) => Bornology.cobounded.{u1} (π i) (_inst_4 i)))
 Case conversion may be inaccurate. Consider using '#align bornology.cobounded_pi Bornology.cobounded_piₓ'. -/
 theorem cobounded_pi : cobounded (∀ i, π i) = Filter.coprodᵢ fun i => cobounded (π i) :=
   rfl
@@ -174,42 +150,33 @@ theorem cobounded_pi : cobounded (∀ i, π i) = Filter.coprodᵢ fun i => cobou
 
 /- warning: bornology.forall_is_bounded_image_eval_iff -> Bornology.forall_isBounded_image_eval_iff is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_4 : forall (i : ι), Bornology.{u2} (π i)] {s : Set.{max u1 u2} (forall (i : ι), π i)}, Iff (forall (i : ι), Bornology.IsBounded.{u2} (π i) (_inst_4 i) (Set.image.{max u1 u2, u2} (forall (x : ι), π x) (π i) (Function.eval.{succ u1, succ u2} ι (fun (i : ι) => π i) i) s)) (Bornology.IsBounded.{max u1 u2} (forall (i : ι), π i) (Pi.bornology.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) s)
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_4 : forall (i : ι), Bornology.{u2} (π i)] {s : Set.{max u1 u2} (forall (i : ι), π i)}, Iff (forall (i : ι), Bornology.IsBounded.{u2} (π i) (_inst_4 i) (Set.image.{max u1 u2, u2} (forall (x : ι), π x) (π i) (Function.eval.{succ u1, succ u2} ι (fun (i : ι) => π i) i) s)) (Bornology.IsBounded.{max u1 u2} (forall (i : ι), π i) (Pi.instBornology.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) s)
 but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_4 : forall (i : ι), Bornology.{u1} (π i)] {s : Set.{max u2 u1} (forall (i : ι), π i)}, Iff (forall (i : ι), Bornology.IsBounded.{u1} (π i) (_inst_4 i) (Set.image.{max u2 u1, u1} (forall (x : ι), π x) (π i) (Function.eval.{succ u2, succ u1} ι (fun (i : ι) => π i) i) s)) (Bornology.IsBounded.{max u2 u1} (forall (i : ι), π i) (instBornologyForAll.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) s)
+  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_4 : forall (i : ι), Bornology.{u1} (π i)] {s : Set.{max u2 u1} (forall (i : ι), π i)}, Iff (forall (i : ι), Bornology.IsBounded.{u1} (π i) (_inst_4 i) (Set.image.{max u2 u1, u1} (forall (x : ι), π x) (π i) (Function.eval.{succ u2, succ u1} ι (fun (i : ι) => π i) i) s)) (Bornology.IsBounded.{max u2 u1} (forall (i : ι), π i) (Pi.instBornology.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) s)
 Case conversion may be inaccurate. Consider using '#align bornology.forall_is_bounded_image_eval_iff Bornology.forall_isBounded_image_eval_iffₓ'. -/
 theorem forall_isBounded_image_eval_iff {s : Set (∀ i, π i)} :
     (∀ i, IsBounded (eval i '' s)) ↔ IsBounded s :=
   compl_mem_coprodᵢ.symm
 #align bornology.forall_is_bounded_image_eval_iff Bornology.forall_isBounded_image_eval_iff
 
-/- warning: bornology.is_bounded.pi -> Bornology.IsBounded.pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_4 : forall (i : ι), Bornology.{u2} (π i)] {S : forall (i : ι), Set.{u2} (π i)}, (forall (i : ι), Bornology.IsBounded.{u2} (π i) (_inst_4 i) (S i)) -> (Bornology.IsBounded.{max u1 u2} (forall (i : ι), π i) (Pi.bornology.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) (Set.pi.{u1, u2} ι (fun (i : ι) => π i) (Set.univ.{u1} ι) S))
-but is expected to have type
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_4 : forall (i : ι), Bornology.{u2} (π i)] {S : forall (i : ι), Set.{u2} (π i)}, (forall (i : ι), Bornology.IsBounded.{u2} (π i) (_inst_4 i) (S i)) -> (Bornology.IsBounded.{max u2 u1} (forall (i : ι), π i) (instBornologyForAll.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) (Set.pi.{u1, u2} ι (fun (i : ι) => π i) (Set.univ.{u1} ι) S))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded.pi Bornology.IsBounded.piₓ'. -/
+#print Bornology.IsBounded.pi /-
 theorem IsBounded.pi (h : ∀ i, IsBounded (S i)) : IsBounded (pi univ S) :=
   forall_isBounded_image_eval_iff.1 fun i => (h i).Subset eval_image_univ_pi_subset
 #align bornology.is_bounded.pi Bornology.IsBounded.pi
+-/
 
 /- warning: bornology.is_bounded_pi_of_nonempty -> Bornology.isBounded_pi_of_nonempty is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_4 : forall (i : ι), Bornology.{u2} (π i)] {S : forall (i : ι), Set.{u2} (π i)}, (Set.Nonempty.{max u1 u2} (forall (i : ι), π i) (Set.pi.{u1, u2} ι (fun (i : ι) => π i) (Set.univ.{u1} ι) S)) -> (Iff (Bornology.IsBounded.{max u1 u2} (forall (i : ι), π i) (Pi.bornology.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) (Set.pi.{u1, u2} ι (fun (i : ι) => π i) (Set.univ.{u1} ι) S)) (forall (i : ι), Bornology.IsBounded.{u2} (π i) (_inst_4 i) (S i)))
+  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_4 : forall (i : ι), Bornology.{u2} (π i)] {S : forall (i : ι), Set.{u2} (π i)}, (Set.Nonempty.{max u1 u2} (forall (i : ι), π i) (Set.pi.{u1, u2} ι (fun (i : ι) => π i) (Set.univ.{u1} ι) S)) -> (Iff (Bornology.IsBounded.{max u1 u2} (forall (i : ι), π i) (Pi.instBornology.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) (Set.pi.{u1, u2} ι (fun (i : ι) => π i) (Set.univ.{u1} ι) S)) (forall (i : ι), Bornology.IsBounded.{u2} (π i) (_inst_4 i) (S i)))
 but is expected to have type
-  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_4 : forall (i : ι), Bornology.{u1} (π i)] {S : forall (i : ι), Set.{u1} (π i)}, (Set.Nonempty.{max u2 u1} (forall (i : ι), π i) (Set.pi.{u2, u1} ι (fun (i : ι) => π i) (Set.univ.{u2} ι) S)) -> (Iff (Bornology.IsBounded.{max u1 u2} (forall (i : ι), π i) (instBornologyForAll.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) (Set.pi.{u2, u1} ι (fun (i : ι) => π i) (Set.univ.{u2} ι) S)) (forall (i : ι), Bornology.IsBounded.{u1} (π i) (_inst_4 i) (S i)))
+  forall {ι : Type.{u2}} {π : ι -> Type.{u1}} [_inst_1 : Fintype.{u2} ι] [_inst_4 : forall (i : ι), Bornology.{u1} (π i)] {S : forall (i : ι), Set.{u1} (π i)}, (Set.Nonempty.{max u2 u1} (forall (i : ι), π i) (Set.pi.{u2, u1} ι (fun (i : ι) => π i) (Set.univ.{u2} ι) S)) -> (Iff (Bornology.IsBounded.{max u1 u2} (forall (i : ι), π i) (Pi.instBornology.{u2, u1} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) (Set.pi.{u2, u1} ι (fun (i : ι) => π i) (Set.univ.{u2} ι) S)) (forall (i : ι), Bornology.IsBounded.{u1} (π i) (_inst_4 i) (S i)))
 Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_pi_of_nonempty Bornology.isBounded_pi_of_nonemptyₓ'. -/
 theorem isBounded_pi_of_nonempty (hne : (pi univ S).Nonempty) :
     IsBounded (pi univ S) ↔ ∀ i, IsBounded (S i) :=
   ⟨fun H i => @eval_image_univ_pi _ _ _ i hne ▸ forall_isBounded_image_eval_iff.2 H i, IsBounded.pi⟩
 #align bornology.is_bounded_pi_of_nonempty Bornology.isBounded_pi_of_nonempty
 
-/- warning: bornology.is_bounded_pi -> Bornology.isBounded_pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_4 : forall (i : ι), Bornology.{u2} (π i)] {S : forall (i : ι), Set.{u2} (π i)}, Iff (Bornology.IsBounded.{max u1 u2} (forall (i : ι), π i) (Pi.bornology.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) (Set.pi.{u1, u2} ι (fun (i : ι) => π i) (Set.univ.{u1} ι) S)) (Or (Exists.{succ u1} ι (fun (i : ι) => Eq.{succ u2} (Set.{u2} (π i)) (S i) (EmptyCollection.emptyCollection.{u2} (Set.{u2} (π i)) (Set.hasEmptyc.{u2} (π i))))) (forall (i : ι), Bornology.IsBounded.{u2} (π i) (_inst_4 i) (S i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {π : ι -> Type.{u2}} [_inst_1 : Fintype.{u1} ι] [_inst_4 : forall (i : ι), Bornology.{u2} (π i)] {S : forall (i : ι), Set.{u2} (π i)}, Iff (Bornology.IsBounded.{max u2 u1} (forall (i : ι), π i) (instBornologyForAll.{u1, u2} ι (fun (i : ι) => π i) _inst_1 (fun (i : ι) => _inst_4 i)) (Set.pi.{u1, u2} ι (fun (i : ι) => π i) (Set.univ.{u1} ι) S)) (Or (Exists.{succ u1} ι (fun (i : ι) => Eq.{succ u2} (Set.{u2} (π i)) (S i) (EmptyCollection.emptyCollection.{u2} (Set.{u2} (π i)) (Set.instEmptyCollectionSet.{u2} (π i))))) (forall (i : ι), Bornology.IsBounded.{u2} (π i) (_inst_4 i) (S i)))
-Case conversion may be inaccurate. Consider using '#align bornology.is_bounded_pi Bornology.isBounded_piₓ'. -/
+#print Bornology.isBounded_pi /-
 theorem isBounded_pi : IsBounded (pi univ S) ↔ (∃ i, S i = ∅) ∨ ∀ i, IsBounded (S i) :=
   by
   by_cases hne : ∃ i, S i = ∅
@@ -218,6 +185,7 @@ theorem isBounded_pi : IsBounded (pi univ S) ↔ (∃ i, S i = ∅) ∨ ∀ i, I
     simp only [not_exists, ← Ne.def, ← nonempty_iff_ne_empty, ← univ_pi_nonempty_iff] at hne
     exact is_bounded_pi_of_nonempty hne
 #align bornology.is_bounded_pi Bornology.isBounded_pi
+-/
 
 /-!
 ### Bounded sets in `{x // p x}`

a11f9106

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

e3d9ab8f

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

converts "--porting note" into "-- Porting note";
converts "porting note" into "Porting note".

8be0b69c

Diff

@@ -165,7 +165,7 @@ instance [∀ i, BoundedSpace (π i)] : BoundedSpace (∀ i, π i) := by
 theorem boundedSpace_induced_iff {α β : Type*} [Bornology β] {f : α → β} :
     @BoundedSpace α (Bornology.induced f) ↔ IsBounded (range f) := by
   rw [← @isBounded_univ _ (Bornology.induced f), isBounded_induced, image_univ]
--- porting note: had to explicitly provided the bornology to `isBounded_univ`.
+-- Porting note: had to explicitly provided the bornology to `isBounded_univ`.
 #align bounded_space_induced_iff boundedSpace_induced_iff
 
 theorem boundedSpace_subtype_iff {p : α → Prop} :

e3d9ab8f

feat(Bornology/Constructions): drop [Finite ι] assumption (#10582)

38c547ff

Diff

@@ -20,7 +20,7 @@ open Set Filter Bornology Function
 
 open Filter
 
-variable {α β ι : Type*} {π : ι → Type*} [Finite ι] [Bornology α] [Bornology β]
+variable {α β ι : Type*} {π : ι → Type*} [Bornology α] [Bornology β]
   [∀ i, Bornology (π i)]
 
 instance Prod.instBornology : Bornology (α × β) where
@@ -31,13 +31,12 @@ instance Prod.instBornology : Bornology (α × β) where
 
 instance Pi.instBornology : Bornology (∀ i, π i) where
   cobounded' := Filter.coprodᵢ fun i => cobounded (π i)
-  le_cofinite' := @coprodᵢ_cofinite ι π _ ▸ Filter.coprodᵢ_mono fun _ => Bornology.le_cofinite _
+  le_cofinite' := iSup_le fun _ ↦ (comap_mono (Bornology.le_cofinite _)).trans (comap_cofinite_le _)
 #align pi.bornology Pi.instBornology
 
 /-- Inverse image of a bornology. -/
 @[reducible]
-def Bornology.induced {α β : Type*} [Bornology β] (f : α → β) : Bornology α
-    where
+def Bornology.induced {α β : Type*} [Bornology β] (f : α → β) : Bornology α where
   cobounded' := comap f (cobounded β)
   le_cofinite' := (comap_mono (Bornology.le_cofinite β)).trans (comap_cofinite_le _)
 #align bornology.induced Bornology.induced

e3d9ab8f

chore(Topology): Fintype -> Finite (#10262)

fbee97e1

Diff

@@ -20,7 +20,7 @@ open Set Filter Bornology Function
 
 open Filter
 
-variable {α β ι : Type*} {π : ι → Type*} [Fintype ι] [Bornology α] [Bornology β]
+variable {α β ι : Type*} {π : ι → Type*} [Finite ι] [Bornology α] [Bornology β]
   [∀ i, Bornology (π i)]
 
 instance Prod.instBornology : Bornology (α × β) where

e3d9ab8f

feat(Topology/Bornology): add convenience lemmas (#8640)

Add Bornology.IsBounded.image_fst, Bornology.IsBounded.image_snd, and Bornology.IsBounded.image_eval.

04c2181e

Diff

@@ -61,14 +61,20 @@ theorem isBounded_image_fst_and_snd {s : Set (α × β)} :
   compl_mem_coprod.symm
 #align bornology.is_bounded_image_fst_and_snd Bornology.isBounded_image_fst_and_snd
 
+lemma IsBounded.image_fst {s : Set (α × β)} (hs : IsBounded s) : IsBounded (Prod.fst '' s) :=
+  (isBounded_image_fst_and_snd.2 hs).1
+
+lemma IsBounded.image_snd {s : Set (α × β)} (hs : IsBounded s) : IsBounded (Prod.snd '' s) :=
+  (isBounded_image_fst_and_snd.2 hs).2
+
 variable {s : Set α} {t : Set β} {S : ∀ i, Set (π i)}
 
 theorem IsBounded.fst_of_prod (h : IsBounded (s ×ˢ t)) (ht : t.Nonempty) : IsBounded s :=
-  fst_image_prod s ht ▸ (isBounded_image_fst_and_snd.2 h).1
+  fst_image_prod s ht ▸ h.image_fst
 #align bornology.is_bounded.fst_of_prod Bornology.IsBounded.fst_of_prod
 
 theorem IsBounded.snd_of_prod (h : IsBounded (s ×ˢ t)) (hs : s.Nonempty) : IsBounded t :=
-  snd_image_prod hs t ▸ (isBounded_image_fst_and_snd.2 h).2
+  snd_image_prod hs t ▸ h.image_snd
 #align bornology.is_bounded.snd_of_prod Bornology.IsBounded.snd_of_prod
 
 theorem IsBounded.prod (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s ×ˢ t) :=
@@ -106,6 +112,10 @@ theorem forall_isBounded_image_eval_iff {s : Set (∀ i, π i)} :
   compl_mem_coprodᵢ.symm
 #align bornology.forall_is_bounded_image_eval_iff Bornology.forall_isBounded_image_eval_iff
 
+lemma IsBounded.image_eval {s : Set (∀ i, π i)} (hs : IsBounded s) (i : ι) :
+    IsBounded (eval i '' s) :=
+  forall_isBounded_image_eval_iff.2 hs i
+
 theorem IsBounded.pi (h : ∀ i, IsBounded (S i)) : IsBounded (pi univ S) :=
   forall_isBounded_image_eval_iff.1 fun i => (h i).subset eval_image_univ_pi_subset
 #align bornology.is_bounded.pi Bornology.IsBounded.pi

e3d9ab8f

chore: bump Std to Std#340 (#8104)

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

92e16069

Diff

@@ -89,7 +89,7 @@ theorem isBounded_prod : IsBounded (s ×ˢ t) ↔ s = ∅ ∨ t = ∅ ∨ IsBoun
 
 theorem isBounded_prod_self : IsBounded (s ×ˢ s) ↔ IsBounded s := by
   rcases s.eq_empty_or_nonempty with (rfl | hs); · simp
-  exact (isBounded_prod_of_nonempty (hs.prod hs)).trans (and_self_iff _)
+  exact (isBounded_prod_of_nonempty (hs.prod hs)).trans and_self_iff
 #align bornology.is_bounded_prod_self Bornology.isBounded_prod_self
 
 /-!

e3d9ab8f

feat: patch for new alias command (#6172)

19e0ba92

Diff

@@ -168,10 +168,10 @@ theorem boundedSpace_val_set_iff {s : Set α} : BoundedSpace s ↔ IsBounded s :
   boundedSpace_subtype_iff
 #align bounded_space_coe_set_iff boundedSpace_val_set_iff
 
-alias boundedSpace_subtype_iff ↔ _ Bornology.IsBounded.boundedSpace_subtype
+alias ⟨_, Bornology.IsBounded.boundedSpace_subtype⟩ := boundedSpace_subtype_iff
 #align bornology.is_bounded.bounded_space_subtype Bornology.IsBounded.boundedSpace_subtype
 
-alias boundedSpace_val_set_iff ↔ _ Bornology.IsBounded.boundedSpace_val
+alias ⟨_, Bornology.IsBounded.boundedSpace_val⟩ := boundedSpace_val_set_iff
 #align bornology.is_bounded.bounded_space_coe Bornology.IsBounded.boundedSpace_val
 
 instance [BoundedSpace α] {p : α → Prop} : BoundedSpace (Subtype p) :=

e3d9ab8f

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

@@ -20,7 +20,7 @@ open Set Filter Bornology Function
 
 open Filter
 
-variable {α β ι : Type _} {π : ι → Type _} [Fintype ι] [Bornology α] [Bornology β]
+variable {α β ι : Type*} {π : ι → Type*} [Fintype ι] [Bornology α] [Bornology β]
   [∀ i, Bornology (π i)]
 
 instance Prod.instBornology : Bornology (α × β) where
@@ -36,7 +36,7 @@ instance Pi.instBornology : Bornology (∀ i, π i) where
 
 /-- Inverse image of a bornology. -/
 @[reducible]
-def Bornology.induced {α β : Type _} [Bornology β] (f : α → β) : Bornology α
+def Bornology.induced {α β : Type*} [Bornology β] (f : α → β) : Bornology α
     where
   cobounded' := comap f (cobounded β)
   le_cofinite' := (comap_mono (Bornology.le_cofinite β)).trans (comap_cofinite_le _)
@@ -128,7 +128,7 @@ theorem isBounded_pi : IsBounded (pi univ S) ↔ (∃ i, S i = ∅) ∨ ∀ i, I
 -/
 
 
-theorem isBounded_induced {α β : Type _} [Bornology β] {f : α → β} {s : Set α} :
+theorem isBounded_induced {α β : Type*} [Bornology β] {f : α → β} {s : Set α} :
     @IsBounded α (Bornology.induced f) s ↔ IsBounded (f '' s) :=
   compl_mem_comap
 #align bornology.is_bounded_induced Bornology.isBounded_induced
@@ -153,7 +153,7 @@ instance [BoundedSpace α] [BoundedSpace β] : BoundedSpace (α × β) := by
 instance [∀ i, BoundedSpace (π i)] : BoundedSpace (∀ i, π i) := by
   simp [← cobounded_eq_bot_iff, cobounded_pi]
 
-theorem boundedSpace_induced_iff {α β : Type _} [Bornology β] {f : α → β} :
+theorem boundedSpace_induced_iff {α β : Type*} [Bornology β] {f : α → β} :
     @BoundedSpace α (Bornology.induced f) ↔ IsBounded (range f) := by
   rw [← @isBounded_univ _ (Bornology.induced f), isBounded_induced, image_univ]
 -- porting note: had to explicitly provided the bornology to `isBounded_univ`.

e3d9ab8f

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 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
-
-! This file was ported from Lean 3 source module topology.bornology.constructions
-! leanprover-community/mathlib commit e3d9ab8faa9dea8f78155c6c27d62a621f4c152d
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Topology.Bornology.Basic
 
+#align_import topology.bornology.constructions from "leanprover-community/mathlib"@"e3d9ab8faa9dea8f78155c6c27d62a621f4c152d"
+
 /-!
 # Bornology structure on products and subtypes

e3d9ab8f

feat: port Analysis.NormedSpace.PiLp (#4345)

Co-authored-by: Jireh Loreaux <loreaujy@gmail.com>

65926b16

Diff

@@ -26,16 +26,16 @@ open Filter
 variable {α β ι : Type _} {π : ι → Type _} [Fintype ι] [Bornology α] [Bornology β]
   [∀ i, Bornology (π i)]
 
-instance : Bornology (α × β)
-    where
+instance Prod.instBornology : Bornology (α × β) where
   cobounded' := (cobounded α).coprod (cobounded β)
   le_cofinite' :=
     @coprod_cofinite α β ▸ coprod_mono ‹Bornology α›.le_cofinite ‹Bornology β›.le_cofinite
+#align prod.bornology Prod.instBornology
 
-instance : Bornology (∀ i, π i)
-    where
+instance Pi.instBornology : Bornology (∀ i, π i) where
   cobounded' := Filter.coprodᵢ fun i => cobounded (π i)
   le_cofinite' := @coprodᵢ_cofinite ι π _ ▸ Filter.coprodᵢ_mono fun _ => Bornology.le_cofinite _
+#align pi.bornology Pi.instBornology
 
 /-- Inverse image of a bornology. -/
 @[reducible]

e3d9ab8f

feat: port Topology.Bornology.Constructions (#1854)

porting notes:

at one point I had to explicit provide the bornology to isBounded_univ. This seems like a regression and should be investigated.

depends on: #1822

724a444a

`topology.bornology.constructions` ⟷ `Mathlib.Topology.Bornology.Constructions`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 7 + 259

topology.bornology.constructions ⟷ Mathlib.Topology.Bornology.Constructions

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 7 + 259

`topology.bornology.constructions` ⟷ `Mathlib.Topology.Bornology.Constructions`