data.set.prod | Mathlib porting status

(last sync)

refactor(*): move all mk_simp_attribute commands to 1 file (#19223)

Diff

@@ -42,9 +42,9 @@ lemma prod_eq (s : set α) (t : set β) : s ×ˢ t = prod.fst ⁻¹' s ∩ prod.
 
 lemma mem_prod_eq {p : α × β} : p ∈ s ×ˢ t = (p.1 ∈ s ∧ p.2 ∈ t) := rfl
 
-@[simp] lemma mem_prod {p : α × β} : p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t := iff.rfl
+@[simp, mfld_simps] lemma mem_prod {p : α × β} : p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t := iff.rfl
 
-@[simp] lemma prod_mk_mem_set_prod_eq : (a, b) ∈ s ×ˢ t = (a ∈ s ∧ b ∈ t) := rfl
+@[simp, mfld_simps] lemma prod_mk_mem_set_prod_eq : (a, b) ∈ s ×ˢ t = (a ∈ s ∧ b ∈ t) := rfl
 
 lemma mk_mem_prod (ha : a ∈ s) (hb : b ∈ t) : (a, b) ∈ s ×ˢ t := ⟨ha, hb⟩
 
@@ -77,7 +77,7 @@ by simp [and_assoc]
 
 @[simp] lemma empty_prod : (∅ : set α) ×ˢ t = ∅ := by { ext, exact false_and _ }
 
-@[simp] lemma univ_prod_univ : @univ α ×ˢ @univ β = univ := by { ext, exact true_and _ }
+@[simp, mfld_simps] lemma univ_prod_univ : @univ α ×ˢ @univ β = univ := by { ext, exact true_and _ }
 
 lemma univ_prod {t : set β} : (univ : set α) ×ˢ t = prod.snd ⁻¹' t := by simp [prod_eq]
 
@@ -103,6 +103,7 @@ by { ext ⟨x, y⟩, simp only [←and_and_distrib_right, mem_inter_iff, mem_pro
 lemma prod_inter : s ×ˢ (t₁ ∩ t₂) = s ×ˢ t₁ ∩ s ×ˢ t₂ :=
 by { ext ⟨x, y⟩, simp only [←and_and_distrib_left, mem_inter_iff, mem_prod] }
 
+@[mfld_simps]
 lemma prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂) :=
 by { ext ⟨x, y⟩, simp [and_assoc, and.left_comm] }
 
@@ -186,7 +187,7 @@ lemma prod_range_range_eq {m₁ : α → γ} {m₂ : β → δ} :
   (range m₁) ×ˢ (range m₂) = range (λ p : α × β, (m₁ p.1, m₂ p.2)) :=
 ext $ by simp [range]
 
-@[simp] lemma range_prod_map {m₁ : α → γ} {m₂ : β → δ} :
+@[simp, mfld_simps] lemma range_prod_map {m₁ : α → γ} {m₂ : β → δ} :
   range (prod.map m₁ m₂) = (range m₁) ×ˢ (range m₂) :=
 prod_range_range_eq.symm
 
@@ -219,7 +220,6 @@ lemma prod_sub_preimage_iff {W : set γ} {f : α × β → γ} :
   s ×ˢ t ⊆ f ⁻¹' W ↔ ∀ a b, a ∈ s → b ∈ t → f (a, b) ∈ W :=
 by simp [subset_def]
 
-
 lemma image_prod_mk_subset_prod {f : α → β} {g : α → γ} {s : set α} :
   (λ x, (f x, g x)) '' s ⊆ (f '' s) ×ˢ (g '' s) :=
 by { rintros _ ⟨x, hx, rfl⟩, exact mk_mem_prod (mem_image_of_mem f hx) (mem_image_of_mem g hx) }

feat(order/sup_indep): More lemmas (#11932)

A few more lemmas about finset.sup_indep and set.pairwise_disjoint.

Diff

@@ -106,13 +106,21 @@ by { ext ⟨x, y⟩, simp only [←and_and_distrib_left, mem_inter_iff, mem_prod
 lemma prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂) :=
 by { ext ⟨x, y⟩, simp [and_assoc, and.left_comm] }
 
-lemma disjoint_prod : disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ disjoint s₁ s₂ ∨ disjoint t₁ t₂ :=
+@[simp] lemma disjoint_prod : disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ disjoint s₁ s₂ ∨ disjoint t₁ t₂ :=
 begin
   simp_rw [disjoint_left, mem_prod, not_and_distrib, prod.forall, and_imp,
     ←@forall_or_distrib_right α, ←@forall_or_distrib_left β,
     ←@forall_or_distrib_right (_ ∈ s₁), ←@forall_or_distrib_left (_ ∈ t₁)],
 end
 
+lemma _root_.disjoint.set_prod_left (hs : disjoint s₁ s₂) (t₁ t₂ : set β) :
+  disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) :=
+disjoint_left.2 $ λ ⟨a, b⟩ ⟨ha₁, hb₁⟩ ⟨ha₂, hb₂⟩, disjoint_left.1 hs ha₁ ha₂
+
+lemma _root_.disjoint.set_prod_right (ht : disjoint t₁ t₂) (s₁ s₂ : set α) :
+  disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) :=
+disjoint_left.2 $ λ ⟨a, b⟩ ⟨ha₁, hb₁⟩ ⟨ha₂, hb₂⟩, disjoint_left.1 ht hb₁ hb₂
+
 lemma insert_prod : insert a s ×ˢ t = (prod.mk a '' t) ∪ s ×ˢ t :=
 by { ext ⟨x, y⟩, simp [image, iff_def, or_imp_distrib, imp.swap] {contextual := tt} }
 
@@ -479,6 +487,20 @@ univ_pi_eq_empty_iff.2 $ h.elim $ λ x, ⟨x, rfl⟩
 @[simp] lemma disjoint_univ_pi : disjoint (pi univ t₁) (pi univ t₂) ↔ ∃ i, disjoint (t₁ i) (t₂ i) :=
 by simp only [disjoint_iff_inter_eq_empty, ← pi_inter_distrib, univ_pi_eq_empty_iff]
 
+lemma _root_.disjoint.set_pi (hi : i ∈ s) (ht : disjoint (t₁ i) (t₂ i)) :
+  disjoint (s.pi t₁) (s.pi t₂) :=
+disjoint_left.2 $ λ h h₁ h₂, disjoint_left.1 ht (h₁ _ hi) (h₂ _ hi)
+
+section nonempty
+variables [Π i, nonempty (α i)]
+
+lemma pi_eq_empty_iff' : s.pi t = ∅ ↔ ∃ i ∈ s, t i = ∅ := by simp [pi_eq_empty_iff]
+
+@[simp] lemma disjoint_pi : disjoint (s.pi t₁) (s.pi t₂) ↔ ∃ i ∈ s, disjoint (t₁ i) (t₂ i) :=
+by simp only [disjoint_iff_inter_eq_empty, ← pi_inter_distrib, pi_eq_empty_iff']
+
+end nonempty
+
 @[simp] lemma range_dcomp (f : Π i, α i → β i) :
   range (λ (g : Π i, α i), (λ i, f i (g i))) = pi univ (λ i, range (f i)) :=
 begin

feat(analysis/calculus/cont_diff): Prove that fderiv_within is C^n for functions with parameters (#16946)

Prove that fderiv_within is C^n (at a point within a set) for a function with parameters
There are some inconvenient side-conditions needed for the lemmas, feel free to recommend improvements
set.diag_image is not used, but a (useful) left-over used before a refactor.
This is useful for lemmas about mfderiv and the smooth vector bundle refactor
From the sphere eversion project

Diff

@@ -353,6 +353,15 @@ prod_subset_iff.trans disjoint_iff_forall_ne.symm
 
 lemma diag_preimage_prod_self (s : set α) : (λ x, (x, x)) ⁻¹' (s ×ˢ s) = s := inter_self s
 
+lemma diag_image (s : set α) : (λ x, (x, x)) '' s = diagonal α ∩ (s ×ˢ s) :=
+begin
+  ext x, split,
+  { rintro ⟨x, hx, rfl⟩, exact ⟨rfl, hx, hx⟩ },
+  { obtain ⟨x, y⟩ := x,
+    rintro ⟨rfl : x = y, h2x⟩,
+    exact mem_image_of_mem _ h2x.1 }
+end
+
 end diagonal
 
 section off_diag

996b0ff9

(no changes)

f974ae84

chore(*): golf (#18111)

Sets

Add set.maps_to_prod_map_diagonal, set.diagonal_nonempty, and set.diagonal_subset_iff.

Filters

Generalize and rename nhds_eq_comap_uniformity_aux to filter.mem_comap_prod_mk.
Add set.nonempty.principal_ne_bot and filter.comap_id'.
Rename filter.has_basis.comp_of_surjective to filter.has_basis.comp_surjective.

Uniform spaces

Rename monotone_comp_rel to monotone.comp_rel to enable dot notation.
Add nhds_eq_comap_uniformity'.
Use 𝓝ˢ (diagonal γ) instead of ⨆ x, 𝓝 (x, x) in uniform_space_of_compact_t2.
Golf here and there.

Mathlib 4 port

Relevant parts are forward-ported in leanprover-community/mathlib4#1438

Diff

@@ -331,6 +331,9 @@ lemma mem_diagonal (x : α) : (x, x) ∈ diagonal α := by simp [diagonal]
 
 @[simp] lemma mem_diagonal_iff {x : α × α} : x ∈ diagonal α ↔ x.1 = x.2 := iff.rfl
 
+lemma diagonal_nonempty [nonempty α] : (diagonal α).nonempty :=
+nonempty.elim ‹_› $ λ x, ⟨_, mem_diagonal x⟩
+
 instance decidable_mem_diagonal [h : decidable_eq α] (x : α × α) : decidable (x ∈ diagonal α) :=
 h x.1 x.2
 
@@ -340,9 +343,11 @@ by { ext ⟨⟨x, hx⟩, ⟨y, hy⟩⟩, simp [set.diagonal] }
 @[simp] lemma range_diag : range (λ x, (x, x)) = diagonal α :=
 by { ext ⟨x, y⟩, simp [diagonal, eq_comm] }
 
+lemma diagonal_subset_iff {s} : diagonal α ⊆ s ↔ ∀ x, (x, x) ∈ s :=
+by rw [← range_diag, range_subset_iff]
+
 @[simp] lemma prod_subset_compl_diagonal_iff_disjoint : s ×ˢ t ⊆ (diagonal α)ᶜ ↔ disjoint s t :=
-subset_compl_comm.trans $ by simp_rw [← range_diag, range_subset_iff,
-  disjoint_left, mem_compl_iff, prod_mk_mem_set_prod_eq, not_and]
+prod_subset_iff.trans disjoint_iff_forall_ne.symm
 
 @[simp] lemma diag_preimage_prod (s t : set α) : (λ x, (x, x)) ⁻¹' (s ×ˢ t) = s ∩ t := rfl

(no changes)

4a1bf948

feat(data/set/n_ary): Distributivity of ∩ (#17924)

set.image2 f for injective2 f distributes over intersection.

Also move the required results from data.set.prod to data.set.n_ary. As a bonus, this makes quite a few files not depend on data.set.n_ary anymore and matches the import direction for the corresponding finset files.

Diff

@@ -3,8 +3,7 @@ Copyright (c) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro, Johannes Hölzl, Patrick Massot
 -/
-import data.set.basic
-import data.set.n_ary
+import data.set.image
 
 /-!
 # Sets in product and pi types
@@ -291,20 +290,6 @@ begin
   refl,
 end
 
-@[simp] lemma image_prod (f : α → β → γ) : (λ x : α × β, f x.1 x.2) '' s ×ˢ t = image2 f s t :=
-set.ext $ λ a,
-⟨ by { rintro ⟨_, _, rfl⟩, exact ⟨_, _, (mem_prod.mp ‹_›).1, (mem_prod.mp ‹_›).2, rfl⟩ },
-  by { rintro ⟨_, _, _, _, rfl⟩, exact ⟨(_, _), mem_prod.mpr ⟨‹_›, ‹_›⟩, rfl⟩ }⟩
-
-@[simp] lemma image2_mk_eq_prod : image2 prod.mk s t = s ×ˢ t := ext $ by simp
-
-@[simp] lemma image2_curry (f : α × β → γ) (s : set α) (t : set β) :
-  image2 (λ a b, f (a, b)) s t = (s ×ˢ t).image f :=
-by rw [←image2_mk_eq_prod, image_image2]
-
-@[simp] lemma image_uncurry_prod (f : α → β → γ) (s : set α) (t : set β) :
-  uncurry f '' s ×ˢ t = image2 f s t := by { rw ←image2_curry, refl }
-
 section mono
 
 variables [preorder α] {f : α → set β} {g : α → set γ}

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-04-25-08

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

ad7a2212

Diff

@@ -151,7 +151,7 @@ theorem forall_prod_set {p : α × β → Prop} : (∀ x ∈ s ×ˢ t, p x) ↔
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.exists_prod_set /-
 theorem exists_prod_set {p : α × β → Prop} : (∃ x ∈ s ×ˢ t, p x) ↔ ∃ x ∈ s, ∃ y ∈ t, p (x, y) := by
-  simp [and_assoc']
+  simp [and_assoc]
 #align set.exists_prod_set Set.exists_prod_set
 -/
 
@@ -252,7 +252,7 @@ theorem prod_inter : s ×ˢ (t₁ ∩ t₂) = s ×ˢ t₁ ∩ s ×ˢ t₂ := by
 #print Set.prod_inter_prod /-
 @[mfld_simps]
 theorem prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂) := by ext ⟨x, y⟩;
-  simp [and_assoc', and_left_comm]
+  simp [and_assoc, and_left_comm]
 #align set.prod_inter_prod Set.prod_inter_prod
 -/
 
@@ -405,7 +405,7 @@ theorem mk_preimage_prod_right_fn_eq_if [DecidablePred (· ∈ s)] (g : δ → 
 #print Set.preimage_swap_prod /-
 @[simp]
 theorem preimage_swap_prod (s : Set α) (t : Set β) : Prod.swap ⁻¹' s ×ˢ t = t ×ˢ s := by ext ⟨x, y⟩;
-  simp [and_comm']
+  simp [and_comm]
 #align set.preimage_swap_prod Set.preimage_swap_prod
 -/

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -1247,7 +1247,7 @@ theorem update_preimage_pi [DecidableEq ι] {f : ∀ i, α i} (hi : i ∈ s)
 #align set.update_preimage_pi Set.update_preimage_pi
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (j «expr ≠ » i) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (j «expr ≠ » i) -/
 #print Set.update_preimage_univ_pi /-
 theorem update_preimage_univ_pi [DecidableEq ι] {f : ∀ i, α i} (hf : ∀ (j) (_ : j ≠ i), f j ∈ t j) :
     update f i ⁻¹' pi univ t = t i :=

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -599,14 +599,14 @@ theorem prod_subset_prod_iff : s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t
   by
   cases' (s ×ˢ t).eq_empty_or_nonempty with h h
   · simp [h, prod_eq_empty_iff.1 h]
-  have st : s.nonempty ∧ t.nonempty := by rwa [prod_nonempty_iff] at h 
+  have st : s.nonempty ∧ t.nonempty := by rwa [prod_nonempty_iff] at h
   refine' ⟨fun H => Or.inl ⟨_, _⟩, _⟩
   · have := image_subset (Prod.fst : α × β → α) H
-    rwa [fst_image_prod _ st.2, fst_image_prod _ (h.mono H).snd] at this 
+    rwa [fst_image_prod _ st.2, fst_image_prod _ (h.mono H).snd] at this
   · have := image_subset (Prod.snd : α × β → β) H
-    rwa [snd_image_prod st.1, snd_image_prod (h.mono H).fst] at this 
+    rwa [snd_image_prod st.1, snd_image_prod (h.mono H).fst] at this
   · intro H
-    simp only [st.1.ne_empty, st.2.ne_empty, or_false_iff] at H 
+    simp only [st.1.ne_empty, st.2.ne_empty, or_false_iff] at H
     exact prod_mono H.1 H.2
 #align set.prod_subset_prod_iff Set.prod_subset_prod_iff
 -/
@@ -621,7 +621,7 @@ theorem prod_eq_prod_iff_of_nonempty (h : (s ×ˢ t).Nonempty) :
   constructor
   · intro heq
     have h₁ : (s₁ ×ˢ t₁ : Set _).Nonempty := by rwa [← HEq]
-    rw [prod_nonempty_iff] at h h₁ 
+    rw [prod_nonempty_iff] at h h₁
     rw [← fst_image_prod s h.2, ← fst_image_prod s₁ h₁.2, HEq, eq_self_iff_true, true_and_iff, ←
       snd_image_prod h.1 t, ← snd_image_prod h₁.1 t₁, HEq]
   · rintro ⟨rfl, rfl⟩; rfl
@@ -641,7 +641,7 @@ theorem prod_eq_prod_iff :
       or_iff_right_iff_imp]
     rintro ⟨rfl, rfl⟩; exact prod_eq_empty_iff.mp h
   rw [prod_eq_prod_iff_of_nonempty h]
-  rw [nonempty_iff_ne_empty, Ne.def, prod_eq_empty_iff] at h 
+  rw [nonempty_iff_ne_empty, Ne.def, prod_eq_empty_iff] at h
   simp_rw [h, false_and_iff, or_false_iff]
 #align set.prod_eq_prod_iff Set.prod_eq_prod_iff
 -/

bump to nightly-2024-02-01-06

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

5433bded

Diff

@@ -1180,6 +1180,9 @@ theorem eval_image_univ_pi_subset : eval i '' pi univ t ⊆ t i :=
 #print Set.subset_eval_image_pi /-
 theorem subset_eval_image_pi (ht : (s.pi t).Nonempty) (i : ι) : t i ⊆ eval i '' s.pi t := by
   classical
+  obtain ⟨f, hf⟩ := ht
+  refine' fun y hy => ⟨update f i y, fun j hj => _, update_same _ _ _⟩
+  obtain rfl | hji := eq_or_ne j i <;> simp [*, hf _ hj]
 #align set.subset_eval_image_pi Set.subset_eval_image_pi
 -/

bump to nightly-2024-01-31-06

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

61100fe9

Diff

@@ -1180,9 +1180,6 @@ theorem eval_image_univ_pi_subset : eval i '' pi univ t ⊆ t i :=
 #print Set.subset_eval_image_pi /-
 theorem subset_eval_image_pi (ht : (s.pi t).Nonempty) (i : ι) : t i ⊆ eval i '' s.pi t := by
   classical
-  obtain ⟨f, hf⟩ := ht
-  refine' fun y hy => ⟨update f i y, fun j hj => _, update_same _ _ _⟩
-  obtain rfl | hji := eq_or_ne j i <;> simp [*, hf _ hj]
 #align set.subset_eval_image_pi Set.subset_eval_image_pi
 -/

bump to nightly-2023-11-05-06

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

acc3325f

Diff

@@ -1204,7 +1204,8 @@ theorem eval_image_univ_pi (ht : (pi univ t).Nonempty) :
 theorem pi_subset_pi_iff : pi s t₁ ⊆ pi s t₂ ↔ (∀ i ∈ s, t₁ i ⊆ t₂ i) ∨ pi s t₁ = ∅ :=
   by
   refine'
-    ⟨fun h => or_iff_not_imp_right.2 _, fun h => h.elim pi_mono fun h' => h'.symm ▸ empty_subset _⟩
+    ⟨fun h => Classical.or_iff_not_imp_right.2 _, fun h =>
+      h.elim pi_mono fun h' => h'.symm ▸ empty_subset _⟩
   rw [← Ne.def, ← nonempty_iff_ne_empty]
   intro hne i hi
   simpa only [eval_image_pi hi hne, eval_image_pi hi (hne.mono h)] using

bump to nightly-2023-10-21-06

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

a2dc86f8

Diff

@@ -985,7 +985,7 @@ theorem pi_congr (h : s₁ = s₂) (h' : ∀ i ∈ s₁, t₁ i = t₂ i) : s₁
 #print Set.pi_eq_empty /-
 theorem pi_eq_empty (hs : i ∈ s) (ht : t i = ∅) : s.pi t = ∅ :=
   by
-  ext f; simp only [mem_empty_iff_false, not_forall, iff_false_iff, mem_pi, not_imp]
+  ext f; simp only [mem_empty_iff_false, Classical.not_forall, iff_false_iff, mem_pi, not_imp]
   exact ⟨i, hs, by simp [ht]⟩
 #align set.pi_eq_empty Set.pi_eq_empty
 -/

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) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro, Johannes Hölzl, Patrick Massot
 -/
-import Mathbin.Data.Set.Image
+import Data.Set.Image
 
 #align_import data.set.prod from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
 
@@ -1246,7 +1246,7 @@ theorem update_preimage_pi [DecidableEq ι] {f : ∀ i, α i} (hi : i ∈ s)
 #align set.update_preimage_pi Set.update_preimage_pi
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (j «expr ≠ » i) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (j «expr ≠ » i) -/
 #print Set.update_preimage_univ_pi /-
 theorem update_preimage_univ_pi [DecidableEq ι] {f : ∀ i, α i} (hf : ∀ (j) (_ : j ≠ i), f j ∈ t j) :
     update f i ⁻¹' pi univ t = t i :=

bump to nightly-2023-08-23-23

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

f612b9e0

Diff

@@ -830,10 +830,10 @@ theorem offDiag_eq_empty : s.offDiag = ∅ ↔ s.Subsingleton := by
 #align set.off_diag_eq_empty Set.offDiag_eq_empty
 -/
 
-alias off_diag_nonempty ↔ _ nontrivial.off_diag_nonempty
+alias ⟨_, nontrivial.off_diag_nonempty⟩ := off_diag_nonempty
 #align set.nontrivial.off_diag_nonempty Set.Nontrivial.offDiag_nonempty
 
-alias off_diag_nonempty ↔ _ subsingleton.off_diag_eq_empty
+alias ⟨_, subsingleton.off_diag_eq_empty⟩ := off_diag_nonempty
 #align set.subsingleton.off_diag_eq_empty Set.Subsingleton.offDiag_eq_empty
 
 variable (s t)

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) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro, Johannes Hölzl, Patrick Massot
-
-! This file was ported from Lean 3 source module data.set.prod
-! leanprover-community/mathlib commit 48fb5b5280e7c81672afc9524185ae994553ebf4
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Set.Image
 
+#align_import data.set.prod from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
+
 /-!
 # Sets in product and pi types
 
@@ -1249,7 +1246,7 @@ theorem update_preimage_pi [DecidableEq ι] {f : ∀ i, α i} (hi : i ∈ s)
 #align set.update_preimage_pi Set.update_preimage_pi
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (j «expr ≠ » i) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (j «expr ≠ » i) -/
 #print Set.update_preimage_univ_pi /-
 theorem update_preimage_univ_pi [DecidableEq ι] {f : ∀ i, α i} (hf : ∀ (j) (_ : j ≠ i), f j ∈ t j) :
     update f i ⁻¹' pi univ t = t i :=

bump to nightly-2023-07-04-01

mathlib commit https://github.com/leanprover-community/mathlib/commit/728ef9dbb281241906f25cbeb30f90d83e0bb451

05318d71

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro, Johannes Hölzl, Patrick Massot
 
 ! This file was ported from Lean 3 source module data.set.prod
-! leanprover-community/mathlib commit c4c2ed622f43768eff32608d4a0f8a6cec1c047d
+! leanprover-community/mathlib commit 48fb5b5280e7c81672afc9524185ae994553ebf4
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -67,7 +67,7 @@ theorem mem_prod_eq {p : α × β} : (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.mem_prod /-
-@[simp]
+@[simp, mfld_simps]
 theorem mem_prod {p : α × β} : p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t :=
   Iff.rfl
 #align set.mem_prod Set.mem_prod
@@ -75,7 +75,7 @@ theorem mem_prod {p : α × β} : p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t :=
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.prod_mk_mem_set_prod_eq /-
-@[simp]
+@[simp, mfld_simps]
 theorem prod_mk_mem_set_prod_eq : ((a, b) ∈ s ×ˢ t) = (a ∈ s ∧ b ∈ t) :=
   rfl
 #align set.prod_mk_mem_set_prod_eq Set.prod_mk_mem_set_prod_eq
@@ -174,7 +174,7 @@ theorem empty_prod : (∅ : Set α) ×ˢ t = ∅ := by ext; exact false_and_iff
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.univ_prod_univ /-
-@[simp]
+@[simp, mfld_simps]
 theorem univ_prod_univ : @univ α ×ˢ @univ β = univ := by ext; exact true_and_iff _
 #align set.univ_prod_univ Set.univ_prod_univ
 -/
@@ -253,6 +253,7 @@ theorem prod_inter : s ×ˢ (t₁ ∩ t₂) = s ×ˢ t₁ ∩ s ×ˢ t₂ := by
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.prod_inter_prod /-
+@[mfld_simps]
 theorem prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂) := by ext ⟨x, y⟩;
   simp [and_assoc', and_left_comm]
 #align set.prod_inter_prod Set.prod_inter_prod
@@ -440,7 +441,7 @@ theorem prod_range_range_eq {m₁ : α → γ} {m₂ : β → δ} :
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.range_prod_map /-
-@[simp]
+@[simp, mfld_simps]
 theorem range_prod_map {m₁ : α → γ} {m₂ : β → δ} : range (Prod.map m₁ m₂) = range m₁ ×ˢ range m₂ :=
   prod_range_range_eq.symm
 #align set.range_prod_map Set.range_prod_map

bump to nightly-2023-06-20-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/0723536a0522d24fc2f159a096fb3304bef77472

1fb3229c

Diff

@@ -1049,13 +1049,17 @@ section Nonempty
 
 variable [∀ i, Nonempty (α i)]
 
+#print Set.pi_eq_empty_iff' /-
 theorem pi_eq_empty_iff' : s.pi t = ∅ ↔ ∃ i ∈ s, t i = ∅ := by simp [pi_eq_empty_iff]
 #align set.pi_eq_empty_iff' Set.pi_eq_empty_iff'
+-/
 
+#print Set.disjoint_pi /-
 @[simp]
 theorem disjoint_pi : Disjoint (s.pi t₁) (s.pi t₂) ↔ ∃ i ∈ s, Disjoint (t₁ i) (t₂ i) := by
   simp only [disjoint_iff_inter_eq_empty, ← pi_inter_distrib, pi_eq_empty_iff']
 #align set.disjoint_pi Set.disjoint_pi
+-/
 
 end Nonempty

bump to nightly-2023-06-17-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/893964fc28cefbcffc7cb784ed00a2895b4e65cf

253178d1

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro, Johannes Hölzl, Patrick Massot
 
 ! This file was ported from Lean 3 source module data.set.prod
-! leanprover-community/mathlib commit 27f315c5591c84687852f816d8ef31fe103d03de
+! leanprover-community/mathlib commit c4c2ed622f43768eff32608d4a0f8a6cec1c047d
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -261,12 +261,27 @@ theorem prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.disjoint_prod /-
+@[simp]
 theorem disjoint_prod : Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂ := by
   simp_rw [disjoint_left, mem_prod, not_and_or, Prod.forall, and_imp, ← @forall_or_right α, ←
     @forall_or_left β, ← @forall_or_right (_ ∈ s₁), ← @forall_or_left (_ ∈ t₁)]
 #align set.disjoint_prod Set.disjoint_prod
 -/
 
+/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+theorem Disjoint.set_prod_left (hs : Disjoint s₁ s₂) (t₁ t₂ : Set β) :
+    Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) :=
+  disjoint_left.2 fun ⟨a, b⟩ ⟨ha₁, hb₁⟩ ⟨ha₂, hb₂⟩ => disjoint_left.1 hs ha₁ ha₂
+#align disjoint.set_prod_left Disjoint.set_prod_left
+
+/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+/- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+theorem Disjoint.set_prod_right (ht : Disjoint t₁ t₂) (s₁ s₂ : Set α) :
+    Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) :=
+  disjoint_left.2 fun ⟨a, b⟩ ⟨ha₁, hb₁⟩ ⟨ha₂, hb₂⟩ => disjoint_left.1 ht hb₁ hb₂
+#align disjoint.set_prod_right Disjoint.set_prod_right
+
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.insert_prod /-
@@ -1026,6 +1041,24 @@ theorem disjoint_univ_pi : Disjoint (pi univ t₁) (pi univ t₂) ↔ ∃ i, Dis
 #align set.disjoint_univ_pi Set.disjoint_univ_pi
 -/
 
+theorem Disjoint.set_pi (hi : i ∈ s) (ht : Disjoint (t₁ i) (t₂ i)) : Disjoint (s.pi t₁) (s.pi t₂) :=
+  disjoint_left.2 fun h h₁ h₂ => disjoint_left.1 ht (h₁ _ hi) (h₂ _ hi)
+#align disjoint.set_pi Disjoint.set_pi
+
+section Nonempty
+
+variable [∀ i, Nonempty (α i)]
+
+theorem pi_eq_empty_iff' : s.pi t = ∅ ↔ ∃ i ∈ s, t i = ∅ := by simp [pi_eq_empty_iff]
+#align set.pi_eq_empty_iff' Set.pi_eq_empty_iff'
+
+@[simp]
+theorem disjoint_pi : Disjoint (s.pi t₁) (s.pi t₂) ↔ ∃ i ∈ s, Disjoint (t₁ i) (t₂ i) := by
+  simp only [disjoint_iff_inter_eq_empty, ← pi_inter_distrib, pi_eq_empty_iff']
+#align set.disjoint_pi Set.disjoint_pi
+
+end Nonempty
+
 #print Set.range_dcomp /-
 @[simp]
 theorem range_dcomp (f : ∀ i, α i → β i) :

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -47,26 +47,31 @@ def prod (s : Set α) (t : Set β) : Set (α × β) :=
 #align set.prod Set.prod
 -/
 
--- mathport name: set.prod
 infixr:82
   " ×ˢ " =>-- This notation binds more strongly than (pre)images, unions and intersections.
   Set.prod
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_eq /-
 theorem prod_eq (s : Set α) (t : Set β) : s ×ˢ t = Prod.fst ⁻¹' s ∩ Prod.snd ⁻¹' t :=
   rfl
 #align set.prod_eq Set.prod_eq
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.mem_prod_eq /-
 theorem mem_prod_eq {p : α × β} : (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) :=
   rfl
 #align set.mem_prod_eq Set.mem_prod_eq
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.mem_prod /-
 @[simp]
 theorem mem_prod {p : α × β} : p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t :=
   Iff.rfl
 #align set.mem_prod Set.mem_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.prod_mk_mem_set_prod_eq /-
@@ -77,9 +82,11 @@ theorem prod_mk_mem_set_prod_eq : ((a, b) ∈ s ×ˢ t) = (a ∈ s ∧ b ∈ t)
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.mk_mem_prod /-
 theorem mk_mem_prod (ha : a ∈ s) (hb : b ∈ t) : (a, b) ∈ s ×ˢ t :=
   ⟨ha, hb⟩
 #align set.mk_mem_prod Set.mk_mem_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.decidableMemProd /-
@@ -90,15 +97,19 @@ instance decidableMemProd [hs : DecidablePred (· ∈ s)] [ht : DecidablePred (
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_mono /-
 theorem prod_mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : s₁ ×ˢ t₁ ⊆ s₂ ×ˢ t₂ := fun x ⟨h₁, h₂⟩ =>
   ⟨hs h₁, ht h₂⟩
 #align set.prod_mono Set.prod_mono
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_mono_left /-
 theorem prod_mono_left (hs : s₁ ⊆ s₂) : s₁ ×ˢ t ⊆ s₂ ×ˢ t :=
   prod_mono hs Subset.rfl
 #align set.prod_mono_left Set.prod_mono_left
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -119,10 +130,12 @@ theorem prod_self_subset_prod_self : s₁ ×ˢ s₁ ⊆ s₂ ×ˢ s₂ ↔ s₁
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_self_ssubset_prod_self /-
 @[simp]
 theorem prod_self_ssubset_prod_self : s₁ ×ˢ s₁ ⊂ s₂ ×ˢ s₂ ↔ s₁ ⊂ s₂ :=
   and_congr prod_self_subset_prod_self <| not_congr prod_self_subset_prod_self
 #align set.prod_self_ssubset_prod_self Set.prod_self_ssubset_prod_self
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.prod_subset_iff /-
@@ -132,29 +145,39 @@ theorem prod_subset_iff {P : Set (α × β)} : s ×ˢ t ⊆ P ↔ ∀ x ∈ s, 
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.forall_prod_set /-
 theorem forall_prod_set {p : α × β → Prop} : (∀ x ∈ s ×ˢ t, p x) ↔ ∀ x ∈ s, ∀ y ∈ t, p (x, y) :=
   prod_subset_iff
 #align set.forall_prod_set Set.forall_prod_set
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.exists_prod_set /-
 theorem exists_prod_set {p : α × β → Prop} : (∃ x ∈ s ×ˢ t, p x) ↔ ∃ x ∈ s, ∃ y ∈ t, p (x, y) := by
   simp [and_assoc']
 #align set.exists_prod_set Set.exists_prod_set
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_empty /-
 @[simp]
 theorem prod_empty : s ×ˢ (∅ : Set β) = ∅ := by ext; exact and_false_iff _
 #align set.prod_empty Set.prod_empty
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.empty_prod /-
 @[simp]
 theorem empty_prod : (∅ : Set α) ×ˢ t = ∅ := by ext; exact false_and_iff _
 #align set.empty_prod Set.empty_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.univ_prod_univ /-
 @[simp]
 theorem univ_prod_univ : @univ α ×ˢ @univ β = univ := by ext; exact true_and_iff _
 #align set.univ_prod_univ Set.univ_prod_univ
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.univ_prod /-
@@ -163,85 +186,111 @@ theorem univ_prod {t : Set β} : (univ : Set α) ×ˢ t = Prod.snd ⁻¹' t := b
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_univ /-
 theorem prod_univ {s : Set α} : s ×ˢ (univ : Set β) = Prod.fst ⁻¹' s := by simp [prod_eq]
 #align set.prod_univ Set.prod_univ
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.singleton_prod /-
 @[simp]
 theorem singleton_prod : ({a} : Set α) ×ˢ t = Prod.mk a '' t := by ext ⟨x, y⟩;
   simp [and_left_comm, eq_comm]
 #align set.singleton_prod Set.singleton_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_singleton /-
 @[simp]
 theorem prod_singleton : s ×ˢ ({b} : Set β) = (fun a => (a, b)) '' s := by ext ⟨x, y⟩;
   simp [and_left_comm, eq_comm]
 #align set.prod_singleton Set.prod_singleton
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.singleton_prod_singleton /-
 theorem singleton_prod_singleton : ({a} : Set α) ×ˢ ({b} : Set β) = {(a, b)} := by simp
 #align set.singleton_prod_singleton Set.singleton_prod_singleton
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.union_prod /-
 @[simp]
 theorem union_prod : (s₁ ∪ s₂) ×ˢ t = s₁ ×ˢ t ∪ s₂ ×ˢ t := by ext ⟨x, y⟩; simp [or_and_right]
 #align set.union_prod Set.union_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_union /-
 @[simp]
 theorem prod_union : s ×ˢ (t₁ ∪ t₂) = s ×ˢ t₁ ∪ s ×ˢ t₂ := by ext ⟨x, y⟩; simp [and_or_left]
 #align set.prod_union Set.prod_union
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.inter_prod /-
 theorem inter_prod : (s₁ ∩ s₂) ×ˢ t = s₁ ×ˢ t ∩ s₂ ×ˢ t := by ext ⟨x, y⟩;
   simp only [← and_and_right, mem_inter_iff, mem_prod]
 #align set.inter_prod Set.inter_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_inter /-
 theorem prod_inter : s ×ˢ (t₁ ∩ t₂) = s ×ˢ t₁ ∩ s ×ˢ t₂ := by ext ⟨x, y⟩;
   simp only [← and_and_left, mem_inter_iff, mem_prod]
 #align set.prod_inter Set.prod_inter
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_inter_prod /-
 theorem prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂) := by ext ⟨x, y⟩;
   simp [and_assoc', and_left_comm]
 #align set.prod_inter_prod Set.prod_inter_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.disjoint_prod /-
 theorem disjoint_prod : Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂ := by
   simp_rw [disjoint_left, mem_prod, not_and_or, Prod.forall, and_imp, ← @forall_or_right α, ←
     @forall_or_left β, ← @forall_or_right (_ ∈ s₁), ← @forall_or_left (_ ∈ t₁)]
 #align set.disjoint_prod Set.disjoint_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.insert_prod /-
 theorem insert_prod : insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t := by ext ⟨x, y⟩;
   simp (config := { contextual := true }) [image, iff_def, or_imp, Imp.swap]
 #align set.insert_prod Set.insert_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_insert /-
 theorem prod_insert : s ×ˢ insert b t = (fun a => (a, b)) '' s ∪ s ×ˢ t := by ext ⟨x, y⟩;
   simp (config := { contextual := true }) [image, iff_def, or_imp, Imp.swap]
 #align set.prod_insert Set.prod_insert
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_preimage_eq /-
 theorem prod_preimage_eq {f : γ → α} {g : δ → β} :
     (f ⁻¹' s) ×ˢ (g ⁻¹' t) = (fun p : γ × δ => (f p.1, g p.2)) ⁻¹' s ×ˢ t :=
   rfl
 #align set.prod_preimage_eq Set.prod_preimage_eq
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -254,23 +303,29 @@ theorem prod_preimage_left {f : γ → α} :
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_preimage_right /-
 theorem prod_preimage_right {g : δ → β} :
     s ×ˢ (g ⁻¹' t) = (fun p : α × δ => (p.1, g p.2)) ⁻¹' s ×ˢ t :=
   rfl
 #align set.prod_preimage_right Set.prod_preimage_right
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.preimage_prod_map_prod /-
 theorem preimage_prod_map_prod (f : α → β) (g : γ → δ) (s : Set β) (t : Set δ) :
     Prod.map f g ⁻¹' s ×ˢ t = (f ⁻¹' s) ×ˢ (g ⁻¹' t) :=
   rfl
 #align set.preimage_prod_map_prod Set.preimage_prod_map_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.mk_preimage_prod /-
 theorem mk_preimage_prod (f : γ → α) (g : γ → β) :
     (fun x => (f x, g x)) ⁻¹' s ×ˢ t = f ⁻¹' s ∩ g ⁻¹' t :=
   rfl
 #align set.mk_preimage_prod Set.mk_preimage_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.mk_preimage_prod_left /-
@@ -280,9 +335,11 @@ theorem mk_preimage_prod_left (hb : b ∈ t) : (fun a => (a, b)) ⁻¹' s ×ˢ t
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.mk_preimage_prod_right /-
 @[simp]
 theorem mk_preimage_prod_right (ha : a ∈ s) : Prod.mk a ⁻¹' s ×ˢ t = t := by ext b; simp [ha]
 #align set.mk_preimage_prod_right Set.mk_preimage_prod_right
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.mk_preimage_prod_left_eq_empty /-
@@ -293,10 +350,12 @@ theorem mk_preimage_prod_left_eq_empty (hb : b ∉ t) : (fun a => (a, b)) ⁻¹'
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.mk_preimage_prod_right_eq_empty /-
 @[simp]
 theorem mk_preimage_prod_right_eq_empty (ha : a ∉ s) : Prod.mk a ⁻¹' s ×ˢ t = ∅ := by ext b;
   simp [ha]
 #align set.mk_preimage_prod_right_eq_empty Set.mk_preimage_prod_right_eq_empty
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.mk_preimage_prod_left_eq_if /-
@@ -306,55 +365,71 @@ theorem mk_preimage_prod_left_eq_if [DecidablePred (· ∈ t)] :
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.mk_preimage_prod_right_eq_if /-
 theorem mk_preimage_prod_right_eq_if [DecidablePred (· ∈ s)] :
     Prod.mk a ⁻¹' s ×ˢ t = if a ∈ s then t else ∅ := by split_ifs <;> simp [h]
 #align set.mk_preimage_prod_right_eq_if Set.mk_preimage_prod_right_eq_if
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.mk_preimage_prod_left_fn_eq_if /-
 theorem mk_preimage_prod_left_fn_eq_if [DecidablePred (· ∈ t)] (f : γ → α) :
     (fun a => (f a, b)) ⁻¹' s ×ˢ t = if b ∈ t then f ⁻¹' s else ∅ := by
   rw [← mk_preimage_prod_left_eq_if, prod_preimage_left, preimage_preimage]
 #align set.mk_preimage_prod_left_fn_eq_if Set.mk_preimage_prod_left_fn_eq_if
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.mk_preimage_prod_right_fn_eq_if /-
 theorem mk_preimage_prod_right_fn_eq_if [DecidablePred (· ∈ s)] (g : δ → β) :
     (fun b => (a, g b)) ⁻¹' s ×ˢ t = if a ∈ s then g ⁻¹' t else ∅ := by
   rw [← mk_preimage_prod_right_eq_if, prod_preimage_right, preimage_preimage]
 #align set.mk_preimage_prod_right_fn_eq_if Set.mk_preimage_prod_right_fn_eq_if
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.preimage_swap_prod /-
 @[simp]
 theorem preimage_swap_prod (s : Set α) (t : Set β) : Prod.swap ⁻¹' s ×ˢ t = t ×ˢ s := by ext ⟨x, y⟩;
   simp [and_comm']
 #align set.preimage_swap_prod Set.preimage_swap_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.image_swap_prod /-
 @[simp]
 theorem image_swap_prod (s : Set α) (t : Set β) : Prod.swap '' s ×ˢ t = t ×ˢ s := by
   rw [image_swap_eq_preimage_swap, preimage_swap_prod]
 #align set.image_swap_prod Set.image_swap_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_image_image_eq /-
 theorem prod_image_image_eq {m₁ : α → γ} {m₂ : β → δ} :
     (m₁ '' s) ×ˢ (m₂ '' t) = (fun p : α × β => (m₁ p.1, m₂ p.2)) '' s ×ˢ t :=
   ext <| by
     simp [-exists_and_right, exists_and_distrib_right.symm, and_left_comm, and_assoc, and_comm]
 #align set.prod_image_image_eq Set.prod_image_image_eq
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_range_range_eq /-
 theorem prod_range_range_eq {m₁ : α → γ} {m₂ : β → δ} :
     range m₁ ×ˢ range m₂ = range fun p : α × β => (m₁ p.1, m₂ p.2) :=
   ext <| by simp [range]
 #align set.prod_range_range_eq Set.prod_range_range_eq
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.range_prod_map /-
 @[simp]
 theorem range_prod_map {m₁ : α → γ} {m₂ : β → δ} : range (Prod.map m₁ m₂) = range m₁ ×ˢ range m₂ :=
   prod_range_range_eq.symm
 #align set.range_prod_map Set.range_prod_map
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.prod_range_univ_eq /-
@@ -365,10 +440,12 @@ theorem prod_range_univ_eq {m₁ : α → γ} :
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_univ_range_eq /-
 theorem prod_univ_range_eq {m₂ : β → δ} :
     (univ : Set α) ×ˢ range m₂ = range fun p : α × β => (p.1, m₂ p.2) :=
   ext <| by simp [range]
 #align set.prod_univ_range_eq Set.prod_univ_range_eq
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.range_pair_subset /-
@@ -382,38 +459,52 @@ theorem range_pair_subset (f : α → β) (g : α → γ) :
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.Nonempty.prod /-
 theorem Nonempty.prod : s.Nonempty → t.Nonempty → (s ×ˢ t).Nonempty := fun ⟨x, hx⟩ ⟨y, hy⟩ =>
   ⟨(x, y), ⟨hx, hy⟩⟩
 #align set.nonempty.prod Set.Nonempty.prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.Nonempty.fst /-
 theorem Nonempty.fst : (s ×ˢ t).Nonempty → s.Nonempty := fun ⟨x, hx⟩ => ⟨x.1, hx.1⟩
 #align set.nonempty.fst Set.Nonempty.fst
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.Nonempty.snd /-
 theorem Nonempty.snd : (s ×ˢ t).Nonempty → t.Nonempty := fun ⟨x, hx⟩ => ⟨x.2, hx.2⟩
 #align set.nonempty.snd Set.Nonempty.snd
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_nonempty_iff /-
 theorem prod_nonempty_iff : (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty :=
   ⟨fun h => ⟨h.fst, h.snd⟩, fun h => h.1.Prod h.2⟩
 #align set.prod_nonempty_iff Set.prod_nonempty_iff
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_eq_empty_iff /-
 theorem prod_eq_empty_iff : s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅ := by
   simp only [not_nonempty_iff_eq_empty.symm, prod_nonempty_iff, not_and_or]
 #align set.prod_eq_empty_iff Set.prod_eq_empty_iff
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_sub_preimage_iff /-
 theorem prod_sub_preimage_iff {W : Set γ} {f : α × β → γ} :
     s ×ˢ t ⊆ f ⁻¹' W ↔ ∀ a b, a ∈ s → b ∈ t → f (a, b) ∈ W := by simp [subset_def]
 #align set.prod_sub_preimage_iff Set.prod_sub_preimage_iff
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.image_prod_mk_subset_prod /-
 theorem image_prod_mk_subset_prod {f : α → β} {g : α → γ} {s : Set α} :
     (fun x => (f x, g x)) '' s ⊆ (f '' s) ×ˢ (g '' s) := by rintro _ ⟨x, hx, rfl⟩;
   exact mk_mem_prod (mem_image_of_mem f hx) (mem_image_of_mem g hx)
 #align set.image_prod_mk_subset_prod Set.image_prod_mk_subset_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.image_prod_mk_subset_prod_left /-
@@ -423,19 +514,25 @@ theorem image_prod_mk_subset_prod_left (hb : b ∈ t) : (fun a => (a, b)) '' s 
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.image_prod_mk_subset_prod_right /-
 theorem image_prod_mk_subset_prod_right (ha : a ∈ s) : Prod.mk a '' t ⊆ s ×ˢ t := by
   rintro _ ⟨b, hb, rfl⟩; exact ⟨ha, hb⟩
 #align set.image_prod_mk_subset_prod_right Set.image_prod_mk_subset_prod_right
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_subset_preimage_fst /-
 theorem prod_subset_preimage_fst (s : Set α) (t : Set β) : s ×ˢ t ⊆ Prod.fst ⁻¹' s :=
   inter_subset_left _ _
 #align set.prod_subset_preimage_fst Set.prod_subset_preimage_fst
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.fst_image_prod_subset /-
 theorem fst_image_prod_subset (s : Set α) (t : Set β) : Prod.fst '' s ×ˢ t ⊆ s :=
   image_subset_iff.2 <| prod_subset_preimage_fst s t
 #align set.fst_image_prod_subset Set.fst_image_prod_subset
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.fst_image_prod /-
@@ -447,33 +544,42 @@ theorem fst_image_prod (s : Set β) {t : Set α} (ht : t.Nonempty) : Prod.fst ''
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_subset_preimage_snd /-
 theorem prod_subset_preimage_snd (s : Set α) (t : Set β) : s ×ˢ t ⊆ Prod.snd ⁻¹' t :=
   inter_subset_right _ _
 #align set.prod_subset_preimage_snd Set.prod_subset_preimage_snd
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.snd_image_prod_subset /-
 theorem snd_image_prod_subset (s : Set α) (t : Set β) : Prod.snd '' s ×ˢ t ⊆ t :=
   image_subset_iff.2 <| prod_subset_preimage_snd s t
 #align set.snd_image_prod_subset Set.snd_image_prod_subset
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.snd_image_prod /-
 theorem snd_image_prod {s : Set α} (hs : s.Nonempty) (t : Set β) : Prod.snd '' s ×ˢ t = t :=
   (snd_image_prod_subset _ _).antisymm fun y y_in =>
     let ⟨x, x_in⟩ := hs
     ⟨(x, y), ⟨x_in, y_in⟩, rfl⟩
 #align set.snd_image_prod Set.snd_image_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_diff_prod /-
 theorem prod_diff_prod : s ×ˢ t \ s₁ ×ˢ t₁ = s ×ˢ (t \ t₁) ∪ (s \ s₁) ×ˢ t := by ext x;
   by_cases h₁ : x.1 ∈ s₁ <;> by_cases h₂ : x.2 ∈ t₁ <;> simp [*]
 #align set.prod_diff_prod Set.prod_diff_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_subset_prod_iff /-
 /-- A product set is included in a product set if and only factors are included, or a factor of the
 first set is empty. -/
 theorem prod_subset_prod_iff : s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t ⊆ t₁ ∨ s = ∅ ∨ t = ∅ :=
@@ -490,11 +596,13 @@ theorem prod_subset_prod_iff : s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t
     simp only [st.1.ne_empty, st.2.ne_empty, or_false_iff] at H 
     exact prod_mono H.1 H.2
 #align set.prod_subset_prod_iff Set.prod_subset_prod_iff
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_eq_prod_iff_of_nonempty /-
 theorem prod_eq_prod_iff_of_nonempty (h : (s ×ˢ t).Nonempty) :
     s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁ := by
   constructor
@@ -505,10 +613,12 @@ theorem prod_eq_prod_iff_of_nonempty (h : (s ×ˢ t).Nonempty) :
       snd_image_prod h.1 t, ← snd_image_prod h₁.1 t₁, HEq]
   · rintro ⟨rfl, rfl⟩; rfl
 #align set.prod_eq_prod_iff_of_nonempty Set.prod_eq_prod_iff_of_nonempty
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_eq_prod_iff /-
 theorem prod_eq_prod_iff :
     s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁ ∨ (s = ∅ ∨ t = ∅) ∧ (s₁ = ∅ ∨ t₁ = ∅) :=
   by
@@ -521,6 +631,7 @@ theorem prod_eq_prod_iff :
   rw [nonempty_iff_ne_empty, Ne.def, prod_eq_empty_iff] at h 
   simp_rw [h, false_and_iff, or_false_iff]
 #align set.prod_eq_prod_iff Set.prod_eq_prod_iff
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -540,24 +651,32 @@ section Mono
 variable [Preorder α] {f : α → Set β} {g : α → Set γ}
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Monotone.set_prod /-
 theorem Monotone.set_prod (hf : Monotone f) (hg : Monotone g) : Monotone fun x => f x ×ˢ g x :=
   fun a b h => prod_mono (hf h) (hg h)
 #align monotone.set_prod Monotone.set_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Antitone.set_prod /-
 theorem Antitone.set_prod (hf : Antitone f) (hg : Antitone g) : Antitone fun x => f x ×ˢ g x :=
   fun a b h => prod_mono (hf h) (hg h)
 #align antitone.set_prod Antitone.set_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print MonotoneOn.set_prod /-
 theorem MonotoneOn.set_prod (hf : MonotoneOn f s) (hg : MonotoneOn g s) :
     MonotoneOn (fun x => f x ×ˢ g x) s := fun a ha b hb h => prod_mono (hf ha hb h) (hg ha hb h)
 #align monotone_on.set_prod MonotoneOn.set_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print AntitoneOn.set_prod /-
 theorem AntitoneOn.set_prod (hf : AntitoneOn f s) (hg : AntitoneOn g s) :
     AntitoneOn (fun x => f x ×ˢ g x) s := fun a ha b hb h => prod_mono (hf ha hb h) (hg ha hb h)
 #align antitone_on.set_prod AntitoneOn.set_prod
+-/
 
 end Mono
 
@@ -624,16 +743,20 @@ theorem diagonal_subset_iff {s} : diagonal α ⊆ s ↔ ∀ x, (x, x) ∈ s := b
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_subset_compl_diagonal_iff_disjoint /-
 @[simp]
 theorem prod_subset_compl_diagonal_iff_disjoint : s ×ˢ t ⊆ diagonal αᶜ ↔ Disjoint s t :=
   prod_subset_iff.trans disjoint_iff_forall_ne.symm
 #align set.prod_subset_compl_diagonal_iff_disjoint Set.prod_subset_compl_diagonal_iff_disjoint
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.diag_preimage_prod /-
 @[simp]
 theorem diag_preimage_prod (s t : Set α) : (fun x => (x, x)) ⁻¹' s ×ˢ t = s ∩ t :=
   rfl
 #align set.diag_preimage_prod Set.diag_preimage_prod
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.diag_preimage_prod_self /-
@@ -643,6 +766,7 @@ theorem diag_preimage_prod_self (s : Set α) : (fun x => (x, x)) ⁻¹' s ×ˢ s
 -/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.diag_image /-
 theorem diag_image (s : Set α) : (fun x => (x, x)) '' s = diagonal α ∩ s ×ˢ s :=
   by
   ext x; constructor
@@ -651,6 +775,7 @@ theorem diag_image (s : Set α) : (fun x => (x, x)) '' s = diagonal α ∩ s ×
     rintro ⟨rfl : x = y, h2x⟩
     exact mem_image_of_mem _ h2x.1
 #align set.diag_image Set.diag_image
+-/
 
 end Diagonal
 
@@ -672,9 +797,11 @@ theorem mem_offDiag : x ∈ s.offDiag ↔ x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.
 #align set.mem_off_diag Set.mem_offDiag
 -/
 
+#print Set.offDiag_mono /-
 theorem offDiag_mono : Monotone (offDiag : Set α → Set (α × α)) := fun s t h x =>
   And.imp (@h _) <| And.imp_left <| @h _
 #align set.off_diag_mono Set.offDiag_mono
+-/
 
 #print Set.offDiag_nonempty /-
 @[simp]
@@ -723,25 +850,33 @@ theorem offDiag_singleton (a : α) : ({a} : Set α).offDiag = ∅ := by simp
 #align set.off_diag_singleton Set.offDiag_singleton
 -/
 
+#print Set.offDiag_univ /-
 @[simp]
 theorem offDiag_univ : (univ : Set α).offDiag = diagonal αᶜ :=
   ext <| by simp
 #align set.off_diag_univ Set.offDiag_univ
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_sdiff_diagonal /-
 @[simp]
 theorem prod_sdiff_diagonal : s ×ˢ s \ diagonal α = s.offDiag :=
   ext fun _ => and_assoc
 #align set.prod_sdiff_diagonal Set.prod_sdiff_diagonal
+-/
 
+#print Set.disjoint_diagonal_offDiag /-
 @[simp]
 theorem disjoint_diagonal_offDiag : Disjoint (diagonal α) s.offDiag :=
   disjoint_left.mpr fun x hd ho => ho.2.2 hd
 #align set.disjoint_diagonal_off_diag Set.disjoint_diagonal_offDiag
+-/
 
+#print Set.offDiag_inter /-
 theorem offDiag_inter : (s ∩ t).offDiag = s.offDiag ∩ t.offDiag :=
   ext fun x => by simp only [mem_off_diag, mem_inter_iff]; tauto
 #align set.off_diag_inter Set.offDiag_inter
+-/
 
 variable {s t}
 
@@ -749,6 +884,7 @@ variable {s t}
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.offDiag_union /-
 theorem offDiag_union (h : Disjoint s t) :
     (s ∪ t).offDiag = s.offDiag ∪ t.offDiag ∪ s ×ˢ t ∪ t ×ˢ s :=
   by
@@ -758,9 +894,11 @@ theorem offDiag_union (h : Disjoint s t) :
   simp only [mem_union, mem_prod, Ne.def, Prod.forall]
   rintro i j (⟨hi, hj⟩ | ⟨hi, hj⟩) rfl <;> exact h.le_bot ⟨‹_›, ‹_›⟩
 #align set.off_diag_union Set.offDiag_union
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.offDiag_insert /-
 theorem offDiag_insert (ha : a ∉ s) : (insert a s).offDiag = s.offDiag ∪ {a} ×ˢ s ∪ s ×ˢ {a} :=
   by
   rw [insert_eq, union_comm, off_diag_union, off_diag_singleton, union_empty, union_right_comm]
@@ -768,6 +906,7 @@ theorem offDiag_insert (ha : a ∉ s) : (insert a s).offDiag = s.offDiag ∪ {a}
   rintro b hb (rfl : b = a)
   exact ha hb
 #align set.off_diag_insert Set.offDiag_insert
+-/
 
 end OffDiag
 
@@ -787,14 +926,18 @@ def pi (s : Set ι) (t : ∀ i, Set (α i)) : Set (∀ i, α i) :=
 #align set.pi Set.pi
 -/
 
+#print Set.mem_pi /-
 @[simp]
 theorem mem_pi {f : ∀ i, α i} : f ∈ s.pi t ↔ ∀ i ∈ s, f i ∈ t i :=
   Iff.rfl
 #align set.mem_pi Set.mem_pi
+-/
 
+#print Set.mem_univ_pi /-
 @[simp]
 theorem mem_univ_pi {f : ∀ i, α i} : f ∈ pi univ t ↔ ∀ i, f i ∈ t i := by simp
 #align set.mem_univ_pi Set.mem_univ_pi
+-/
 
 #print Set.empty_pi /-
 @[simp]
@@ -802,27 +945,37 @@ theorem empty_pi (s : ∀ i, Set (α i)) : pi ∅ s = univ := by ext; simp [pi]
 #align set.empty_pi Set.empty_pi
 -/
 
+#print Set.pi_univ /-
 @[simp]
 theorem pi_univ (s : Set ι) : (pi s fun i => (univ : Set (α i))) = univ :=
   eq_univ_of_forall fun f i hi => mem_univ _
 #align set.pi_univ Set.pi_univ
+-/
 
+#print Set.pi_mono /-
 theorem pi_mono (h : ∀ i ∈ s, t₁ i ⊆ t₂ i) : pi s t₁ ⊆ pi s t₂ := fun x hx i hi => h i hi <| hx i hi
 #align set.pi_mono Set.pi_mono
+-/
 
+#print Set.pi_inter_distrib /-
 theorem pi_inter_distrib : (s.pi fun i => t i ∩ t₁ i) = s.pi t ∩ s.pi t₁ :=
   ext fun x => by simp only [forall_and, mem_pi, mem_inter_iff]
 #align set.pi_inter_distrib Set.pi_inter_distrib
+-/
 
+#print Set.pi_congr /-
 theorem pi_congr (h : s₁ = s₂) (h' : ∀ i ∈ s₁, t₁ i = t₂ i) : s₁.pi t₁ = s₂.pi t₂ :=
   h ▸ ext fun x => forall₂_congr fun i hi => h' i hi ▸ Iff.rfl
 #align set.pi_congr Set.pi_congr
+-/
 
+#print Set.pi_eq_empty /-
 theorem pi_eq_empty (hs : i ∈ s) (ht : t i = ∅) : s.pi t = ∅ :=
   by
   ext f; simp only [mem_empty_iff_false, not_forall, iff_false_iff, mem_pi, not_imp]
   exact ⟨i, hs, by simp [ht]⟩
 #align set.pi_eq_empty Set.pi_eq_empty
+-/
 
 #print Set.univ_pi_eq_empty /-
 theorem univ_pi_eq_empty (ht : t i = ∅) : pi univ t = ∅ :=
@@ -830,14 +983,19 @@ theorem univ_pi_eq_empty (ht : t i = ∅) : pi univ t = ∅ :=
 #align set.univ_pi_eq_empty Set.univ_pi_eq_empty
 -/
 
+#print Set.pi_nonempty_iff /-
 theorem pi_nonempty_iff : (s.pi t).Nonempty ↔ ∀ i, ∃ x, i ∈ s → x ∈ t i := by
   simp [Classical.skolem, Set.Nonempty]
 #align set.pi_nonempty_iff Set.pi_nonempty_iff
+-/
 
+#print Set.univ_pi_nonempty_iff /-
 theorem univ_pi_nonempty_iff : (pi univ t).Nonempty ↔ ∀ i, (t i).Nonempty := by
   simp [Classical.skolem, Set.Nonempty]
 #align set.univ_pi_nonempty_iff Set.univ_pi_nonempty_iff
+-/
 
+#print Set.pi_eq_empty_iff /-
 theorem pi_eq_empty_iff : s.pi t = ∅ ↔ ∃ i, IsEmpty (α i) ∨ i ∈ s ∧ t i = ∅ :=
   by
   rw [← not_nonempty_iff_eq_empty, pi_nonempty_iff]
@@ -845,22 +1003,30 @@ theorem pi_eq_empty_iff : s.pi t = ∅ ↔ ∃ i, IsEmpty (α i) ∨ i ∈ s ∧
   refine' exists_congr fun i => _
   cases isEmpty_or_nonempty (α i) <;> simp [*, forall_and, eq_empty_iff_forall_not_mem]
 #align set.pi_eq_empty_iff Set.pi_eq_empty_iff
+-/
 
+#print Set.univ_pi_eq_empty_iff /-
 @[simp]
 theorem univ_pi_eq_empty_iff : pi univ t = ∅ ↔ ∃ i, t i = ∅ := by
   simp [← not_nonempty_iff_eq_empty, univ_pi_nonempty_iff]
 #align set.univ_pi_eq_empty_iff Set.univ_pi_eq_empty_iff
+-/
 
+#print Set.univ_pi_empty /-
 @[simp]
 theorem univ_pi_empty [h : Nonempty ι] : pi univ (fun i => ∅ : ∀ i, Set (α i)) = ∅ :=
   univ_pi_eq_empty_iff.2 <| h.elim fun x => ⟨x, rfl⟩
 #align set.univ_pi_empty Set.univ_pi_empty
+-/
 
+#print Set.disjoint_univ_pi /-
 @[simp]
 theorem disjoint_univ_pi : Disjoint (pi univ t₁) (pi univ t₂) ↔ ∃ i, Disjoint (t₁ i) (t₂ i) := by
   simp only [disjoint_iff_inter_eq_empty, ← pi_inter_distrib, univ_pi_eq_empty_iff]
 #align set.disjoint_univ_pi Set.disjoint_univ_pi
+-/
 
+#print Set.range_dcomp /-
 @[simp]
 theorem range_dcomp (f : ∀ i, α i → β i) :
     (range fun g : ∀ i, α i => fun i => f i (g i)) = pi univ fun i => range (f i) :=
@@ -871,11 +1037,14 @@ theorem range_dcomp (f : ∀ i, α i → β i) :
   · choose y hy using hx
     exact ⟨fun i => y i trivial, funext fun i => hy i trivial⟩
 #align set.range_dcomp Set.range_dcomp
+-/
 
+#print Set.insert_pi /-
 @[simp]
 theorem insert_pi (i : ι) (s : Set ι) (t : ∀ i, Set (α i)) :
     pi (insert i s) t = eval i ⁻¹' t i ∩ pi s t := by ext; simp [pi, or_imp, forall_and]
 #align set.insert_pi Set.insert_pi
+-/
 
 #print Set.singleton_pi /-
 @[simp]
@@ -889,15 +1058,20 @@ theorem singleton_pi' (i : ι) (t : ∀ i, Set (α i)) : pi {i} t = {x | x i ∈
 #align set.singleton_pi' Set.singleton_pi'
 -/
 
+#print Set.univ_pi_singleton /-
 theorem univ_pi_singleton (f : ∀ i, α i) : (pi univ fun i => {f i}) = ({f} : Set (∀ i, α i)) :=
   ext fun g => by simp [funext_iff]
 #align set.univ_pi_singleton Set.univ_pi_singleton
+-/
 
+#print Set.preimage_pi /-
 theorem preimage_pi (s : Set ι) (t : ∀ i, Set (β i)) (f : ∀ i, α i → β i) :
     (fun (g : ∀ i, α i) i => f _ (g i)) ⁻¹' s.pi t = s.pi fun i => f i ⁻¹' t i :=
   rfl
 #align set.preimage_pi Set.preimage_pi
+-/
 
+#print Set.pi_if /-
 theorem pi_if {p : ι → Prop} [h : DecidablePred p] (s : Set ι) (t₁ t₂ : ∀ i, Set (α i)) :
     (pi s fun i => if p i then t₁ i else t₂ i) = pi ({i ∈ s | p i}) t₁ ∩ pi ({i ∈ s | ¬p i}) t₂ :=
   by
@@ -907,21 +1081,29 @@ theorem pi_if {p : ι → Prop} [h : DecidablePred p] (s : Set ι) (t₁ t₂ :
   · rintro ⟨ht₁, ht₂⟩ i his
     by_cases p i <;> simp_all
 #align set.pi_if Set.pi_if
+-/
 
+#print Set.union_pi /-
 theorem union_pi : (s₁ ∪ s₂).pi t = s₁.pi t ∩ s₂.pi t := by
   simp [pi, or_imp, forall_and, set_of_and]
 #align set.union_pi Set.union_pi
+-/
 
+#print Set.pi_inter_compl /-
 @[simp]
 theorem pi_inter_compl (s : Set ι) : pi s t ∩ pi (sᶜ) t = pi univ t := by
   rw [← union_pi, union_compl_self]
 #align set.pi_inter_compl Set.pi_inter_compl
+-/
 
+#print Set.pi_update_of_not_mem /-
 theorem pi_update_of_not_mem [DecidableEq ι] (hi : i ∉ s) (f : ∀ j, α j) (a : α i)
     (t : ∀ j, α j → Set (β j)) : (s.pi fun j => t j (update f i a j)) = s.pi fun j => t j (f j) :=
   pi_congr rfl fun j hj => by rw [update_noteq]; exact fun h => hi (h ▸ hj)
 #align set.pi_update_of_not_mem Set.pi_update_of_not_mem
+-/
 
+#print Set.pi_update_of_mem /-
 theorem pi_update_of_mem [DecidableEq ι] (hi : i ∈ s) (f : ∀ j, α j) (a : α i)
     (t : ∀ j, α j → Set (β j)) :
     (s.pi fun j => t j (update f i a j)) = {x | x i ∈ t i a} ∩ (s \ {i}).pi fun j => t j (f j) :=
@@ -931,21 +1113,28 @@ theorem pi_update_of_mem [DecidableEq ι] (hi : i ∈ s) (f : ∀ j, α j) (a :
     _ = {x | x i ∈ t i a} ∩ (s \ {i}).pi fun j => t j (f j) := by
       rw [union_pi, singleton_pi', update_same, pi_update_of_not_mem]; simp
 #align set.pi_update_of_mem Set.pi_update_of_mem
+-/
 
+#print Set.univ_pi_update /-
 theorem univ_pi_update [DecidableEq ι] {β : ∀ i, Type _} (i : ι) (f : ∀ j, α j) (a : α i)
     (t : ∀ j, α j → Set (β j)) :
     (pi univ fun j => t j (update f i a j)) = {x | x i ∈ t i a} ∩ pi ({i}ᶜ) fun j => t j (f j) := by
   rw [compl_eq_univ_diff, ← pi_update_of_mem (mem_univ _)]
 #align set.univ_pi_update Set.univ_pi_update
+-/
 
+#print Set.univ_pi_update_univ /-
 theorem univ_pi_update_univ [DecidableEq ι] (i : ι) (s : Set (α i)) :
     pi univ (update (fun j : ι => (univ : Set (α j))) i s) = eval i ⁻¹' s := by
   rw [univ_pi_update i (fun j => (univ : Set (α j))) s fun j t => t, pi_univ, inter_univ, preimage]
 #align set.univ_pi_update_univ Set.univ_pi_update_univ
+-/
 
+#print Set.eval_image_pi_subset /-
 theorem eval_image_pi_subset (hs : i ∈ s) : eval i '' s.pi t ⊆ t i :=
   image_subset_iff.2 fun f hf => hf i hs
 #align set.eval_image_pi_subset Set.eval_image_pi_subset
+-/
 
 #print Set.eval_image_univ_pi_subset /-
 theorem eval_image_univ_pi_subset : eval i '' pi univ t ⊆ t i :=
@@ -953,22 +1142,28 @@ theorem eval_image_univ_pi_subset : eval i '' pi univ t ⊆ t i :=
 #align set.eval_image_univ_pi_subset Set.eval_image_univ_pi_subset
 -/
 
+#print Set.subset_eval_image_pi /-
 theorem subset_eval_image_pi (ht : (s.pi t).Nonempty) (i : ι) : t i ⊆ eval i '' s.pi t := by
   classical
   obtain ⟨f, hf⟩ := ht
   refine' fun y hy => ⟨update f i y, fun j hj => _, update_same _ _ _⟩
   obtain rfl | hji := eq_or_ne j i <;> simp [*, hf _ hj]
 #align set.subset_eval_image_pi Set.subset_eval_image_pi
+-/
 
+#print Set.eval_image_pi /-
 theorem eval_image_pi (hs : i ∈ s) (ht : (s.pi t).Nonempty) : eval i '' s.pi t = t i :=
   (eval_image_pi_subset hs).antisymm (subset_eval_image_pi ht i)
 #align set.eval_image_pi Set.eval_image_pi
+-/
 
+#print Set.eval_image_univ_pi /-
 @[simp]
 theorem eval_image_univ_pi (ht : (pi univ t).Nonempty) :
     (fun f : ∀ i, α i => f i) '' pi univ t = t i :=
   eval_image_pi (mem_univ i) ht
 #align set.eval_image_univ_pi Set.eval_image_univ_pi
+-/
 
 #print Set.pi_subset_pi_iff /-
 theorem pi_subset_pi_iff : pi s t₁ ⊆ pi s t₂ ↔ (∀ i ∈ s, t₁ i ⊆ t₂ i) ∨ pi s t₁ = ∅ :=
@@ -988,15 +1183,20 @@ theorem univ_pi_subset_univ_pi_iff : pi univ t₁ ⊆ pi univ t₂ ↔ (∀ i, t
 #align set.univ_pi_subset_univ_pi_iff Set.univ_pi_subset_univ_pi_iff
 -/
 
+#print Set.eval_preimage /-
 theorem eval_preimage [DecidableEq ι] {s : Set (α i)} :
     eval i ⁻¹' s = pi univ (update (fun i => univ) i s) := by ext x;
   simp [@forall_update_iff _ (fun i => Set (α i)) _ _ _ _ fun i' y => x i' ∈ y]
 #align set.eval_preimage Set.eval_preimage
+-/
 
+#print Set.eval_preimage' /-
 theorem eval_preimage' [DecidableEq ι] {s : Set (α i)} :
     eval i ⁻¹' s = pi {i} (update (fun i => univ) i s) := by ext; simp
 #align set.eval_preimage' Set.eval_preimage'
+-/
 
+#print Set.update_preimage_pi /-
 theorem update_preimage_pi [DecidableEq ι] {f : ∀ i, α i} (hi : i ∈ s)
     (hf : ∀ j ∈ s, j ≠ i → f j ∈ t j) : update f i ⁻¹' s.pi t = t i :=
   by
@@ -1009,21 +1209,28 @@ theorem update_preimage_pi [DecidableEq ι] {f : ∀ i, α i} (hi : i ∈ s)
     · rw [update_noteq h]
       exact hf j hj h
 #align set.update_preimage_pi Set.update_preimage_pi
+-/
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (j «expr ≠ » i) -/
+#print Set.update_preimage_univ_pi /-
 theorem update_preimage_univ_pi [DecidableEq ι] {f : ∀ i, α i} (hf : ∀ (j) (_ : j ≠ i), f j ∈ t j) :
     update f i ⁻¹' pi univ t = t i :=
   update_preimage_pi (mem_univ i) fun j _ => hf j
 #align set.update_preimage_univ_pi Set.update_preimage_univ_pi
+-/
 
+#print Set.subset_pi_eval_image /-
 theorem subset_pi_eval_image (s : Set ι) (u : Set (∀ i, α i)) : u ⊆ pi s fun i => eval i '' u :=
   fun f hf i hi => ⟨f, hf, rfl⟩
 #align set.subset_pi_eval_image Set.subset_pi_eval_image
+-/
 
+#print Set.univ_pi_ite /-
 theorem univ_pi_ite (s : Set ι) [DecidablePred (· ∈ s)] (t : ∀ i, Set (α i)) :
     (pi univ fun i => if i ∈ s then t i else univ) = s.pi t := by ext; simp_rw [mem_univ_pi];
   refine' forall_congr' fun i => _; split_ifs <;> simp [h]
 #align set.univ_pi_ite Set.univ_pi_ite
+-/
 
 end Pi

bump to nightly-2023-06-09-07

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

16afdc39

Diff

@@ -930,7 +930,6 @@ theorem pi_update_of_mem [DecidableEq ι] (hi : i ∈ s) (f : ∀ j, α j) (a :
       rw [union_diff_self, union_eq_self_of_subset_left (singleton_subset_iff.2 hi)]
     _ = {x | x i ∈ t i a} ∩ (s \ {i}).pi fun j => t j (f j) := by
       rw [union_pi, singleton_pi', update_same, pi_update_of_not_mem]; simp
-    
 #align set.pi_update_of_mem Set.pi_update_of_mem
 
 theorem univ_pi_update [DecidableEq ι] {β : ∀ i, Type _} (i : ι) (f : ∀ j, α j) (a : α i)

bump to nightly-2023-06-08-23

mathlib commit https://github.com/leanprover-community/mathlib/commit/31c24aa72e7b3e5ed97a8412470e904f82b81004

d3cfe2e3

Diff

@@ -1011,7 +1011,7 @@ theorem update_preimage_pi [DecidableEq ι] {f : ∀ i, α i} (hi : i ∈ s)
       exact hf j hj h
 #align set.update_preimage_pi Set.update_preimage_pi
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (j «expr ≠ » i) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (j «expr ≠ » i) -/
 theorem update_preimage_univ_pi [DecidableEq ι] {f : ∀ i, α i} (hf : ∀ (j) (_ : j ≠ i), f j ∈ t j) :
     update f i ⁻¹' pi univ t = t i :=
   update_preimage_pi (mem_univ i) fun j _ => hf j

bump to nightly-2023-06-04-18

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

3fb4268b

Diff

@@ -43,7 +43,7 @@ variable {α β γ δ : Type _} {s s₁ s₂ : Set α} {t t₁ t₂ : Set β} {a
 #print Set.prod /-
 /-- The cartesian product `prod s t` is the set of `(a, b)` such that `a ∈ s` and `b ∈ t`. -/
 def prod (s : Set α) (t : Set β) : Set (α × β) :=
-  { p | p.1 ∈ s ∧ p.2 ∈ t }
+  {p | p.1 ∈ s ∧ p.2 ∈ t}
 #align set.prod Set.prod
 -/
 
@@ -577,7 +577,7 @@ variable {α : Type _} {s t : Set α}
 #print Set.diagonal /-
 /-- `diagonal α` is the set of `α × α` consisting of all pairs of the form `(a, a)`. -/
 def diagonal (α : Type _) : Set (α × α) :=
-  { p | p.1 = p.2 }
+  {p | p.1 = p.2}
 #align set.diagonal Set.diagonal
 -/
 
@@ -661,7 +661,7 @@ variable {α : Type _} {s t : Set α} {x : α × α} {a : α}
 #print Set.offDiag /-
 /-- The off-diagonal of a set `s` is the set of pairs `(a, b)` with `a, b ∈ s` and `a ≠ b`. -/
 def offDiag (s : Set α) : Set (α × α) :=
-  { x | x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2 }
+  {x | x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2}
 #align set.off_diag Set.offDiag
 -/
 
@@ -706,7 +706,7 @@ theorem offDiag_subset_prod : s.offDiag ⊆ s ×ˢ s := fun x hx => ⟨hx.1, hx.
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.offDiag_eq_sep_prod /-
-theorem offDiag_eq_sep_prod : s.offDiag = { x ∈ s ×ˢ s | x.1 ≠ x.2 } :=
+theorem offDiag_eq_sep_prod : s.offDiag = {x ∈ s ×ˢ s | x.1 ≠ x.2} :=
   ext fun _ => and_assoc.symm
 #align set.off_diag_eq_sep_prod Set.offDiag_eq_sep_prod
 -/
@@ -783,7 +783,7 @@ variable {ι : Type _} {α β : ι → Type _} {s s₁ s₂ : Set ι} {t t₁ t
 is the set of dependent functions `f : Πa, π a` such that `f a` belongs to `t a`
 whenever `a ∈ s`. -/
 def pi (s : Set ι) (t : ∀ i, Set (α i)) : Set (∀ i, α i) :=
-  { f | ∀ i ∈ s, f i ∈ t i }
+  {f | ∀ i ∈ s, f i ∈ t i}
 #align set.pi Set.pi
 -/
 
@@ -884,7 +884,7 @@ theorem singleton_pi (i : ι) (t : ∀ i, Set (α i)) : pi {i} t = eval i ⁻¹'
 -/
 
 #print Set.singleton_pi' /-
-theorem singleton_pi' (i : ι) (t : ∀ i, Set (α i)) : pi {i} t = { x | x i ∈ t i } :=
+theorem singleton_pi' (i : ι) (t : ∀ i, Set (α i)) : pi {i} t = {x | x i ∈ t i} :=
   singleton_pi i t
 #align set.singleton_pi' Set.singleton_pi'
 -/
@@ -899,8 +899,7 @@ theorem preimage_pi (s : Set ι) (t : ∀ i, Set (β i)) (f : ∀ i, α i → β
 #align set.preimage_pi Set.preimage_pi
 
 theorem pi_if {p : ι → Prop} [h : DecidablePred p] (s : Set ι) (t₁ t₂ : ∀ i, Set (α i)) :
-    (pi s fun i => if p i then t₁ i else t₂ i) =
-      pi ({ i ∈ s | p i }) t₁ ∩ pi ({ i ∈ s | ¬p i }) t₂ :=
+    (pi s fun i => if p i then t₁ i else t₂ i) = pi ({i ∈ s | p i}) t₁ ∩ pi ({i ∈ s | ¬p i}) t₂ :=
   by
   ext f
   refine' ⟨fun h => _, _⟩
@@ -925,19 +924,19 @@ theorem pi_update_of_not_mem [DecidableEq ι] (hi : i ∉ s) (f : ∀ j, α j) (
 
 theorem pi_update_of_mem [DecidableEq ι] (hi : i ∈ s) (f : ∀ j, α j) (a : α i)
     (t : ∀ j, α j → Set (β j)) :
-    (s.pi fun j => t j (update f i a j)) = { x | x i ∈ t i a } ∩ (s \ {i}).pi fun j => t j (f j) :=
+    (s.pi fun j => t j (update f i a j)) = {x | x i ∈ t i a} ∩ (s \ {i}).pi fun j => t j (f j) :=
   calc
     (s.pi fun j => t j (update f i a j)) = ({i} ∪ s \ {i}).pi fun j => t j (update f i a j) := by
       rw [union_diff_self, union_eq_self_of_subset_left (singleton_subset_iff.2 hi)]
-    _ = { x | x i ∈ t i a } ∩ (s \ {i}).pi fun j => t j (f j) := by
+    _ = {x | x i ∈ t i a} ∩ (s \ {i}).pi fun j => t j (f j) := by
       rw [union_pi, singleton_pi', update_same, pi_update_of_not_mem]; simp
     
 #align set.pi_update_of_mem Set.pi_update_of_mem
 
 theorem univ_pi_update [DecidableEq ι] {β : ∀ i, Type _} (i : ι) (f : ∀ j, α j) (a : α i)
     (t : ∀ j, α j → Set (β j)) :
-    (pi univ fun j => t j (update f i a j)) = { x | x i ∈ t i a } ∩ pi ({i}ᶜ) fun j => t j (f j) :=
-  by rw [compl_eq_univ_diff, ← pi_update_of_mem (mem_univ _)]
+    (pi univ fun j => t j (update f i a j)) = {x | x i ∈ t i a} ∩ pi ({i}ᶜ) fun j => t j (f j) := by
+  rw [compl_eq_univ_diff, ← pi_update_of_mem (mem_univ _)]
 #align set.univ_pi_update Set.univ_pi_update
 
 theorem univ_pi_update_univ [DecidableEq ι] (i : ι) (s : Set (α i)) :
@@ -957,9 +956,9 @@ theorem eval_image_univ_pi_subset : eval i '' pi univ t ⊆ t i :=
 
 theorem subset_eval_image_pi (ht : (s.pi t).Nonempty) (i : ι) : t i ⊆ eval i '' s.pi t := by
   classical
-    obtain ⟨f, hf⟩ := ht
-    refine' fun y hy => ⟨update f i y, fun j hj => _, update_same _ _ _⟩
-    obtain rfl | hji := eq_or_ne j i <;> simp [*, hf _ hj]
+  obtain ⟨f, hf⟩ := ht
+  refine' fun y hy => ⟨update f i y, fun j hj => _, update_same _ _ _⟩
+  obtain rfl | hji := eq_or_ne j i <;> simp [*, hf _ hj]
 #align set.subset_eval_image_pi Set.subset_eval_image_pi
 
 theorem eval_image_pi (hs : i ∈ s) (ht : (s.pi t).Nonempty) : eval i '' s.pi t = t i :=

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -480,14 +480,14 @@ theorem prod_subset_prod_iff : s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t
   by
   cases' (s ×ˢ t).eq_empty_or_nonempty with h h
   · simp [h, prod_eq_empty_iff.1 h]
-  have st : s.nonempty ∧ t.nonempty := by rwa [prod_nonempty_iff] at h
+  have st : s.nonempty ∧ t.nonempty := by rwa [prod_nonempty_iff] at h 
   refine' ⟨fun H => Or.inl ⟨_, _⟩, _⟩
   · have := image_subset (Prod.fst : α × β → α) H
-    rwa [fst_image_prod _ st.2, fst_image_prod _ (h.mono H).snd] at this
+    rwa [fst_image_prod _ st.2, fst_image_prod _ (h.mono H).snd] at this 
   · have := image_subset (Prod.snd : α × β → β) H
-    rwa [snd_image_prod st.1, snd_image_prod (h.mono H).fst] at this
+    rwa [snd_image_prod st.1, snd_image_prod (h.mono H).fst] at this 
   · intro H
-    simp only [st.1.ne_empty, st.2.ne_empty, or_false_iff] at H
+    simp only [st.1.ne_empty, st.2.ne_empty, or_false_iff] at H 
     exact prod_mono H.1 H.2
 #align set.prod_subset_prod_iff Set.prod_subset_prod_iff
 
@@ -500,7 +500,7 @@ theorem prod_eq_prod_iff_of_nonempty (h : (s ×ˢ t).Nonempty) :
   constructor
   · intro heq
     have h₁ : (s₁ ×ˢ t₁ : Set _).Nonempty := by rwa [← HEq]
-    rw [prod_nonempty_iff] at h h₁
+    rw [prod_nonempty_iff] at h h₁ 
     rw [← fst_image_prod s h.2, ← fst_image_prod s₁ h₁.2, HEq, eq_self_iff_true, true_and_iff, ←
       snd_image_prod h.1 t, ← snd_image_prod h₁.1 t₁, HEq]
   · rintro ⟨rfl, rfl⟩; rfl
@@ -518,7 +518,7 @@ theorem prod_eq_prod_iff :
       or_iff_right_iff_imp]
     rintro ⟨rfl, rfl⟩; exact prod_eq_empty_iff.mp h
   rw [prod_eq_prod_iff_of_nonempty h]
-  rw [nonempty_iff_ne_empty, Ne.def, prod_eq_empty_iff] at h
+  rw [nonempty_iff_ne_empty, Ne.def, prod_eq_empty_iff] at h 
   simp_rw [h, false_and_iff, or_false_iff]
 #align set.prod_eq_prod_iff Set.prod_eq_prod_iff

bump to nightly-2023-05-28-16

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

b51961d2

Diff

@@ -245,10 +245,12 @@ theorem prod_preimage_eq {f : γ → α} {g : δ → β} :
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_preimage_left /-
 theorem prod_preimage_left {f : γ → α} :
     (f ⁻¹' s) ×ˢ t = (fun p : γ × β => (f p.1, p.2)) ⁻¹' s ×ˢ t :=
   rfl
 #align set.prod_preimage_left Set.prod_preimage_left
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -355,10 +357,12 @@ theorem range_prod_map {m₁ : α → γ} {m₂ : β → δ} : range (Prod.map m
 #align set.range_prod_map Set.range_prod_map
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
+#print Set.prod_range_univ_eq /-
 theorem prod_range_univ_eq {m₁ : α → γ} :
     range m₁ ×ˢ (univ : Set β) = range fun p : α × β => (m₁ p.1, p.2) :=
   ext <| by simp [range]
 #align set.prod_range_univ_eq Set.prod_range_univ_eq
+-/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_univ_range_eq {m₂ : β → δ} :
@@ -470,7 +474,6 @@ theorem prod_diff_prod : s ×ˢ t \ s₁ ×ˢ t₁ = s ×ˢ (t \ t₁) ∪ (s \
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-#print Set.prod_subset_prod_iff /-
 /-- A product set is included in a product set if and only factors are included, or a factor of the
 first set is empty. -/
 theorem prod_subset_prod_iff : s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t ⊆ t₁ ∨ s = ∅ ∨ t = ∅ :=
@@ -487,7 +490,6 @@ theorem prod_subset_prod_iff : s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t
     simp only [st.1.ne_empty, st.2.ne_empty, or_false_iff] at H
     exact prod_mono H.1 H.2
 #align set.prod_subset_prod_iff Set.prod_subset_prod_iff
--/
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -52,34 +52,16 @@ infixr:82
   " ×ˢ " =>-- This notation binds more strongly than (pre)images, unions and intersections.
   Set.prod
 
-/- warning: set.prod_eq -> Set.prod_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Set.{u1} α) (t : Set.{u2} β), Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s t) (Inter.inter.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasInter.{max u1 u2} (Prod.{u1, u2} α β)) (Set.preimage.{max u1 u2, u1} (Prod.{u1, u2} α β) α (Prod.fst.{u1, u2} α β) s) (Set.preimage.{max u1 u2, u2} (Prod.{u1, u2} α β) β (Prod.snd.{u1, u2} α β) t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (s : Set.{u2} α) (t : Set.{u1} β), Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s t) (Inter.inter.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instInterSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.preimage.{max u1 u2, u2} (Prod.{u2, u1} α β) α (Prod.fst.{u2, u1} α β) s) (Set.preimage.{max u2 u1, u1} (Prod.{u2, u1} α β) β (Prod.snd.{u2, u1} α β) t))
-Case conversion may be inaccurate. Consider using '#align set.prod_eq Set.prod_eqₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_eq (s : Set α) (t : Set β) : s ×ˢ t = Prod.fst ⁻¹' s ∩ Prod.snd ⁻¹' t :=
   rfl
 #align set.prod_eq Set.prod_eq
 
-/- warning: set.mem_prod_eq -> Set.mem_prod_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β} {p : Prod.{u1, u2} α β}, Eq.{1} Prop (Membership.Mem.{max u1 u2, max u1 u2} (Prod.{u1, u2} α β) (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasMem.{max u1 u2} (Prod.{u1, u2} α β)) p (Set.prod.{u1, u2} α β s t)) (And (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (Prod.fst.{u1, u2} α β p) s) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (Prod.snd.{u1, u2} α β p) t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β} {p : Prod.{u2, u1} α β}, Eq.{1} Prop (Membership.mem.{max u2 u1, max u1 u2} (Prod.{u2, u1} α β) (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instMembershipSet.{max u2 u1} (Prod.{u2, u1} α β)) p (Set.prod.{u2, u1} α β s t)) (And (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) (Prod.fst.{u2, u1} α β p) s) (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) (Prod.snd.{u2, u1} α β p) t))
-Case conversion may be inaccurate. Consider using '#align set.mem_prod_eq Set.mem_prod_eqₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem mem_prod_eq {p : α × β} : (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) :=
   rfl
 #align set.mem_prod_eq Set.mem_prod_eq
 
-/- warning: set.mem_prod -> Set.mem_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β} {p : Prod.{u1, u2} α β}, Iff (Membership.Mem.{max u1 u2, max u1 u2} (Prod.{u1, u2} α β) (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasMem.{max u1 u2} (Prod.{u1, u2} α β)) p (Set.prod.{u1, u2} α β s t)) (And (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (Prod.fst.{u1, u2} α β p) s) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) (Prod.snd.{u1, u2} α β p) t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β} {p : Prod.{u2, u1} α β}, Iff (Membership.mem.{max u2 u1, max u1 u2} (Prod.{u2, u1} α β) (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instMembershipSet.{max u2 u1} (Prod.{u2, u1} α β)) p (Set.prod.{u2, u1} α β s t)) (And (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) (Prod.fst.{u2, u1} α β p) s) (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) (Prod.snd.{u2, u1} α β p) t))
-Case conversion may be inaccurate. Consider using '#align set.mem_prod Set.mem_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem mem_prod {p : α × β} : p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t :=
@@ -94,12 +76,6 @@ theorem prod_mk_mem_set_prod_eq : ((a, b) ∈ s ×ˢ t) = (a ∈ s ∧ b ∈ t)
 #align set.prod_mk_mem_set_prod_eq Set.prod_mk_mem_set_prod_eq
 -/
 
-/- warning: set.mk_mem_prod -> Set.mk_mem_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β} {a : α} {b : β}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b t) -> (Membership.Mem.{max u1 u2, max u1 u2} (Prod.{u1, u2} α β) (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasMem.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.mk.{u1, u2} α β a b) (Set.prod.{u1, u2} α β s t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β} {a : α} {b : β}, (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) a s) -> (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b t) -> (Membership.mem.{max u1 u2, max u1 u2} (Prod.{u2, u1} α β) (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instMembershipSet.{max u2 u1} (Prod.{u2, u1} α β)) (Prod.mk.{u2, u1} α β a b) (Set.prod.{u2, u1} α β s t))
-Case conversion may be inaccurate. Consider using '#align set.mk_mem_prod Set.mk_mem_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem mk_mem_prod (ha : a ∈ s) (hb : b ∈ t) : (a, b) ∈ s ×ˢ t :=
   ⟨ha, hb⟩
@@ -112,24 +88,12 @@ instance decidableMemProd [hs : DecidablePred (· ∈ s)] [ht : DecidablePred (
 #align set.decidable_mem_prod Set.decidableMemProd
 -/
 
-/- warning: set.prod_mono -> Set.prod_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t₁ : Set.{u2} β} {t₂ : Set.{u2} β}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s₁ s₂) -> (HasSubset.Subset.{u2} (Set.{u2} β) (Set.hasSubset.{u2} β) t₁ t₂) -> (HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasSubset.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s₁ t₁) (Set.prod.{u1, u2} α β s₂ t₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s₁ : Set.{u2} α} {s₂ : Set.{u2} α} {t₁ : Set.{u1} β} {t₂ : Set.{u1} β}, (HasSubset.Subset.{u2} (Set.{u2} α) (Set.instHasSubsetSet.{u2} α) s₁ s₂) -> (HasSubset.Subset.{u1} (Set.{u1} β) (Set.instHasSubsetSet.{u1} β) t₁ t₂) -> (HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instHasSubsetSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s₁ t₁) (Set.prod.{u2, u1} α β s₂ t₂))
-Case conversion may be inaccurate. Consider using '#align set.prod_mono Set.prod_monoₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : s₁ ×ˢ t₁ ⊆ s₂ ×ˢ t₂ := fun x ⟨h₁, h₂⟩ =>
   ⟨hs h₁, ht h₂⟩
 #align set.prod_mono Set.prod_mono
 
-/- warning: set.prod_mono_left -> Set.prod_mono_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u2} β}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s₁ s₂) -> (HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasSubset.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s₁ t) (Set.prod.{u1, u2} α β s₂ t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s₁ : Set.{u2} α} {s₂ : Set.{u2} α} {t : Set.{u1} β}, (HasSubset.Subset.{u2} (Set.{u2} α) (Set.instHasSubsetSet.{u2} α) s₁ s₂) -> (HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instHasSubsetSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s₁ t) (Set.prod.{u2, u1} α β s₂ t))
-Case conversion may be inaccurate. Consider using '#align set.prod_mono_left Set.prod_mono_leftₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_mono_left (hs : s₁ ⊆ s₂) : s₁ ×ˢ t ⊆ s₂ ×ˢ t :=
@@ -153,12 +117,6 @@ theorem prod_self_subset_prod_self : s₁ ×ˢ s₁ ⊆ s₂ ×ˢ s₂ ↔ s₁
 #align set.prod_self_subset_prod_self Set.prod_self_subset_prod_self
 -/
 
-/- warning: set.prod_self_ssubset_prod_self -> Set.prod_self_ssubset_prod_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, Iff (HasSSubset.SSubset.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.hasSsubset.{u1} (Prod.{u1, u1} α α)) (Set.prod.{u1, u1} α α s₁ s₁) (Set.prod.{u1, u1} α α s₂ s₂)) (HasSSubset.SSubset.{u1} (Set.{u1} α) (Set.hasSsubset.{u1} α) s₁ s₂)
-but is expected to have type
-  forall {α : Type.{u1}} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α}, Iff (HasSSubset.SSubset.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instHasSSubsetSet.{u1} (Prod.{u1, u1} α α)) (Set.prod.{u1, u1} α α s₁ s₁) (Set.prod.{u1, u1} α α s₂ s₂)) (HasSSubset.SSubset.{u1} (Set.{u1} α) (Set.instHasSSubsetSet.{u1} α) s₁ s₂)
-Case conversion may be inaccurate. Consider using '#align set.prod_self_ssubset_prod_self Set.prod_self_ssubset_prod_selfₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
@@ -173,56 +131,26 @@ theorem prod_subset_iff {P : Set (α × β)} : s ×ˢ t ⊆ P ↔ ∀ x ∈ s, 
 #align set.prod_subset_iff Set.prod_subset_iff
 -/
 
-/- warning: set.forall_prod_set -> Set.forall_prod_set is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β} {p : (Prod.{u1, u2} α β) -> Prop}, Iff (forall (x : Prod.{u1, u2} α β), (Membership.Mem.{max u1 u2, max u1 u2} (Prod.{u1, u2} α β) (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasMem.{max u1 u2} (Prod.{u1, u2} α β)) x (Set.prod.{u1, u2} α β s t)) -> (p x)) (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (forall (y : β), (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) y t) -> (p (Prod.mk.{u1, u2} α β x y))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β} {p : (Prod.{u2, u1} α β) -> Prop}, Iff (forall (x : Prod.{u2, u1} α β), (Membership.mem.{max u2 u1, max u1 u2} (Prod.{u2, u1} α β) (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instMembershipSet.{max u2 u1} (Prod.{u2, u1} α β)) x (Set.prod.{u2, u1} α β s t)) -> (p x)) (forall (x : α), (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) x s) -> (forall (y : β), (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) y t) -> (p (Prod.mk.{u2, u1} α β x y))))
-Case conversion may be inaccurate. Consider using '#align set.forall_prod_set Set.forall_prod_setₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem forall_prod_set {p : α × β → Prop} : (∀ x ∈ s ×ˢ t, p x) ↔ ∀ x ∈ s, ∀ y ∈ t, p (x, y) :=
   prod_subset_iff
 #align set.forall_prod_set Set.forall_prod_set
 
-/- warning: set.exists_prod_set -> Set.exists_prod_set is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β} {p : (Prod.{u1, u2} α β) -> Prop}, Iff (Exists.{succ (max u1 u2)} (Prod.{u1, u2} α β) (fun (x : Prod.{u1, u2} α β) => Exists.{0} (Membership.Mem.{max u1 u2, max u1 u2} (Prod.{u1, u2} α β) (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasMem.{max u1 u2} (Prod.{u1, u2} α β)) x (Set.prod.{u1, u2} α β s t)) (fun (H : Membership.Mem.{max u1 u2, max u1 u2} (Prod.{u1, u2} α β) (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasMem.{max u1 u2} (Prod.{u1, u2} α β)) x (Set.prod.{u1, u2} α β s t)) => p x))) (Exists.{succ u1} α (fun (x : α) => Exists.{0} (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) (fun (H : Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) => Exists.{succ u2} β (fun (y : β) => Exists.{0} (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) y t) (fun (H : Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) y t) => p (Prod.mk.{u1, u2} α β x y))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β} {p : (Prod.{u2, u1} α β) -> Prop}, Iff (Exists.{succ (max u2 u1)} (Prod.{u2, u1} α β) (fun (x : Prod.{u2, u1} α β) => And (Membership.mem.{max u2 u1, max u1 u2} (Prod.{u2, u1} α β) (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instMembershipSet.{max u2 u1} (Prod.{u2, u1} α β)) x (Set.prod.{u2, u1} α β s t)) (p x))) (Exists.{succ u2} α (fun (x : α) => And (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) x s) (Exists.{succ u1} β (fun (y : β) => And (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) y t) (p (Prod.mk.{u2, u1} α β x y))))))
-Case conversion may be inaccurate. Consider using '#align set.exists_prod_set Set.exists_prod_setₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem exists_prod_set {p : α × β → Prop} : (∃ x ∈ s ×ˢ t, p x) ↔ ∃ x ∈ s, ∃ y ∈ t, p (x, y) := by
   simp [and_assoc']
 #align set.exists_prod_set Set.exists_prod_set
 
-/- warning: set.prod_empty -> Set.prod_empty is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s (EmptyCollection.emptyCollection.{u2} (Set.{u2} β) (Set.hasEmptyc.{u2} β))) (EmptyCollection.emptyCollection.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasEmptyc.{max u1 u2} (Prod.{u1, u2} α β)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s (EmptyCollection.emptyCollection.{u1} (Set.{u1} β) (Set.instEmptyCollectionSet.{u1} β))) (EmptyCollection.emptyCollection.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instEmptyCollectionSet.{max u2 u1} (Prod.{u2, u1} α β)))
-Case conversion may be inaccurate. Consider using '#align set.prod_empty Set.prod_emptyₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem prod_empty : s ×ˢ (∅ : Set β) = ∅ := by ext; exact and_false_iff _
 #align set.prod_empty Set.prod_empty
 
-/- warning: set.empty_prod -> Set.empty_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {t : Set.{u2} β}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)) t) (EmptyCollection.emptyCollection.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasEmptyc.{max u1 u2} (Prod.{u1, u2} α β)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {t : Set.{u1} β}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β (EmptyCollection.emptyCollection.{u2} (Set.{u2} α) (Set.instEmptyCollectionSet.{u2} α)) t) (EmptyCollection.emptyCollection.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instEmptyCollectionSet.{max u2 u1} (Prod.{u2, u1} α β)))
-Case conversion may be inaccurate. Consider using '#align set.empty_prod Set.empty_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem empty_prod : (∅ : Set α) ×ˢ t = ∅ := by ext; exact false_and_iff _
 #align set.empty_prod Set.empty_prod
 
-/- warning: set.univ_prod_univ -> Set.univ_prod_univ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β (Set.univ.{u1} α) (Set.univ.{u2} β)) (Set.univ.{max u1 u2} (Prod.{u1, u2} α β))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β (Set.univ.{u2} α) (Set.univ.{u1} β)) (Set.univ.{max u2 u1} (Prod.{u2, u1} α β))
-Case conversion may be inaccurate. Consider using '#align set.univ_prod_univ Set.univ_prod_univₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem univ_prod_univ : @univ α ×ˢ @univ β = univ := by ext; exact true_and_iff _
@@ -234,56 +162,26 @@ theorem univ_prod {t : Set β} : (univ : Set α) ×ˢ t = Prod.snd ⁻¹' t := b
 #align set.univ_prod Set.univ_prod
 -/
 
-/- warning: set.prod_univ -> Set.prod_univ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s (Set.univ.{u2} β)) (Set.preimage.{max u1 u2, u1} (Prod.{u1, u2} α β) α (Prod.fst.{u1, u2} α β) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s (Set.univ.{u1} β)) (Set.preimage.{max u1 u2, u2} (Prod.{u2, u1} α β) α (Prod.fst.{u2, u1} α β) s)
-Case conversion may be inaccurate. Consider using '#align set.prod_univ Set.prod_univₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_univ {s : Set α} : s ×ˢ (univ : Set β) = Prod.fst ⁻¹' s := by simp [prod_eq]
 #align set.prod_univ Set.prod_univ
 
-/- warning: set.singleton_prod -> Set.singleton_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {t : Set.{u2} β} {a : α}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) t) (Set.image.{u2, max u1 u2} β (Prod.{u1, u2} α β) (Prod.mk.{u1, u2} α β a) t)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {t : Set.{u1} β} {a : α}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β (Singleton.singleton.{u2, u2} α (Set.{u2} α) (Set.instSingletonSet.{u2} α) a) t) (Set.image.{u1, max u1 u2} β (Prod.{u2, u1} α β) (Prod.mk.{u2, u1} α β a) t)
-Case conversion may be inaccurate. Consider using '#align set.singleton_prod Set.singleton_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem singleton_prod : ({a} : Set α) ×ˢ t = Prod.mk a '' t := by ext ⟨x, y⟩;
   simp [and_left_comm, eq_comm]
 #align set.singleton_prod Set.singleton_prod
 
-/- warning: set.prod_singleton -> Set.prod_singleton is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {b : β}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s (Singleton.singleton.{u2, u2} β (Set.{u2} β) (Set.hasSingleton.{u2} β) b)) (Set.image.{u1, max u1 u2} α (Prod.{u1, u2} α β) (fun (a : α) => Prod.mk.{u1, u2} α β a b) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {b : β}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s (Singleton.singleton.{u1, u1} β (Set.{u1} β) (Set.instSingletonSet.{u1} β) b)) (Set.image.{u2, max u1 u2} α (Prod.{u2, u1} α β) (fun (a : α) => Prod.mk.{u2, u1} α β a b) s)
-Case conversion may be inaccurate. Consider using '#align set.prod_singleton Set.prod_singletonₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem prod_singleton : s ×ˢ ({b} : Set β) = (fun a => (a, b)) '' s := by ext ⟨x, y⟩;
   simp [and_left_comm, eq_comm]
 #align set.prod_singleton Set.prod_singleton
 
-/- warning: set.singleton_prod_singleton -> Set.singleton_prod_singleton is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {a : α} {b : β}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) (Singleton.singleton.{u2, u2} β (Set.{u2} β) (Set.hasSingleton.{u2} β) b)) (Singleton.singleton.{max u1 u2, max u1 u2} (Prod.{u1, u2} α β) (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasSingleton.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.mk.{u1, u2} α β a b))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {a : α} {b : β}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β (Singleton.singleton.{u2, u2} α (Set.{u2} α) (Set.instSingletonSet.{u2} α) a) (Singleton.singleton.{u1, u1} β (Set.{u1} β) (Set.instSingletonSet.{u1} β) b)) (Singleton.singleton.{max u1 u2, max u2 u1} (Prod.{u2, u1} α β) (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instSingletonSet.{max u2 u1} (Prod.{u2, u1} α β)) (Prod.mk.{u2, u1} α β a b))
-Case conversion may be inaccurate. Consider using '#align set.singleton_prod_singleton Set.singleton_prod_singletonₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem singleton_prod_singleton : ({a} : Set α) ×ˢ ({b} : Set β) = {(a, b)} := by simp
 #align set.singleton_prod_singleton Set.singleton_prod_singleton
 
-/- warning: set.union_prod -> Set.union_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u2} β}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s₁ s₂) t) (Union.union.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasUnion.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s₁ t) (Set.prod.{u1, u2} α β s₂ t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s₁ : Set.{u2} α} {s₂ : Set.{u2} α} {t : Set.{u1} β}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β (Union.union.{u2} (Set.{u2} α) (Set.instUnionSet.{u2} α) s₁ s₂) t) (Union.union.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instUnionSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s₁ t) (Set.prod.{u2, u1} α β s₂ t))
-Case conversion may be inaccurate. Consider using '#align set.union_prod Set.union_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -291,12 +189,6 @@ Case conversion may be inaccurate. Consider using '#align set.union_prod Set.uni
 theorem union_prod : (s₁ ∪ s₂) ×ˢ t = s₁ ×ˢ t ∪ s₂ ×ˢ t := by ext ⟨x, y⟩; simp [or_and_right]
 #align set.union_prod Set.union_prod
 
-/- warning: set.prod_union -> Set.prod_union is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t₁ : Set.{u2} β} {t₂ : Set.{u2} β}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s (Union.union.{u2} (Set.{u2} β) (Set.hasUnion.{u2} β) t₁ t₂)) (Union.union.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasUnion.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s t₁) (Set.prod.{u1, u2} α β s t₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t₁ : Set.{u1} β} {t₂ : Set.{u1} β}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s (Union.union.{u1} (Set.{u1} β) (Set.instUnionSet.{u1} β) t₁ t₂)) (Union.union.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instUnionSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s t₁) (Set.prod.{u2, u1} α β s t₂))
-Case conversion may be inaccurate. Consider using '#align set.prod_union Set.prod_unionₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -304,12 +196,6 @@ Case conversion may be inaccurate. Consider using '#align set.prod_union Set.pro
 theorem prod_union : s ×ˢ (t₁ ∪ t₂) = s ×ˢ t₁ ∪ s ×ˢ t₂ := by ext ⟨x, y⟩; simp [and_or_left]
 #align set.prod_union Set.prod_union
 
-/- warning: set.inter_prod -> Set.inter_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t : Set.{u2} β}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s₁ s₂) t) (Inter.inter.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasInter.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s₁ t) (Set.prod.{u1, u2} α β s₂ t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s₁ : Set.{u2} α} {s₂ : Set.{u2} α} {t : Set.{u1} β}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β (Inter.inter.{u2} (Set.{u2} α) (Set.instInterSet.{u2} α) s₁ s₂) t) (Inter.inter.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instInterSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s₁ t) (Set.prod.{u2, u1} α β s₂ t))
-Case conversion may be inaccurate. Consider using '#align set.inter_prod Set.inter_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -317,12 +203,6 @@ theorem inter_prod : (s₁ ∩ s₂) ×ˢ t = s₁ ×ˢ t ∩ s₂ ×ˢ t := by
   simp only [← and_and_right, mem_inter_iff, mem_prod]
 #align set.inter_prod Set.inter_prod
 
-/- warning: set.prod_inter -> Set.prod_inter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t₁ : Set.{u2} β} {t₂ : Set.{u2} β}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s (Inter.inter.{u2} (Set.{u2} β) (Set.hasInter.{u2} β) t₁ t₂)) (Inter.inter.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasInter.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s t₁) (Set.prod.{u1, u2} α β s t₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t₁ : Set.{u1} β} {t₂ : Set.{u1} β}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s (Inter.inter.{u1} (Set.{u1} β) (Set.instInterSet.{u1} β) t₁ t₂)) (Inter.inter.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instInterSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s t₁) (Set.prod.{u2, u1} α β s t₂))
-Case conversion may be inaccurate. Consider using '#align set.prod_inter Set.prod_interₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -330,12 +210,6 @@ theorem prod_inter : s ×ˢ (t₁ ∩ t₂) = s ×ˢ t₁ ∩ s ×ˢ t₂ := by
   simp only [← and_and_left, mem_inter_iff, mem_prod]
 #align set.prod_inter Set.prod_inter
 
-/- warning: set.prod_inter_prod -> Set.prod_inter_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t₁ : Set.{u2} β} {t₂ : Set.{u2} β}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Inter.inter.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasInter.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s₁ t₁) (Set.prod.{u1, u2} α β s₂ t₂)) (Set.prod.{u1, u2} α β (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s₁ s₂) (Inter.inter.{u2} (Set.{u2} β) (Set.hasInter.{u2} β) t₁ t₂))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s₁ : Set.{u2} α} {s₂ : Set.{u2} α} {t₁ : Set.{u1} β} {t₂ : Set.{u1} β}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Inter.inter.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instInterSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s₁ t₁) (Set.prod.{u2, u1} α β s₂ t₂)) (Set.prod.{u2, u1} α β (Inter.inter.{u2} (Set.{u2} α) (Set.instInterSet.{u2} α) s₁ s₂) (Inter.inter.{u1} (Set.{u1} β) (Set.instInterSet.{u1} β) t₁ t₂))
-Case conversion may be inaccurate. Consider using '#align set.prod_inter_prod Set.prod_inter_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -343,12 +217,6 @@ theorem prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×
   simp [and_assoc', and_left_comm]
 #align set.prod_inter_prod Set.prod_inter_prod
 
-/- warning: set.disjoint_prod -> Set.disjoint_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t₁ : Set.{u2} β} {t₂ : Set.{u2} β}, Iff (Disjoint.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (SemilatticeInf.toPartialOrder.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Lattice.toSemilatticeInf.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (GeneralizedCoheytingAlgebra.toLattice.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.booleanAlgebra.{max u1 u2} (Prod.{u1, u2} α β))))))) (GeneralizedBooleanAlgebra.toOrderBot.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.booleanAlgebra.{max u1 u2} (Prod.{u1, u2} α β)))) (Set.prod.{u1, u2} α β s₁ t₁) (Set.prod.{u1, u2} α β s₂ t₂)) (Or (Disjoint.{u1} (Set.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (Lattice.toSemilatticeInf.{u1} (Set.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} α) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) s₁ s₂) (Disjoint.{u2} (Set.{u2} β) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (Lattice.toSemilatticeInf.{u2} (Set.{u2} β) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} β) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} β) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} (Set.{u2} β) (Set.booleanAlgebra.{u2} β)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u2} (Set.{u2} β) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} (Set.{u2} β) (Set.booleanAlgebra.{u2} β))) t₁ t₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {s₁ : Set.{u1} α} {s₂ : Set.{u1} α} {t₁ : Set.{u2} β} {t₂ : Set.{u2} β}, Iff (Disjoint.{max u2 u1} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (SemilatticeInf.toPartialOrder.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (Lattice.toSemilatticeInf.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (GeneralizedCoheytingAlgebra.toLattice.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (BiheytingAlgebra.toCoheytingAlgebra.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (BooleanAlgebra.toBiheytingAlgebra.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (Set.instBooleanAlgebraSet.{max u1 u2} (Prod.{u1, u2} α β)))))))) (BoundedOrder.toOrderBot.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (Preorder.toLE.{max u2 u1} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (PartialOrder.toPreorder.{max u2 u1} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (SemilatticeInf.toPartialOrder.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (Lattice.toSemilatticeInf.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (GeneralizedCoheytingAlgebra.toLattice.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (BiheytingAlgebra.toCoheytingAlgebra.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (BooleanAlgebra.toBiheytingAlgebra.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (Set.instBooleanAlgebraSet.{max u1 u2} (Prod.{u1, u2} α β)))))))))) (BooleanAlgebra.toBoundedOrder.{max u1 u2} (Set.{max u2 u1} (Prod.{u1, u2} α β)) (Set.instBooleanAlgebraSet.{max u1 u2} (Prod.{u1, u2} α β)))) (Set.prod.{u1, u2} α β s₁ t₁) (Set.prod.{u1, u2} α β s₂ t₂)) (Or (Disjoint.{u1} (Set.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (Lattice.toSemilatticeInf.{u1} (Set.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α))))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (Lattice.toSemilatticeInf.{u1} (Set.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α))))))))) (BooleanAlgebra.toBoundedOrder.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α))) s₁ s₂) (Disjoint.{u2} (Set.{u2} β) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (Lattice.toSemilatticeInf.{u2} (Set.{u2} β) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} β) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} β) (BiheytingAlgebra.toCoheytingAlgebra.{u2} (Set.{u2} β) (BooleanAlgebra.toBiheytingAlgebra.{u2} (Set.{u2} β) (Set.instBooleanAlgebraSet.{u2} β))))))) (BoundedOrder.toOrderBot.{u2} (Set.{u2} β) (Preorder.toLE.{u2} (Set.{u2} β) (PartialOrder.toPreorder.{u2} (Set.{u2} β) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (Lattice.toSemilatticeInf.{u2} (Set.{u2} β) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} β) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} β) (BiheytingAlgebra.toCoheytingAlgebra.{u2} (Set.{u2} β) (BooleanAlgebra.toBiheytingAlgebra.{u2} (Set.{u2} β) (Set.instBooleanAlgebraSet.{u2} β))))))))) (BooleanAlgebra.toBoundedOrder.{u2} (Set.{u2} β) (Set.instBooleanAlgebraSet.{u2} β))) t₁ t₂))
-Case conversion may be inaccurate. Consider using '#align set.disjoint_prod Set.disjoint_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem disjoint_prod : Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂ := by
@@ -356,36 +224,18 @@ theorem disjoint_prod : Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint
     @forall_or_left β, ← @forall_or_right (_ ∈ s₁), ← @forall_or_left (_ ∈ t₁)]
 #align set.disjoint_prod Set.disjoint_prod
 
-/- warning: set.insert_prod -> Set.insert_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β} {a : α}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a s) t) (Union.union.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasUnion.{max u1 u2} (Prod.{u1, u2} α β)) (Set.image.{u2, max u1 u2} β (Prod.{u1, u2} α β) (Prod.mk.{u1, u2} α β a) t) (Set.prod.{u1, u2} α β s t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β} {a : α}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β (Insert.insert.{u2, u2} α (Set.{u2} α) (Set.instInsertSet.{u2} α) a s) t) (Union.union.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instUnionSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.image.{u1, max u1 u2} β (Prod.{u2, u1} α β) (Prod.mk.{u2, u1} α β a) t) (Set.prod.{u2, u1} α β s t))
-Case conversion may be inaccurate. Consider using '#align set.insert_prod Set.insert_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem insert_prod : insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t := by ext ⟨x, y⟩;
   simp (config := { contextual := true }) [image, iff_def, or_imp, Imp.swap]
 #align set.insert_prod Set.insert_prod
 
-/- warning: set.prod_insert -> Set.prod_insert is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β} {b : β}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s (Insert.insert.{u2, u2} β (Set.{u2} β) (Set.hasInsert.{u2} β) b t)) (Union.union.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasUnion.{max u1 u2} (Prod.{u1, u2} α β)) (Set.image.{u1, max u1 u2} α (Prod.{u1, u2} α β) (fun (a : α) => Prod.mk.{u1, u2} α β a b) s) (Set.prod.{u1, u2} α β s t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β} {b : β}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s (Insert.insert.{u1, u1} β (Set.{u1} β) (Set.instInsertSet.{u1} β) b t)) (Union.union.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instUnionSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.image.{u2, max u1 u2} α (Prod.{u2, u1} α β) (fun (a : α) => Prod.mk.{u2, u1} α β a b) s) (Set.prod.{u2, u1} α β s t))
-Case conversion may be inaccurate. Consider using '#align set.prod_insert Set.prod_insertₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_insert : s ×ˢ insert b t = (fun a => (a, b)) '' s ∪ s ×ˢ t := by ext ⟨x, y⟩;
   simp (config := { contextual := true }) [image, iff_def, or_imp, Imp.swap]
 #align set.prod_insert Set.prod_insert
 
-/- warning: set.prod_preimage_eq -> Set.prod_preimage_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {s : Set.{u1} α} {t : Set.{u2} β} {f : γ -> α} {g : δ -> β}, Eq.{succ (max u3 u4)} (Set.{max u3 u4} (Prod.{u3, u4} γ δ)) (Set.prod.{u3, u4} γ δ (Set.preimage.{u3, u1} γ α f s) (Set.preimage.{u4, u2} δ β g t)) (Set.preimage.{max u3 u4, max u1 u2} (Prod.{u3, u4} γ δ) (Prod.{u1, u2} α β) (fun (p : Prod.{u3, u4} γ δ) => Prod.mk.{u1, u2} α β (f (Prod.fst.{u3, u4} γ δ p)) (g (Prod.snd.{u3, u4} γ δ p))) (Set.prod.{u1, u2} α β s t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {γ : Type.{u4}} {δ : Type.{u3}} {s : Set.{u2} α} {t : Set.{u1} β} {f : γ -> α} {g : δ -> β}, Eq.{max (succ u4) (succ u3)} (Set.{max u3 u4} (Prod.{u4, u3} γ δ)) (Set.prod.{u4, u3} γ δ (Set.preimage.{u4, u2} γ α f s) (Set.preimage.{u3, u1} δ β g t)) (Set.preimage.{max u4 u3, max u1 u2} (Prod.{u4, u3} γ δ) (Prod.{u2, u1} α β) (fun (p : Prod.{u4, u3} γ δ) => Prod.mk.{u2, u1} α β (f (Prod.fst.{u4, u3} γ δ p)) (g (Prod.snd.{u4, u3} γ δ p))) (Set.prod.{u2, u1} α β s t))
-Case conversion may be inaccurate. Consider using '#align set.prod_preimage_eq Set.prod_preimage_eqₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_preimage_eq {f : γ → α} {g : δ → β} :
@@ -393,12 +243,6 @@ theorem prod_preimage_eq {f : γ → α} {g : δ → β} :
   rfl
 #align set.prod_preimage_eq Set.prod_preimage_eq
 
-/- warning: set.prod_preimage_left -> Set.prod_preimage_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {s : Set.{u1} α} {t : Set.{u2} β} {f : γ -> α}, Eq.{succ (max u3 u2)} (Set.{max u3 u2} (Prod.{u3, u2} γ β)) (Set.prod.{u3, u2} γ β (Set.preimage.{u3, u1} γ α f s) t) (Set.preimage.{max u3 u2, max u1 u2} (Prod.{u3, u2} γ β) (Prod.{u1, u2} α β) (fun (p : Prod.{u3, u2} γ β) => Prod.mk.{u1, u2} α β (f (Prod.fst.{u3, u2} γ β p)) (Prod.snd.{u3, u2} γ β p)) (Set.prod.{u1, u2} α β s t))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u3}} {γ : Type.{u2}} {s : Set.{u1} α} {t : Set.{u3} β} {f : γ -> α}, Eq.{max (succ u3) (succ u2)} (Set.{max u3 u2} (Prod.{u2, u3} γ β)) (Set.prod.{u2, u3} γ β (Set.preimage.{u2, u1} γ α f s) t) (Set.preimage.{max u3 u2, max u3 u1} (Prod.{u2, u3} γ β) (Prod.{u1, u3} α β) (fun (p : Prod.{u2, u3} γ β) => Prod.mk.{u1, u3} α β (f (Prod.fst.{u2, u3} γ β p)) (Prod.snd.{u2, u3} γ β p)) (Set.prod.{u1, u3} α β s t))
-Case conversion may be inaccurate. Consider using '#align set.prod_preimage_left Set.prod_preimage_leftₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_preimage_left {f : γ → α} :
@@ -406,12 +250,6 @@ theorem prod_preimage_left {f : γ → α} :
   rfl
 #align set.prod_preimage_left Set.prod_preimage_left
 
-/- warning: set.prod_preimage_right -> Set.prod_preimage_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {δ : Type.{u3}} {s : Set.{u1} α} {t : Set.{u2} β} {g : δ -> β}, Eq.{succ (max u1 u3)} (Set.{max u1 u3} (Prod.{u1, u3} α δ)) (Set.prod.{u1, u3} α δ s (Set.preimage.{u3, u2} δ β g t)) (Set.preimage.{max u1 u3, max u1 u2} (Prod.{u1, u3} α δ) (Prod.{u1, u2} α β) (fun (p : Prod.{u1, u3} α δ) => Prod.mk.{u1, u2} α β (Prod.fst.{u1, u3} α δ p) (g (Prod.snd.{u1, u3} α δ p))) (Set.prod.{u1, u2} α β s t))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {δ : Type.{u2}} {s : Set.{u3} α} {t : Set.{u1} β} {g : δ -> β}, Eq.{max (succ u3) (succ u2)} (Set.{max u2 u3} (Prod.{u3, u2} α δ)) (Set.prod.{u3, u2} α δ s (Set.preimage.{u2, u1} δ β g t)) (Set.preimage.{max u3 u2, max u1 u3} (Prod.{u3, u2} α δ) (Prod.{u3, u1} α β) (fun (p : Prod.{u3, u2} α δ) => Prod.mk.{u3, u1} α β (Prod.fst.{u3, u2} α δ p) (g (Prod.snd.{u3, u2} α δ p))) (Set.prod.{u3, u1} α β s t))
-Case conversion may be inaccurate. Consider using '#align set.prod_preimage_right Set.prod_preimage_rightₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_preimage_right {g : δ → β} :
@@ -419,12 +257,6 @@ theorem prod_preimage_right {g : δ → β} :
   rfl
 #align set.prod_preimage_right Set.prod_preimage_right
 
-/- warning: set.preimage_prod_map_prod -> Set.preimage_prod_map_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} (f : α -> β) (g : γ -> δ) (s : Set.{u2} β) (t : Set.{u4} δ), Eq.{succ (max u1 u3)} (Set.{max u1 u3} (Prod.{u1, u3} α γ)) (Set.preimage.{max u1 u3, max u2 u4} (Prod.{u1, u3} α γ) (Prod.{u2, u4} β δ) (Prod.map.{u1, u2, u3, u4} α β γ δ f g) (Set.prod.{u2, u4} β δ s t)) (Set.prod.{u1, u3} α γ (Set.preimage.{u1, u2} α β f s) (Set.preimage.{u3, u4} γ δ g t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u4}} {γ : Type.{u1}} {δ : Type.{u3}} (f : α -> β) (g : γ -> δ) (s : Set.{u4} β) (t : Set.{u3} δ), Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α γ)) (Set.preimage.{max u1 u2, max u3 u4} (Prod.{u2, u1} α γ) (Prod.{u4, u3} β δ) (Prod.map.{u2, u4, u1, u3} α β γ δ f g) (Set.prod.{u4, u3} β δ s t)) (Set.prod.{u2, u1} α γ (Set.preimage.{u2, u4} α β f s) (Set.preimage.{u1, u3} γ δ g t))
-Case conversion may be inaccurate. Consider using '#align set.preimage_prod_map_prod Set.preimage_prod_map_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem preimage_prod_map_prod (f : α → β) (g : γ → δ) (s : Set β) (t : Set δ) :
@@ -432,12 +264,6 @@ theorem preimage_prod_map_prod (f : α → β) (g : γ → δ) (s : Set β) (t :
   rfl
 #align set.preimage_prod_map_prod Set.preimage_prod_map_prod
 
-/- warning: set.mk_preimage_prod -> Set.mk_preimage_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {s : Set.{u1} α} {t : Set.{u2} β} (f : γ -> α) (g : γ -> β), Eq.{succ u3} (Set.{u3} γ) (Set.preimage.{u3, max u1 u2} γ (Prod.{u1, u2} α β) (fun (x : γ) => Prod.mk.{u1, u2} α β (f x) (g x)) (Set.prod.{u1, u2} α β s t)) (Inter.inter.{u3} (Set.{u3} γ) (Set.hasInter.{u3} γ) (Set.preimage.{u3, u1} γ α f s) (Set.preimage.{u3, u2} γ β g t))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {s : Set.{u1} α} {t : Set.{u2} β} (f : γ -> α) (g : γ -> β), Eq.{succ u3} (Set.{u3} γ) (Set.preimage.{u3, max u2 u1} γ (Prod.{u1, u2} α β) (fun (x : γ) => Prod.mk.{u1, u2} α β (f x) (g x)) (Set.prod.{u1, u2} α β s t)) (Inter.inter.{u3} (Set.{u3} γ) (Set.instInterSet.{u3} γ) (Set.preimage.{u3, u1} γ α f s) (Set.preimage.{u3, u2} γ β g t))
-Case conversion may be inaccurate. Consider using '#align set.mk_preimage_prod Set.mk_preimage_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem mk_preimage_prod (f : γ → α) (g : γ → β) :
     (fun x => (f x, g x)) ⁻¹' s ×ˢ t = f ⁻¹' s ∩ g ⁻¹' t :=
@@ -451,12 +277,6 @@ theorem mk_preimage_prod_left (hb : b ∈ t) : (fun a => (a, b)) ⁻¹' s ×ˢ t
 #align set.mk_preimage_prod_left Set.mk_preimage_prod_left
 -/
 
-/- warning: set.mk_preimage_prod_right -> Set.mk_preimage_prod_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β} {a : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Eq.{succ u2} (Set.{u2} β) (Set.preimage.{u2, max u1 u2} β (Prod.{u1, u2} α β) (Prod.mk.{u1, u2} α β a) (Set.prod.{u1, u2} α β s t)) t)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β} {a : α}, (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) a s) -> (Eq.{succ u1} (Set.{u1} β) (Set.preimage.{u1, max u1 u2} β (Prod.{u2, u1} α β) (Prod.mk.{u2, u1} α β a) (Set.prod.{u2, u1} α β s t)) t)
-Case conversion may be inaccurate. Consider using '#align set.mk_preimage_prod_right Set.mk_preimage_prod_rightₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem mk_preimage_prod_right (ha : a ∈ s) : Prod.mk a ⁻¹' s ×ˢ t = t := by ext b; simp [ha]
@@ -470,12 +290,6 @@ theorem mk_preimage_prod_left_eq_empty (hb : b ∉ t) : (fun a => (a, b)) ⁻¹'
 #align set.mk_preimage_prod_left_eq_empty Set.mk_preimage_prod_left_eq_empty
 -/
 
-/- warning: set.mk_preimage_prod_right_eq_empty -> Set.mk_preimage_prod_right_eq_empty is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β} {a : α}, (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s)) -> (Eq.{succ u2} (Set.{u2} β) (Set.preimage.{u2, max u1 u2} β (Prod.{u1, u2} α β) (Prod.mk.{u1, u2} α β a) (Set.prod.{u1, u2} α β s t)) (EmptyCollection.emptyCollection.{u2} (Set.{u2} β) (Set.hasEmptyc.{u2} β)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β} {a : α}, (Not (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) a s)) -> (Eq.{succ u1} (Set.{u1} β) (Set.preimage.{u1, max u1 u2} β (Prod.{u2, u1} α β) (Prod.mk.{u2, u1} α β a) (Set.prod.{u2, u1} α β s t)) (EmptyCollection.emptyCollection.{u1} (Set.{u1} β) (Set.instEmptyCollectionSet.{u1} β)))
-Case conversion may be inaccurate. Consider using '#align set.mk_preimage_prod_right_eq_empty Set.mk_preimage_prod_right_eq_emptyₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem mk_preimage_prod_right_eq_empty (ha : a ∉ s) : Prod.mk a ⁻¹' s ×ˢ t = ∅ := by ext b;
@@ -489,47 +303,23 @@ theorem mk_preimage_prod_left_eq_if [DecidablePred (· ∈ t)] :
 #align set.mk_preimage_prod_left_eq_if Set.mk_preimage_prod_left_eq_if
 -/
 
-/- warning: set.mk_preimage_prod_right_eq_if -> Set.mk_preimage_prod_right_eq_if is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β} {a : α} [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) _x s)], Eq.{succ u2} (Set.{u2} β) (Set.preimage.{u2, max u1 u2} β (Prod.{u1, u2} α β) (Prod.mk.{u1, u2} α β a) (Set.prod.{u1, u2} α β s t)) (ite.{succ u2} (Set.{u2} β) (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (_inst_1 a) t (EmptyCollection.emptyCollection.{u2} (Set.{u2} β) (Set.hasEmptyc.{u2} β)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β} {a : α} [_inst_1 : DecidablePred.{succ u2} α (fun (_x : α) => Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) _x s)], Eq.{succ u1} (Set.{u1} β) (Set.preimage.{u1, max u1 u2} β (Prod.{u2, u1} α β) (Prod.mk.{u2, u1} α β a) (Set.prod.{u2, u1} α β s t)) (ite.{succ u1} (Set.{u1} β) (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) a s) (_inst_1 a) t (EmptyCollection.emptyCollection.{u1} (Set.{u1} β) (Set.instEmptyCollectionSet.{u1} β)))
-Case conversion may be inaccurate. Consider using '#align set.mk_preimage_prod_right_eq_if Set.mk_preimage_prod_right_eq_ifₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem mk_preimage_prod_right_eq_if [DecidablePred (· ∈ s)] :
     Prod.mk a ⁻¹' s ×ˢ t = if a ∈ s then t else ∅ := by split_ifs <;> simp [h]
 #align set.mk_preimage_prod_right_eq_if Set.mk_preimage_prod_right_eq_if
 
-/- warning: set.mk_preimage_prod_left_fn_eq_if -> Set.mk_preimage_prod_left_fn_eq_if is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {s : Set.{u1} α} {t : Set.{u2} β} {b : β} [_inst_1 : DecidablePred.{succ u2} β (fun (_x : β) => Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) _x t)] (f : γ -> α), Eq.{succ u3} (Set.{u3} γ) (Set.preimage.{u3, max u1 u2} γ (Prod.{u1, u2} α β) (fun (a : γ) => Prod.mk.{u1, u2} α β (f a) b) (Set.prod.{u1, u2} α β s t)) (ite.{succ u3} (Set.{u3} γ) (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b t) (_inst_1 b) (Set.preimage.{u3, u1} γ α f s) (EmptyCollection.emptyCollection.{u3} (Set.{u3} γ) (Set.hasEmptyc.{u3} γ)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u3}} {γ : Type.{u2}} {s : Set.{u1} α} {t : Set.{u3} β} {b : β} [_inst_1 : DecidablePred.{succ u3} β (fun (_x : β) => Membership.mem.{u3, u3} β (Set.{u3} β) (Set.instMembershipSet.{u3} β) _x t)] (f : γ -> α), Eq.{succ u2} (Set.{u2} γ) (Set.preimage.{u2, max u3 u1} γ (Prod.{u1, u3} α β) (fun (a : γ) => Prod.mk.{u1, u3} α β (f a) b) (Set.prod.{u1, u3} α β s t)) (ite.{succ u2} (Set.{u2} γ) (Membership.mem.{u3, u3} β (Set.{u3} β) (Set.instMembershipSet.{u3} β) b t) (_inst_1 b) (Set.preimage.{u2, u1} γ α f s) (EmptyCollection.emptyCollection.{u2} (Set.{u2} γ) (Set.instEmptyCollectionSet.{u2} γ)))
-Case conversion may be inaccurate. Consider using '#align set.mk_preimage_prod_left_fn_eq_if Set.mk_preimage_prod_left_fn_eq_ifₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem mk_preimage_prod_left_fn_eq_if [DecidablePred (· ∈ t)] (f : γ → α) :
     (fun a => (f a, b)) ⁻¹' s ×ˢ t = if b ∈ t then f ⁻¹' s else ∅ := by
   rw [← mk_preimage_prod_left_eq_if, prod_preimage_left, preimage_preimage]
 #align set.mk_preimage_prod_left_fn_eq_if Set.mk_preimage_prod_left_fn_eq_if
 
-/- warning: set.mk_preimage_prod_right_fn_eq_if -> Set.mk_preimage_prod_right_fn_eq_if is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {δ : Type.{u3}} {s : Set.{u1} α} {t : Set.{u2} β} {a : α} [_inst_1 : DecidablePred.{succ u1} α (fun (_x : α) => Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) _x s)] (g : δ -> β), Eq.{succ u3} (Set.{u3} δ) (Set.preimage.{u3, max u1 u2} δ (Prod.{u1, u2} α β) (fun (b : δ) => Prod.mk.{u1, u2} α β a (g b)) (Set.prod.{u1, u2} α β s t)) (ite.{succ u3} (Set.{u3} δ) (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (_inst_1 a) (Set.preimage.{u3, u2} δ β g t) (EmptyCollection.emptyCollection.{u3} (Set.{u3} δ) (Set.hasEmptyc.{u3} δ)))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {δ : Type.{u2}} {s : Set.{u3} α} {t : Set.{u1} β} {a : α} [_inst_1 : DecidablePred.{succ u3} α (fun (_x : α) => Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) _x s)] (g : δ -> β), Eq.{succ u2} (Set.{u2} δ) (Set.preimage.{u2, max u1 u3} δ (Prod.{u3, u1} α β) (fun (b : δ) => Prod.mk.{u3, u1} α β a (g b)) (Set.prod.{u3, u1} α β s t)) (ite.{succ u2} (Set.{u2} δ) (Membership.mem.{u3, u3} α (Set.{u3} α) (Set.instMembershipSet.{u3} α) a s) (_inst_1 a) (Set.preimage.{u2, u1} δ β g t) (EmptyCollection.emptyCollection.{u2} (Set.{u2} δ) (Set.instEmptyCollectionSet.{u2} δ)))
-Case conversion may be inaccurate. Consider using '#align set.mk_preimage_prod_right_fn_eq_if Set.mk_preimage_prod_right_fn_eq_ifₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem mk_preimage_prod_right_fn_eq_if [DecidablePred (· ∈ s)] (g : δ → β) :
     (fun b => (a, g b)) ⁻¹' s ×ˢ t = if a ∈ s then g ⁻¹' t else ∅ := by
   rw [← mk_preimage_prod_right_eq_if, prod_preimage_right, preimage_preimage]
 #align set.mk_preimage_prod_right_fn_eq_if Set.mk_preimage_prod_right_fn_eq_if
 
-/- warning: set.preimage_swap_prod -> Set.preimage_swap_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Set.{u1} α) (t : Set.{u2} β), Eq.{succ (max u2 u1)} (Set.{max u2 u1} (Prod.{u2, u1} β α)) (Set.preimage.{max u2 u1, max u1 u2} (Prod.{u2, u1} β α) (Prod.{u1, u2} α β) (Prod.swap.{u2, u1} β α) (Set.prod.{u1, u2} α β s t)) (Set.prod.{u2, u1} β α t s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (s : Set.{u2} α) (t : Set.{u1} β), Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (Prod.{u1, u2} β α)) (Set.preimage.{max u2 u1, max u2 u1} (Prod.{u1, u2} β α) (Prod.{u2, u1} α β) (Prod.swap.{u1, u2} β α) (Set.prod.{u2, u1} α β s t)) (Set.prod.{u1, u2} β α t s)
-Case conversion may be inaccurate. Consider using '#align set.preimage_swap_prod Set.preimage_swap_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
@@ -537,12 +327,6 @@ theorem preimage_swap_prod (s : Set α) (t : Set β) : Prod.swap ⁻¹' s ×ˢ t
   simp [and_comm']
 #align set.preimage_swap_prod Set.preimage_swap_prod
 
-/- warning: set.image_swap_prod -> Set.image_swap_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Set.{u1} α) (t : Set.{u2} β), Eq.{succ (max u2 u1)} (Set.{max u2 u1} (Prod.{u2, u1} β α)) (Set.image.{max u1 u2, max u2 u1} (Prod.{u1, u2} α β) (Prod.{u2, u1} β α) (Prod.swap.{u1, u2} α β) (Set.prod.{u1, u2} α β s t)) (Set.prod.{u2, u1} β α t s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (s : Set.{u2} α) (t : Set.{u1} β), Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u1, u2} β α)) (Set.image.{max u1 u2, max u1 u2} (Prod.{u2, u1} α β) (Prod.{u1, u2} β α) (Prod.swap.{u2, u1} α β) (Set.prod.{u2, u1} α β s t)) (Set.prod.{u1, u2} β α t s)
-Case conversion may be inaccurate. Consider using '#align set.image_swap_prod Set.image_swap_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
@@ -550,12 +334,6 @@ theorem image_swap_prod (s : Set α) (t : Set β) : Prod.swap '' s ×ˢ t = t ×
   rw [image_swap_eq_preimage_swap, preimage_swap_prod]
 #align set.image_swap_prod Set.image_swap_prod
 
-/- warning: set.prod_image_image_eq -> Set.prod_image_image_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {s : Set.{u1} α} {t : Set.{u2} β} {m₁ : α -> γ} {m₂ : β -> δ}, Eq.{succ (max u3 u4)} (Set.{max u3 u4} (Prod.{u3, u4} γ δ)) (Set.prod.{u3, u4} γ δ (Set.image.{u1, u3} α γ m₁ s) (Set.image.{u2, u4} β δ m₂ t)) (Set.image.{max u1 u2, max u3 u4} (Prod.{u1, u2} α β) (Prod.{u3, u4} γ δ) (fun (p : Prod.{u1, u2} α β) => Prod.mk.{u3, u4} γ δ (m₁ (Prod.fst.{u1, u2} α β p)) (m₂ (Prod.snd.{u1, u2} α β p))) (Set.prod.{u1, u2} α β s t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {γ : Type.{u4}} {δ : Type.{u3}} {s : Set.{u2} α} {t : Set.{u1} β} {m₁ : α -> γ} {m₂ : β -> δ}, Eq.{max (succ u4) (succ u3)} (Set.{max u3 u4} (Prod.{u4, u3} γ δ)) (Set.prod.{u4, u3} γ δ (Set.image.{u2, u4} α γ m₁ s) (Set.image.{u1, u3} β δ m₂ t)) (Set.image.{max u2 u1, max u3 u4} (Prod.{u2, u1} α β) (Prod.{u4, u3} γ δ) (fun (p : Prod.{u2, u1} α β) => Prod.mk.{u4, u3} γ δ (m₁ (Prod.fst.{u2, u1} α β p)) (m₂ (Prod.snd.{u2, u1} α β p))) (Set.prod.{u2, u1} α β s t))
-Case conversion may be inaccurate. Consider using '#align set.prod_image_image_eq Set.prod_image_image_eqₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_image_image_eq {m₁ : α → γ} {m₂ : β → δ} :
@@ -564,48 +342,24 @@ theorem prod_image_image_eq {m₁ : α → γ} {m₂ : β → δ} :
     simp [-exists_and_right, exists_and_distrib_right.symm, and_left_comm, and_assoc, and_comm]
 #align set.prod_image_image_eq Set.prod_image_image_eq
 
-/- warning: set.prod_range_range_eq -> Set.prod_range_range_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {m₁ : α -> γ} {m₂ : β -> δ}, Eq.{succ (max u3 u4)} (Set.{max u3 u4} (Prod.{u3, u4} γ δ)) (Set.prod.{u3, u4} γ δ (Set.range.{u3, succ u1} γ α m₁) (Set.range.{u4, succ u2} δ β m₂)) (Set.range.{max u3 u4, max (succ u1) (succ u2)} (Prod.{u3, u4} γ δ) (Prod.{u1, u2} α β) (fun (p : Prod.{u1, u2} α β) => Prod.mk.{u3, u4} γ δ (m₁ (Prod.fst.{u1, u2} α β p)) (m₂ (Prod.snd.{u1, u2} α β p))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {γ : Type.{u4}} {δ : Type.{u3}} {m₁ : α -> γ} {m₂ : β -> δ}, Eq.{max (succ u4) (succ u3)} (Set.{max u3 u4} (Prod.{u4, u3} γ δ)) (Set.prod.{u4, u3} γ δ (Set.range.{u4, succ u2} γ α m₁) (Set.range.{u3, succ u1} δ β m₂)) (Set.range.{max u3 u4, max (succ u2) (succ u1)} (Prod.{u4, u3} γ δ) (Prod.{u2, u1} α β) (fun (p : Prod.{u2, u1} α β) => Prod.mk.{u4, u3} γ δ (m₁ (Prod.fst.{u2, u1} α β p)) (m₂ (Prod.snd.{u2, u1} α β p))))
-Case conversion may be inaccurate. Consider using '#align set.prod_range_range_eq Set.prod_range_range_eqₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_range_range_eq {m₁ : α → γ} {m₂ : β → δ} :
     range m₁ ×ˢ range m₂ = range fun p : α × β => (m₁ p.1, m₂ p.2) :=
   ext <| by simp [range]
 #align set.prod_range_range_eq Set.prod_range_range_eq
 
-/- warning: set.range_prod_map -> Set.range_prod_map is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {δ : Type.{u4}} {m₁ : α -> γ} {m₂ : β -> δ}, Eq.{succ (max u3 u4)} (Set.{max u3 u4} (Prod.{u3, u4} γ δ)) (Set.range.{max u3 u4, max (succ u1) (succ u2)} (Prod.{u3, u4} γ δ) (Prod.{u1, u2} α β) (Prod.map.{u1, u3, u2, u4} α γ β δ m₁ m₂)) (Set.prod.{u3, u4} γ δ (Set.range.{u3, succ u1} γ α m₁) (Set.range.{u4, succ u2} δ β m₂))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u4}} {δ : Type.{u3}} {m₁ : α -> γ} {m₂ : β -> δ}, Eq.{max (succ u4) (succ u3)} (Set.{max u3 u4} (Prod.{u4, u3} γ δ)) (Set.range.{max u3 u4, max (succ u2) (succ u1)} (Prod.{u4, u3} γ δ) (Prod.{u1, u2} α β) (Prod.map.{u1, u4, u2, u3} α γ β δ m₁ m₂)) (Set.prod.{u4, u3} γ δ (Set.range.{u4, succ u1} γ α m₁) (Set.range.{u3, succ u2} δ β m₂))
-Case conversion may be inaccurate. Consider using '#align set.range_prod_map Set.range_prod_mapₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem range_prod_map {m₁ : α → γ} {m₂ : β → δ} : range (Prod.map m₁ m₂) = range m₁ ×ˢ range m₂ :=
   prod_range_range_eq.symm
 #align set.range_prod_map Set.range_prod_map
 
-/- warning: set.prod_range_univ_eq -> Set.prod_range_univ_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {m₁ : α -> γ}, Eq.{succ (max u3 u2)} (Set.{max u3 u2} (Prod.{u3, u2} γ β)) (Set.prod.{u3, u2} γ β (Set.range.{u3, succ u1} γ α m₁) (Set.univ.{u2} β)) (Set.range.{max u3 u2, max (succ u1) (succ u2)} (Prod.{u3, u2} γ β) (Prod.{u1, u2} α β) (fun (p : Prod.{u1, u2} α β) => Prod.mk.{u3, u2} γ β (m₁ (Prod.fst.{u1, u2} α β p)) (Prod.snd.{u1, u2} α β p)))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u3}} {γ : Type.{u2}} {m₁ : α -> γ}, Eq.{max (succ u3) (succ u2)} (Set.{max u3 u2} (Prod.{u2, u3} γ β)) (Set.prod.{u2, u3} γ β (Set.range.{u2, succ u1} γ α m₁) (Set.univ.{u3} β)) (Set.range.{max u3 u2, max (succ u1) (succ u3)} (Prod.{u2, u3} γ β) (Prod.{u1, u3} α β) (fun (p : Prod.{u1, u3} α β) => Prod.mk.{u2, u3} γ β (m₁ (Prod.fst.{u1, u3} α β p)) (Prod.snd.{u1, u3} α β p)))
-Case conversion may be inaccurate. Consider using '#align set.prod_range_univ_eq Set.prod_range_univ_eqₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_range_univ_eq {m₁ : α → γ} :
     range m₁ ×ˢ (univ : Set β) = range fun p : α × β => (m₁ p.1, p.2) :=
   ext <| by simp [range]
 #align set.prod_range_univ_eq Set.prod_range_univ_eq
 
-/- warning: set.prod_univ_range_eq -> Set.prod_univ_range_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {δ : Type.{u3}} {m₂ : β -> δ}, Eq.{succ (max u1 u3)} (Set.{max u1 u3} (Prod.{u1, u3} α δ)) (Set.prod.{u1, u3} α δ (Set.univ.{u1} α) (Set.range.{u3, succ u2} δ β m₂)) (Set.range.{max u1 u3, max (succ u1) (succ u2)} (Prod.{u1, u3} α δ) (Prod.{u1, u2} α β) (fun (p : Prod.{u1, u2} α β) => Prod.mk.{u1, u3} α δ (Prod.fst.{u1, u2} α β p) (m₂ (Prod.snd.{u1, u2} α β p))))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {δ : Type.{u2}} {m₂ : β -> δ}, Eq.{max (succ u3) (succ u2)} (Set.{max u2 u3} (Prod.{u3, u2} α δ)) (Set.prod.{u3, u2} α δ (Set.univ.{u3} α) (Set.range.{u2, succ u1} δ β m₂)) (Set.range.{max u2 u3, max (succ u3) (succ u1)} (Prod.{u3, u2} α δ) (Prod.{u3, u1} α β) (fun (p : Prod.{u3, u1} α β) => Prod.mk.{u3, u2} α δ (Prod.fst.{u3, u1} α β p) (m₂ (Prod.snd.{u3, u1} α β p))))
-Case conversion may be inaccurate. Consider using '#align set.prod_univ_range_eq Set.prod_univ_range_eqₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_univ_range_eq {m₂ : β → δ} :
     (univ : Set α) ×ˢ range m₂ = range fun p : α × β => (p.1, m₂ p.2) :=
@@ -623,76 +377,34 @@ theorem range_pair_subset (f : α → β) (g : α → γ) :
 #align set.range_pair_subset Set.range_pair_subset
 -/
 
-/- warning: set.nonempty.prod -> Set.Nonempty.prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β}, (Set.Nonempty.{u1} α s) -> (Set.Nonempty.{u2} β t) -> (Set.Nonempty.{max u1 u2} (Prod.{u1, u2} α β) (Set.prod.{u1, u2} α β s t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β}, (Set.Nonempty.{u2} α s) -> (Set.Nonempty.{u1} β t) -> (Set.Nonempty.{max u2 u1} (Prod.{u2, u1} α β) (Set.prod.{u2, u1} α β s t))
-Case conversion may be inaccurate. Consider using '#align set.nonempty.prod Set.Nonempty.prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Nonempty.prod : s.Nonempty → t.Nonempty → (s ×ˢ t).Nonempty := fun ⟨x, hx⟩ ⟨y, hy⟩ =>
   ⟨(x, y), ⟨hx, hy⟩⟩
 #align set.nonempty.prod Set.Nonempty.prod
 
-/- warning: set.nonempty.fst -> Set.Nonempty.fst is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β}, (Set.Nonempty.{max u1 u2} (Prod.{u1, u2} α β) (Set.prod.{u1, u2} α β s t)) -> (Set.Nonempty.{u1} α s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β}, (Set.Nonempty.{max u2 u1} (Prod.{u2, u1} α β) (Set.prod.{u2, u1} α β s t)) -> (Set.Nonempty.{u2} α s)
-Case conversion may be inaccurate. Consider using '#align set.nonempty.fst Set.Nonempty.fstₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Nonempty.fst : (s ×ˢ t).Nonempty → s.Nonempty := fun ⟨x, hx⟩ => ⟨x.1, hx.1⟩
 #align set.nonempty.fst Set.Nonempty.fst
 
-/- warning: set.nonempty.snd -> Set.Nonempty.snd is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β}, (Set.Nonempty.{max u1 u2} (Prod.{u1, u2} α β) (Set.prod.{u1, u2} α β s t)) -> (Set.Nonempty.{u2} β t)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β}, (Set.Nonempty.{max u2 u1} (Prod.{u2, u1} α β) (Set.prod.{u2, u1} α β s t)) -> (Set.Nonempty.{u1} β t)
-Case conversion may be inaccurate. Consider using '#align set.nonempty.snd Set.Nonempty.sndₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Nonempty.snd : (s ×ˢ t).Nonempty → t.Nonempty := fun ⟨x, hx⟩ => ⟨x.2, hx.2⟩
 #align set.nonempty.snd Set.Nonempty.snd
 
-/- warning: set.prod_nonempty_iff -> Set.prod_nonempty_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β}, Iff (Set.Nonempty.{max u1 u2} (Prod.{u1, u2} α β) (Set.prod.{u1, u2} α β s t)) (And (Set.Nonempty.{u1} α s) (Set.Nonempty.{u2} β t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β}, Iff (Set.Nonempty.{max u2 u1} (Prod.{u2, u1} α β) (Set.prod.{u2, u1} α β s t)) (And (Set.Nonempty.{u2} α s) (Set.Nonempty.{u1} β t))
-Case conversion may be inaccurate. Consider using '#align set.prod_nonempty_iff Set.prod_nonempty_iffₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_nonempty_iff : (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty :=
   ⟨fun h => ⟨h.fst, h.snd⟩, fun h => h.1.Prod h.2⟩
 #align set.prod_nonempty_iff Set.prod_nonempty_iff
 
-/- warning: set.prod_eq_empty_iff -> Set.prod_eq_empty_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β}, Iff (Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s t) (EmptyCollection.emptyCollection.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasEmptyc.{max u1 u2} (Prod.{u1, u2} α β)))) (Or (Eq.{succ u1} (Set.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α))) (Eq.{succ u2} (Set.{u2} β) t (EmptyCollection.emptyCollection.{u2} (Set.{u2} β) (Set.hasEmptyc.{u2} β))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β}, Iff (Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s t) (EmptyCollection.emptyCollection.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instEmptyCollectionSet.{max u2 u1} (Prod.{u2, u1} α β)))) (Or (Eq.{succ u2} (Set.{u2} α) s (EmptyCollection.emptyCollection.{u2} (Set.{u2} α) (Set.instEmptyCollectionSet.{u2} α))) (Eq.{succ u1} (Set.{u1} β) t (EmptyCollection.emptyCollection.{u1} (Set.{u1} β) (Set.instEmptyCollectionSet.{u1} β))))
-Case conversion may be inaccurate. Consider using '#align set.prod_eq_empty_iff Set.prod_eq_empty_iffₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_eq_empty_iff : s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅ := by
   simp only [not_nonempty_iff_eq_empty.symm, prod_nonempty_iff, not_and_or]
 #align set.prod_eq_empty_iff Set.prod_eq_empty_iff
 
-/- warning: set.prod_sub_preimage_iff -> Set.prod_sub_preimage_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {s : Set.{u1} α} {t : Set.{u2} β} {W : Set.{u3} γ} {f : (Prod.{u1, u2} α β) -> γ}, Iff (HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasSubset.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s t) (Set.preimage.{max u1 u2, u3} (Prod.{u1, u2} α β) γ f W)) (forall (a : α) (b : β), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Membership.Mem.{u2, u2} β (Set.{u2} β) (Set.hasMem.{u2} β) b t) -> (Membership.Mem.{u3, u3} γ (Set.{u3} γ) (Set.hasMem.{u3} γ) (f (Prod.mk.{u1, u2} α β a b)) W))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {γ : Type.{u3}} {s : Set.{u2} α} {t : Set.{u1} β} {W : Set.{u3} γ} {f : (Prod.{u2, u1} α β) -> γ}, Iff (HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instHasSubsetSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s t) (Set.preimage.{max u2 u1, u3} (Prod.{u2, u1} α β) γ f W)) (forall (a : α) (b : β), (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) a s) -> (Membership.mem.{u1, u1} β (Set.{u1} β) (Set.instMembershipSet.{u1} β) b t) -> (Membership.mem.{u3, u3} γ (Set.{u3} γ) (Set.instMembershipSet.{u3} γ) (f (Prod.mk.{u2, u1} α β a b)) W))
-Case conversion may be inaccurate. Consider using '#align set.prod_sub_preimage_iff Set.prod_sub_preimage_iffₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_sub_preimage_iff {W : Set γ} {f : α × β → γ} :
     s ×ˢ t ⊆ f ⁻¹' W ↔ ∀ a b, a ∈ s → b ∈ t → f (a, b) ∈ W := by simp [subset_def]
 #align set.prod_sub_preimage_iff Set.prod_sub_preimage_iff
 
-/- warning: set.image_prod_mk_subset_prod -> Set.image_prod_mk_subset_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {f : α -> β} {g : α -> γ} {s : Set.{u1} α}, HasSubset.Subset.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (Set.hasSubset.{max u2 u3} (Prod.{u2, u3} β γ)) (Set.image.{u1, max u2 u3} α (Prod.{u2, u3} β γ) (fun (x : α) => Prod.mk.{u2, u3} β γ (f x) (g x)) s) (Set.prod.{u2, u3} β γ (Set.image.{u1, u2} α β f s) (Set.image.{u1, u3} α γ g s))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u1}} {γ : Type.{u2}} {f : α -> β} {g : α -> γ} {s : Set.{u3} α}, HasSubset.Subset.{max u2 u1} (Set.{max u2 u1} (Prod.{u1, u2} β γ)) (Set.instHasSubsetSet.{max u1 u2} (Prod.{u1, u2} β γ)) (Set.image.{u3, max u2 u1} α (Prod.{u1, u2} β γ) (fun (x : α) => Prod.mk.{u1, u2} β γ (f x) (g x)) s) (Set.prod.{u1, u2} β γ (Set.image.{u3, u1} α β f s) (Set.image.{u3, u2} α γ g s))
-Case conversion may be inaccurate. Consider using '#align set.image_prod_mk_subset_prod Set.image_prod_mk_subset_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem image_prod_mk_subset_prod {f : α → β} {g : α → γ} {s : Set α} :
     (fun x => (f x, g x)) '' s ⊆ (f '' s) ×ˢ (g '' s) := by rintro _ ⟨x, hx, rfl⟩;
@@ -706,34 +418,16 @@ theorem image_prod_mk_subset_prod_left (hb : b ∈ t) : (fun a => (a, b)) '' s 
 #align set.image_prod_mk_subset_prod_left Set.image_prod_mk_subset_prod_left
 -/
 
-/- warning: set.image_prod_mk_subset_prod_right -> Set.image_prod_mk_subset_prod_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {t : Set.{u2} β} {a : α}, (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasSubset.{max u1 u2} (Prod.{u1, u2} α β)) (Set.image.{u2, max u1 u2} β (Prod.{u1, u2} α β) (Prod.mk.{u1, u2} α β a) t) (Set.prod.{u1, u2} α β s t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β} {a : α}, (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) a s) -> (HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instHasSubsetSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.image.{u1, max u1 u2} β (Prod.{u2, u1} α β) (Prod.mk.{u2, u1} α β a) t) (Set.prod.{u2, u1} α β s t))
-Case conversion may be inaccurate. Consider using '#align set.image_prod_mk_subset_prod_right Set.image_prod_mk_subset_prod_rightₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem image_prod_mk_subset_prod_right (ha : a ∈ s) : Prod.mk a '' t ⊆ s ×ˢ t := by
   rintro _ ⟨b, hb, rfl⟩; exact ⟨ha, hb⟩
 #align set.image_prod_mk_subset_prod_right Set.image_prod_mk_subset_prod_right
 
-/- warning: set.prod_subset_preimage_fst -> Set.prod_subset_preimage_fst is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Set.{u1} α) (t : Set.{u2} β), HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasSubset.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s t) (Set.preimage.{max u1 u2, u1} (Prod.{u1, u2} α β) α (Prod.fst.{u1, u2} α β) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (s : Set.{u2} α) (t : Set.{u1} β), HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instHasSubsetSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s t) (Set.preimage.{max u2 u1, u2} (Prod.{u2, u1} α β) α (Prod.fst.{u2, u1} α β) s)
-Case conversion may be inaccurate. Consider using '#align set.prod_subset_preimage_fst Set.prod_subset_preimage_fstₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_subset_preimage_fst (s : Set α) (t : Set β) : s ×ˢ t ⊆ Prod.fst ⁻¹' s :=
   inter_subset_left _ _
 #align set.prod_subset_preimage_fst Set.prod_subset_preimage_fst
 
-/- warning: set.fst_image_prod_subset -> Set.fst_image_prod_subset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Set.{u1} α) (t : Set.{u2} β), HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) (Set.image.{max u1 u2, u1} (Prod.{u1, u2} α β) α (Prod.fst.{u1, u2} α β) (Set.prod.{u1, u2} α β s t)) s
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (s : Set.{u2} α) (t : Set.{u1} β), HasSubset.Subset.{u2} (Set.{u2} α) (Set.instHasSubsetSet.{u2} α) (Set.image.{max u1 u2, u2} (Prod.{u2, u1} α β) α (Prod.fst.{u2, u1} α β) (Set.prod.{u2, u1} α β s t)) s
-Case conversion may be inaccurate. Consider using '#align set.fst_image_prod_subset Set.fst_image_prod_subsetₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem fst_image_prod_subset (s : Set α) (t : Set β) : Prod.fst '' s ×ˢ t ⊆ s :=
   image_subset_iff.2 <| prod_subset_preimage_fst s t
@@ -748,34 +442,16 @@ theorem fst_image_prod (s : Set β) {t : Set α} (ht : t.Nonempty) : Prod.fst ''
 #align set.fst_image_prod Set.fst_image_prod
 -/
 
-/- warning: set.prod_subset_preimage_snd -> Set.prod_subset_preimage_snd is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Set.{u1} α) (t : Set.{u2} β), HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasSubset.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s t) (Set.preimage.{max u1 u2, u2} (Prod.{u1, u2} α β) β (Prod.snd.{u1, u2} α β) t)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (s : Set.{u2} α) (t : Set.{u1} β), HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instHasSubsetSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s t) (Set.preimage.{max u2 u1, u1} (Prod.{u2, u1} α β) β (Prod.snd.{u2, u1} α β) t)
-Case conversion may be inaccurate. Consider using '#align set.prod_subset_preimage_snd Set.prod_subset_preimage_sndₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem prod_subset_preimage_snd (s : Set α) (t : Set β) : s ×ˢ t ⊆ Prod.snd ⁻¹' t :=
   inter_subset_right _ _
 #align set.prod_subset_preimage_snd Set.prod_subset_preimage_snd
 
-/- warning: set.snd_image_prod_subset -> Set.snd_image_prod_subset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} (s : Set.{u1} α) (t : Set.{u2} β), HasSubset.Subset.{u2} (Set.{u2} β) (Set.hasSubset.{u2} β) (Set.image.{max u1 u2, u2} (Prod.{u1, u2} α β) β (Prod.snd.{u1, u2} α β) (Set.prod.{u1, u2} α β s t)) t
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} (s : Set.{u2} α) (t : Set.{u1} β), HasSubset.Subset.{u1} (Set.{u1} β) (Set.instHasSubsetSet.{u1} β) (Set.image.{max u1 u2, u1} (Prod.{u2, u1} α β) β (Prod.snd.{u2, u1} α β) (Set.prod.{u2, u1} α β s t)) t
-Case conversion may be inaccurate. Consider using '#align set.snd_image_prod_subset Set.snd_image_prod_subsetₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem snd_image_prod_subset (s : Set α) (t : Set β) : Prod.snd '' s ×ˢ t ⊆ t :=
   image_subset_iff.2 <| prod_subset_preimage_snd s t
 #align set.snd_image_prod_subset Set.snd_image_prod_subset
 
-/- warning: set.snd_image_prod -> Set.snd_image_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α}, (Set.Nonempty.{u1} α s) -> (forall (t : Set.{u2} β), Eq.{succ u2} (Set.{u2} β) (Set.image.{max u1 u2, u2} (Prod.{u1, u2} α β) β (Prod.snd.{u1, u2} α β) (Set.prod.{u1, u2} α β s t)) t)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α}, (Set.Nonempty.{u2} α s) -> (forall (t : Set.{u1} β), Eq.{succ u1} (Set.{u1} β) (Set.image.{max u1 u2, u1} (Prod.{u2, u1} α β) β (Prod.snd.{u2, u1} α β) (Set.prod.{u2, u1} α β s t)) t)
-Case conversion may be inaccurate. Consider using '#align set.snd_image_prod Set.snd_image_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem snd_image_prod {s : Set α} (hs : s.Nonempty) (t : Set β) : Prod.snd '' s ×ˢ t = t :=
   (snd_image_prod_subset _ _).antisymm fun y y_in =>
@@ -783,12 +459,6 @@ theorem snd_image_prod {s : Set α} (hs : s.Nonempty) (t : Set β) : Prod.snd ''
     ⟨(x, y), ⟨x_in, y_in⟩, rfl⟩
 #align set.snd_image_prod Set.snd_image_prod
 
-/- warning: set.prod_diff_prod -> Set.prod_diff_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {s₁ : Set.{u1} α} {t : Set.{u2} β} {t₁ : Set.{u2} β}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (SDiff.sdiff.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (BooleanAlgebra.toHasSdiff.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.booleanAlgebra.{max u1 u2} (Prod.{u1, u2} α β))) (Set.prod.{u1, u2} α β s t) (Set.prod.{u1, u2} α β s₁ t₁)) (Union.union.{max u1 u2} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.hasUnion.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s (SDiff.sdiff.{u2} (Set.{u2} β) (BooleanAlgebra.toHasSdiff.{u2} (Set.{u2} β) (Set.booleanAlgebra.{u2} β)) t t₁)) (Set.prod.{u1, u2} α β (SDiff.sdiff.{u1} (Set.{u1} α) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)) s s₁) t))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {s₁ : Set.{u2} α} {t : Set.{u1} β} {t₁ : Set.{u1} β}, Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (SDiff.sdiff.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instSDiffSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s t) (Set.prod.{u2, u1} α β s₁ t₁)) (Union.union.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instUnionSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s (SDiff.sdiff.{u1} (Set.{u1} β) (Set.instSDiffSet.{u1} β) t t₁)) (Set.prod.{u2, u1} α β (SDiff.sdiff.{u2} (Set.{u2} α) (Set.instSDiffSet.{u2} α) s s₁) t))
-Case conversion may be inaccurate. Consider using '#align set.prod_diff_prod Set.prod_diff_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -819,12 +489,6 @@ theorem prod_subset_prod_iff : s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t
 #align set.prod_subset_prod_iff Set.prod_subset_prod_iff
 -/
 
-/- warning: set.prod_eq_prod_iff_of_nonempty -> Set.prod_eq_prod_iff_of_nonempty is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {s₁ : Set.{u1} α} {t : Set.{u2} β} {t₁ : Set.{u2} β}, (Set.Nonempty.{max u1 u2} (Prod.{u1, u2} α β) (Set.prod.{u1, u2} α β s t)) -> (Iff (Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s t) (Set.prod.{u1, u2} α β s₁ t₁)) (And (Eq.{succ u1} (Set.{u1} α) s s₁) (Eq.{succ u2} (Set.{u2} β) t t₁)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {s₁ : Set.{u2} α} {t : Set.{u1} β} {t₁ : Set.{u1} β}, (Set.Nonempty.{max u2 u1} (Prod.{u2, u1} α β) (Set.prod.{u2, u1} α β s t)) -> (Iff (Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s t) (Set.prod.{u2, u1} α β s₁ t₁)) (And (Eq.{succ u2} (Set.{u2} α) s s₁) (Eq.{succ u1} (Set.{u1} β) t t₁)))
-Case conversion may be inaccurate. Consider using '#align set.prod_eq_prod_iff_of_nonempty Set.prod_eq_prod_iff_of_nonemptyₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -840,12 +504,6 @@ theorem prod_eq_prod_iff_of_nonempty (h : (s ×ˢ t).Nonempty) :
   · rintro ⟨rfl, rfl⟩; rfl
 #align set.prod_eq_prod_iff_of_nonempty Set.prod_eq_prod_iff_of_nonempty
 
-/- warning: set.prod_eq_prod_iff -> Set.prod_eq_prod_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {s : Set.{u1} α} {s₁ : Set.{u1} α} {t : Set.{u2} β} {t₁ : Set.{u2} β}, Iff (Eq.{succ (max u1 u2)} (Set.{max u1 u2} (Prod.{u1, u2} α β)) (Set.prod.{u1, u2} α β s t) (Set.prod.{u1, u2} α β s₁ t₁)) (Or (And (Eq.{succ u1} (Set.{u1} α) s s₁) (Eq.{succ u2} (Set.{u2} β) t t₁)) (And (Or (Eq.{succ u1} (Set.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α))) (Eq.{succ u2} (Set.{u2} β) t (EmptyCollection.emptyCollection.{u2} (Set.{u2} β) (Set.hasEmptyc.{u2} β)))) (Or (Eq.{succ u1} (Set.{u1} α) s₁ (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α))) (Eq.{succ u2} (Set.{u2} β) t₁ (EmptyCollection.emptyCollection.{u2} (Set.{u2} β) (Set.hasEmptyc.{u2} β))))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {s₁ : Set.{u2} α} {t : Set.{u1} β} {t₁ : Set.{u1} β}, Iff (Eq.{max (succ u2) (succ u1)} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.prod.{u2, u1} α β s t) (Set.prod.{u2, u1} α β s₁ t₁)) (Or (And (Eq.{succ u2} (Set.{u2} α) s s₁) (Eq.{succ u1} (Set.{u1} β) t t₁)) (And (Or (Eq.{succ u2} (Set.{u2} α) s (EmptyCollection.emptyCollection.{u2} (Set.{u2} α) (Set.instEmptyCollectionSet.{u2} α))) (Eq.{succ u1} (Set.{u1} β) t (EmptyCollection.emptyCollection.{u1} (Set.{u1} β) (Set.instEmptyCollectionSet.{u1} β)))) (Or (Eq.{succ u2} (Set.{u2} α) s₁ (EmptyCollection.emptyCollection.{u2} (Set.{u2} α) (Set.instEmptyCollectionSet.{u2} α))) (Eq.{succ u1} (Set.{u1} β) t₁ (EmptyCollection.emptyCollection.{u1} (Set.{u1} β) (Set.instEmptyCollectionSet.{u1} β))))))
-Case conversion may be inaccurate. Consider using '#align set.prod_eq_prod_iff Set.prod_eq_prod_iffₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -879,45 +537,21 @@ section Mono
 
 variable [Preorder α] {f : α → Set β} {g : α → Set γ}
 
-/- warning: monotone.set_prod -> Monotone.set_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Preorder.{u1} α] {f : α -> (Set.{u2} β)} {g : α -> (Set.{u3} γ)}, (Monotone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (Lattice.toSemilatticeInf.{u2} (Set.{u2} β) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} β) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} β) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} (Set.{u2} β) (Set.booleanAlgebra.{u2} β))))))) f) -> (Monotone.{u1, u3} α (Set.{u3} γ) _inst_1 (PartialOrder.toPreorder.{u3} (Set.{u3} γ) (SemilatticeInf.toPartialOrder.{u3} (Set.{u3} γ) (Lattice.toSemilatticeInf.{u3} (Set.{u3} γ) (GeneralizedCoheytingAlgebra.toLattice.{u3} (Set.{u3} γ) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u3} (Set.{u3} γ) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u3} (Set.{u3} γ) (Set.booleanAlgebra.{u3} γ))))))) g) -> (Monotone.{u1, max u2 u3} α (Set.{max u2 u3} (Prod.{u2, u3} β γ)) _inst_1 (PartialOrder.toPreorder.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (SemilatticeInf.toPartialOrder.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (Lattice.toSemilatticeInf.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (GeneralizedCoheytingAlgebra.toLattice.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (Set.booleanAlgebra.{max u2 u3} (Prod.{u2, u3} β γ)))))))) (fun (x : α) => Set.prod.{u2, u3} β γ (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_1 : Preorder.{u3} α] {f : α -> (Set.{u2} β)} {g : α -> (Set.{u1} γ)}, (Monotone.{u3, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (Lattice.toSemilatticeInf.{u2} (Set.{u2} β) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} β) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} β) (BiheytingAlgebra.toCoheytingAlgebra.{u2} (Set.{u2} β) (BooleanAlgebra.toBiheytingAlgebra.{u2} (Set.{u2} β) (Set.instBooleanAlgebraSet.{u2} β)))))))) f) -> (Monotone.{u3, u1} α (Set.{u1} γ) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} γ) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} γ) (Lattice.toSemilatticeInf.{u1} (Set.{u1} γ) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} γ) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} γ) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} γ) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} γ) (Set.instBooleanAlgebraSet.{u1} γ)))))))) g) -> (Monotone.{u3, max u1 u2} α (Set.{max u1 u2} (Prod.{u2, u1} β γ)) _inst_1 (PartialOrder.toPreorder.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (SemilatticeInf.toPartialOrder.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (Lattice.toSemilatticeInf.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (GeneralizedCoheytingAlgebra.toLattice.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (BiheytingAlgebra.toCoheytingAlgebra.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (BooleanAlgebra.toBiheytingAlgebra.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (Set.instBooleanAlgebraSet.{max u2 u1} (Prod.{u2, u1} β γ))))))))) (fun (x : α) => Set.prod.{u2, u1} β γ (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align monotone.set_prod Monotone.set_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Monotone.set_prod (hf : Monotone f) (hg : Monotone g) : Monotone fun x => f x ×ˢ g x :=
   fun a b h => prod_mono (hf h) (hg h)
 #align monotone.set_prod Monotone.set_prod
 
-/- warning: antitone.set_prod -> Antitone.set_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} [_inst_1 : Preorder.{u1} α] {f : α -> (Set.{u2} β)} {g : α -> (Set.{u3} γ)}, (Antitone.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (Lattice.toSemilatticeInf.{u2} (Set.{u2} β) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} β) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} β) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} (Set.{u2} β) (Set.booleanAlgebra.{u2} β))))))) f) -> (Antitone.{u1, u3} α (Set.{u3} γ) _inst_1 (PartialOrder.toPreorder.{u3} (Set.{u3} γ) (SemilatticeInf.toPartialOrder.{u3} (Set.{u3} γ) (Lattice.toSemilatticeInf.{u3} (Set.{u3} γ) (GeneralizedCoheytingAlgebra.toLattice.{u3} (Set.{u3} γ) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u3} (Set.{u3} γ) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u3} (Set.{u3} γ) (Set.booleanAlgebra.{u3} γ))))))) g) -> (Antitone.{u1, max u2 u3} α (Set.{max u2 u3} (Prod.{u2, u3} β γ)) _inst_1 (PartialOrder.toPreorder.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (SemilatticeInf.toPartialOrder.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (Lattice.toSemilatticeInf.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (GeneralizedCoheytingAlgebra.toLattice.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (Set.booleanAlgebra.{max u2 u3} (Prod.{u2, u3} β γ)))))))) (fun (x : α) => Set.prod.{u2, u3} β γ (f x) (g x)))
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} [_inst_1 : Preorder.{u3} α] {f : α -> (Set.{u2} β)} {g : α -> (Set.{u1} γ)}, (Antitone.{u3, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (Lattice.toSemilatticeInf.{u2} (Set.{u2} β) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} β) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} β) (BiheytingAlgebra.toCoheytingAlgebra.{u2} (Set.{u2} β) (BooleanAlgebra.toBiheytingAlgebra.{u2} (Set.{u2} β) (Set.instBooleanAlgebraSet.{u2} β)))))))) f) -> (Antitone.{u3, u1} α (Set.{u1} γ) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} γ) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} γ) (Lattice.toSemilatticeInf.{u1} (Set.{u1} γ) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} γ) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} γ) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} γ) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} γ) (Set.instBooleanAlgebraSet.{u1} γ)))))))) g) -> (Antitone.{u3, max u1 u2} α (Set.{max u1 u2} (Prod.{u2, u1} β γ)) _inst_1 (PartialOrder.toPreorder.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (SemilatticeInf.toPartialOrder.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (Lattice.toSemilatticeInf.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (GeneralizedCoheytingAlgebra.toLattice.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (BiheytingAlgebra.toCoheytingAlgebra.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (BooleanAlgebra.toBiheytingAlgebra.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (Set.instBooleanAlgebraSet.{max u2 u1} (Prod.{u2, u1} β γ))))))))) (fun (x : α) => Set.prod.{u2, u1} β γ (f x) (g x)))
-Case conversion may be inaccurate. Consider using '#align antitone.set_prod Antitone.set_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem Antitone.set_prod (hf : Antitone f) (hg : Antitone g) : Antitone fun x => f x ×ˢ g x :=
   fun a b h => prod_mono (hf h) (hg h)
 #align antitone.set_prod Antitone.set_prod
 
-/- warning: monotone_on.set_prod -> MonotoneOn.set_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {s : Set.{u1} α} [_inst_1 : Preorder.{u1} α] {f : α -> (Set.{u2} β)} {g : α -> (Set.{u3} γ)}, (MonotoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (Lattice.toSemilatticeInf.{u2} (Set.{u2} β) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} β) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} β) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} (Set.{u2} β) (Set.booleanAlgebra.{u2} β))))))) f s) -> (MonotoneOn.{u1, u3} α (Set.{u3} γ) _inst_1 (PartialOrder.toPreorder.{u3} (Set.{u3} γ) (SemilatticeInf.toPartialOrder.{u3} (Set.{u3} γ) (Lattice.toSemilatticeInf.{u3} (Set.{u3} γ) (GeneralizedCoheytingAlgebra.toLattice.{u3} (Set.{u3} γ) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u3} (Set.{u3} γ) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u3} (Set.{u3} γ) (Set.booleanAlgebra.{u3} γ))))))) g s) -> (MonotoneOn.{u1, max u2 u3} α (Set.{max u2 u3} (Prod.{u2, u3} β γ)) _inst_1 (PartialOrder.toPreorder.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (SemilatticeInf.toPartialOrder.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (Lattice.toSemilatticeInf.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (GeneralizedCoheytingAlgebra.toLattice.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (Set.booleanAlgebra.{max u2 u3} (Prod.{u2, u3} β γ)))))))) (fun (x : α) => Set.prod.{u2, u3} β γ (f x) (g x)) s)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {s : Set.{u3} α} [_inst_1 : Preorder.{u3} α] {f : α -> (Set.{u2} β)} {g : α -> (Set.{u1} γ)}, (MonotoneOn.{u3, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (Lattice.toSemilatticeInf.{u2} (Set.{u2} β) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} β) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} β) (BiheytingAlgebra.toCoheytingAlgebra.{u2} (Set.{u2} β) (BooleanAlgebra.toBiheytingAlgebra.{u2} (Set.{u2} β) (Set.instBooleanAlgebraSet.{u2} β)))))))) f s) -> (MonotoneOn.{u3, u1} α (Set.{u1} γ) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} γ) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} γ) (Lattice.toSemilatticeInf.{u1} (Set.{u1} γ) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} γ) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} γ) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} γ) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} γ) (Set.instBooleanAlgebraSet.{u1} γ)))))))) g s) -> (MonotoneOn.{u3, max u1 u2} α (Set.{max u1 u2} (Prod.{u2, u1} β γ)) _inst_1 (PartialOrder.toPreorder.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (SemilatticeInf.toPartialOrder.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (Lattice.toSemilatticeInf.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (GeneralizedCoheytingAlgebra.toLattice.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (BiheytingAlgebra.toCoheytingAlgebra.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (BooleanAlgebra.toBiheytingAlgebra.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (Set.instBooleanAlgebraSet.{max u2 u1} (Prod.{u2, u1} β γ))))))))) (fun (x : α) => Set.prod.{u2, u1} β γ (f x) (g x)) s)
-Case conversion may be inaccurate. Consider using '#align monotone_on.set_prod MonotoneOn.set_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem MonotoneOn.set_prod (hf : MonotoneOn f s) (hg : MonotoneOn g s) :
     MonotoneOn (fun x => f x ×ˢ g x) s := fun a ha b hb h => prod_mono (hf ha hb h) (hg ha hb h)
 #align monotone_on.set_prod MonotoneOn.set_prod
 
-/- warning: antitone_on.set_prod -> AntitoneOn.set_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} {γ : Type.{u3}} {s : Set.{u1} α} [_inst_1 : Preorder.{u1} α] {f : α -> (Set.{u2} β)} {g : α -> (Set.{u3} γ)}, (AntitoneOn.{u1, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (Lattice.toSemilatticeInf.{u2} (Set.{u2} β) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} β) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} β) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} (Set.{u2} β) (Set.booleanAlgebra.{u2} β))))))) f s) -> (AntitoneOn.{u1, u3} α (Set.{u3} γ) _inst_1 (PartialOrder.toPreorder.{u3} (Set.{u3} γ) (SemilatticeInf.toPartialOrder.{u3} (Set.{u3} γ) (Lattice.toSemilatticeInf.{u3} (Set.{u3} γ) (GeneralizedCoheytingAlgebra.toLattice.{u3} (Set.{u3} γ) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u3} (Set.{u3} γ) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u3} (Set.{u3} γ) (Set.booleanAlgebra.{u3} γ))))))) g s) -> (AntitoneOn.{u1, max u2 u3} α (Set.{max u2 u3} (Prod.{u2, u3} β γ)) _inst_1 (PartialOrder.toPreorder.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (SemilatticeInf.toPartialOrder.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (Lattice.toSemilatticeInf.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (GeneralizedCoheytingAlgebra.toLattice.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{max u2 u3} (Set.{max u2 u3} (Prod.{u2, u3} β γ)) (Set.booleanAlgebra.{max u2 u3} (Prod.{u2, u3} β γ)))))))) (fun (x : α) => Set.prod.{u2, u3} β γ (f x) (g x)) s)
-but is expected to have type
-  forall {α : Type.{u3}} {β : Type.{u2}} {γ : Type.{u1}} {s : Set.{u3} α} [_inst_1 : Preorder.{u3} α] {f : α -> (Set.{u2} β)} {g : α -> (Set.{u1} γ)}, (AntitoneOn.{u3, u2} α (Set.{u2} β) _inst_1 (PartialOrder.toPreorder.{u2} (Set.{u2} β) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} β) (Lattice.toSemilatticeInf.{u2} (Set.{u2} β) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} β) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} β) (BiheytingAlgebra.toCoheytingAlgebra.{u2} (Set.{u2} β) (BooleanAlgebra.toBiheytingAlgebra.{u2} (Set.{u2} β) (Set.instBooleanAlgebraSet.{u2} β)))))))) f s) -> (AntitoneOn.{u3, u1} α (Set.{u1} γ) _inst_1 (PartialOrder.toPreorder.{u1} (Set.{u1} γ) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} γ) (Lattice.toSemilatticeInf.{u1} (Set.{u1} γ) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} γ) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} γ) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} γ) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} γ) (Set.instBooleanAlgebraSet.{u1} γ)))))))) g s) -> (AntitoneOn.{u3, max u1 u2} α (Set.{max u1 u2} (Prod.{u2, u1} β γ)) _inst_1 (PartialOrder.toPreorder.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (SemilatticeInf.toPartialOrder.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (Lattice.toSemilatticeInf.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (GeneralizedCoheytingAlgebra.toLattice.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (BiheytingAlgebra.toCoheytingAlgebra.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (BooleanAlgebra.toBiheytingAlgebra.{max u2 u1} (Set.{max u1 u2} (Prod.{u2, u1} β γ)) (Set.instBooleanAlgebraSet.{max u2 u1} (Prod.{u2, u1} β γ))))))))) (fun (x : α) => Set.prod.{u2, u1} β γ (f x) (g x)) s)
-Case conversion may be inaccurate. Consider using '#align antitone_on.set_prod AntitoneOn.set_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem AntitoneOn.set_prod (hf : AntitoneOn f s) (hg : AntitoneOn g s) :
     AntitoneOn (fun x => f x ×ˢ g x) s := fun a ha b hb h => prod_mono (hf ha hb h) (hg ha hb h)
@@ -987,24 +621,12 @@ theorem diagonal_subset_iff {s} : diagonal α ⊆ s ↔ ∀ x, (x, x) ∈ s := b
 #align set.diagonal_subset_iff Set.diagonal_subset_iff
 -/
 
-/- warning: set.prod_subset_compl_diagonal_iff_disjoint -> Set.prod_subset_compl_diagonal_iff_disjoint is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (HasSubset.Subset.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.hasSubset.{u1} (Prod.{u1, u1} α α)) (Set.prod.{u1, u1} α α s t) (HasCompl.compl.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.booleanAlgebra.{u1} (Prod.{u1, u1} α α))) (Set.diagonal.{u1} α))) (Disjoint.{u1} (Set.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (Lattice.toSemilatticeInf.{u1} (Set.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} α) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) s t)
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, Iff (HasSubset.Subset.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instHasSubsetSet.{u1} (Prod.{u1, u1} α α)) (Set.prod.{u1, u1} α α s t) (HasCompl.compl.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instBooleanAlgebraSet.{u1} (Prod.{u1, u1} α α))) (Set.diagonal.{u1} α))) (Disjoint.{u1} (Set.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (Lattice.toSemilatticeInf.{u1} (Set.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α))))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (Lattice.toSemilatticeInf.{u1} (Set.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α))))))))) (BooleanAlgebra.toBoundedOrder.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α))) s t)
-Case conversion may be inaccurate. Consider using '#align set.prod_subset_compl_diagonal_iff_disjoint Set.prod_subset_compl_diagonal_iff_disjointₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem prod_subset_compl_diagonal_iff_disjoint : s ×ˢ t ⊆ diagonal αᶜ ↔ Disjoint s t :=
   prod_subset_iff.trans disjoint_iff_forall_ne.symm
 #align set.prod_subset_compl_diagonal_iff_disjoint Set.prod_subset_compl_diagonal_iff_disjoint
 
-/- warning: set.diag_preimage_prod -> Set.diag_preimage_prod is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.preimage.{u1, u1} α (Prod.{u1, u1} α α) (fun (x : α) => Prod.mk.{u1, u1} α α x x) (Set.prod.{u1, u1} α α s t)) (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t)
-but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} α) (Set.preimage.{u1, u1} α (Prod.{u1, u1} α α) (fun (x : α) => Prod.mk.{u1, u1} α α x x) (Set.prod.{u1, u1} α α s t)) (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t)
-Case conversion may be inaccurate. Consider using '#align set.diag_preimage_prod Set.diag_preimage_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem diag_preimage_prod (s t : Set α) : (fun x => (x, x)) ⁻¹' s ×ˢ t = s ∩ t :=
@@ -1018,12 +640,6 @@ theorem diag_preimage_prod_self (s : Set α) : (fun x => (x, x)) ⁻¹' s ×ˢ s
 #align set.diag_preimage_prod_self Set.diag_preimage_prod_self
 -/
 
-/- warning: set.diag_image -> Set.diag_image is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α), Eq.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.image.{u1, u1} α (Prod.{u1, u1} α α) (fun (x : α) => Prod.mk.{u1, u1} α α x x) s) (Inter.inter.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.hasInter.{u1} (Prod.{u1, u1} α α)) (Set.diagonal.{u1} α) (Set.prod.{u1, u1} α α s s))
-but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α), Eq.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.image.{u1, u1} α (Prod.{u1, u1} α α) (fun (x : α) => Prod.mk.{u1, u1} α α x x) s) (Inter.inter.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instInterSet.{u1} (Prod.{u1, u1} α α)) (Set.diagonal.{u1} α) (Set.prod.{u1, u1} α α s s))
-Case conversion may be inaccurate. Consider using '#align set.diag_image Set.diag_imageₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem diag_image (s : Set α) : (fun x => (x, x)) '' s = diagonal α ∩ s ×ˢ s :=
   by
@@ -1054,12 +670,6 @@ theorem mem_offDiag : x ∈ s.offDiag ↔ x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.
 #align set.mem_off_diag Set.mem_offDiag
 -/
 
-/- warning: set.off_diag_mono -> Set.offDiag_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Monotone.{u1, u1} (Set.{u1} α) (Set.{u1} (Prod.{u1, u1} α α)) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (Lattice.toSemilatticeInf.{u1} (Set.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} α) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))))))) (PartialOrder.toPreorder.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Lattice.toSemilatticeInf.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.booleanAlgebra.{u1} (Prod.{u1, u1} α α)))))))) (Set.offDiag.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}}, Monotone.{u1, u1} (Set.{u1} α) (Set.{u1} (Prod.{u1, u1} α α)) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (Lattice.toSemilatticeInf.{u1} (Set.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α)))))))) (PartialOrder.toPreorder.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Lattice.toSemilatticeInf.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instBooleanAlgebraSet.{u1} (Prod.{u1, u1} α α))))))))) (Set.offDiag.{u1} α)
-Case conversion may be inaccurate. Consider using '#align set.off_diag_mono Set.offDiag_monoₓ'. -/
 theorem offDiag_mono : Monotone (offDiag : Set α → Set (α × α)) := fun s t h x =>
   And.imp (@h _) <| And.imp_left <| @h _
 #align set.off_diag_mono Set.offDiag_mono
@@ -1111,58 +721,28 @@ theorem offDiag_singleton (a : α) : ({a} : Set α).offDiag = ∅ := by simp
 #align set.off_diag_singleton Set.offDiag_singleton
 -/
 
-/- warning: set.off_diag_univ -> Set.offDiag_univ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Eq.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α (Set.univ.{u1} α)) (HasCompl.compl.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.booleanAlgebra.{u1} (Prod.{u1, u1} α α))) (Set.diagonal.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}}, Eq.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α (Set.univ.{u1} α)) (HasCompl.compl.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instBooleanAlgebraSet.{u1} (Prod.{u1, u1} α α))) (Set.diagonal.{u1} α))
-Case conversion may be inaccurate. Consider using '#align set.off_diag_univ Set.offDiag_univₓ'. -/
 @[simp]
 theorem offDiag_univ : (univ : Set α).offDiag = diagonal αᶜ :=
   ext <| by simp
 #align set.off_diag_univ Set.offDiag_univ
 
-/- warning: set.prod_sdiff_diagonal -> Set.prod_sdiff_diagonal is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α), Eq.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (SDiff.sdiff.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.booleanAlgebra.{u1} (Prod.{u1, u1} α α))) (Set.prod.{u1, u1} α α s s) (Set.diagonal.{u1} α)) (Set.offDiag.{u1} α s)
-but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α), Eq.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (SDiff.sdiff.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instSDiffSet.{u1} (Prod.{u1, u1} α α)) (Set.prod.{u1, u1} α α s s) (Set.diagonal.{u1} α)) (Set.offDiag.{u1} α s)
-Case conversion may be inaccurate. Consider using '#align set.prod_sdiff_diagonal Set.prod_sdiff_diagonalₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
 theorem prod_sdiff_diagonal : s ×ˢ s \ diagonal α = s.offDiag :=
   ext fun _ => and_assoc
 #align set.prod_sdiff_diagonal Set.prod_sdiff_diagonal
 
-/- warning: set.disjoint_diagonal_off_diag -> Set.disjoint_diagonal_offDiag is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α), Disjoint.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Lattice.toSemilatticeInf.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.booleanAlgebra.{u1} (Prod.{u1, u1} α α))))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.booleanAlgebra.{u1} (Prod.{u1, u1} α α)))) (Set.diagonal.{u1} α) (Set.offDiag.{u1} α s)
-but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α), Disjoint.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Lattice.toSemilatticeInf.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instBooleanAlgebraSet.{u1} (Prod.{u1, u1} α α)))))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Preorder.toLE.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (PartialOrder.toPreorder.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Lattice.toSemilatticeInf.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instBooleanAlgebraSet.{u1} (Prod.{u1, u1} α α)))))))))) (BooleanAlgebra.toBoundedOrder.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instBooleanAlgebraSet.{u1} (Prod.{u1, u1} α α)))) (Set.diagonal.{u1} α) (Set.offDiag.{u1} α s)
-Case conversion may be inaccurate. Consider using '#align set.disjoint_diagonal_off_diag Set.disjoint_diagonal_offDiagₓ'. -/
 @[simp]
 theorem disjoint_diagonal_offDiag : Disjoint (diagonal α) s.offDiag :=
   disjoint_left.mpr fun x hd ho => ho.2.2 hd
 #align set.disjoint_diagonal_off_diag Set.disjoint_diagonal_offDiag
 
-/- warning: set.off_diag_inter -> Set.offDiag_inter is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α (Inter.inter.{u1} (Set.{u1} α) (Set.hasInter.{u1} α) s t)) (Inter.inter.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.hasInter.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α s) (Set.offDiag.{u1} α t))
-but is expected to have type
-  forall {α : Type.{u1}} (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t)) (Inter.inter.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instInterSet.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α s) (Set.offDiag.{u1} α t))
-Case conversion may be inaccurate. Consider using '#align set.off_diag_inter Set.offDiag_interₓ'. -/
 theorem offDiag_inter : (s ∩ t).offDiag = s.offDiag ∩ t.offDiag :=
   ext fun x => by simp only [mem_off_diag, mem_inter_iff]; tauto
 #align set.off_diag_inter Set.offDiag_inter
 
 variable {s t}
 
-/- warning: set.off_diag_union -> Set.offDiag_union is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, (Disjoint.{u1} (Set.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (Lattice.toSemilatticeInf.{u1} (Set.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} α) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) s t) -> (Eq.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α (Union.union.{u1} (Set.{u1} α) (Set.hasUnion.{u1} α) s t)) (Union.union.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.hasUnion.{u1} (Prod.{u1, u1} α α)) (Union.union.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.hasUnion.{u1} (Prod.{u1, u1} α α)) (Union.union.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.hasUnion.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α s) (Set.offDiag.{u1} α t)) (Set.prod.{u1, u1} α α s t)) (Set.prod.{u1, u1} α α t s)))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {t : Set.{u1} α}, (Disjoint.{u1} (Set.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (Lattice.toSemilatticeInf.{u1} (Set.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α))))))) (BoundedOrder.toOrderBot.{u1} (Set.{u1} α) (Preorder.toLE.{u1} (Set.{u1} α) (PartialOrder.toPreorder.{u1} (Set.{u1} α) (SemilatticeInf.toPartialOrder.{u1} (Set.{u1} α) (Lattice.toSemilatticeInf.{u1} (Set.{u1} α) (GeneralizedCoheytingAlgebra.toLattice.{u1} (Set.{u1} α) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} (Set.{u1} α) (BiheytingAlgebra.toCoheytingAlgebra.{u1} (Set.{u1} α) (BooleanAlgebra.toBiheytingAlgebra.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α))))))))) (BooleanAlgebra.toBoundedOrder.{u1} (Set.{u1} α) (Set.instBooleanAlgebraSet.{u1} α))) s t) -> (Eq.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α (Union.union.{u1} (Set.{u1} α) (Set.instUnionSet.{u1} α) s t)) (Union.union.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instUnionSet.{u1} (Prod.{u1, u1} α α)) (Union.union.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instUnionSet.{u1} (Prod.{u1, u1} α α)) (Union.union.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instUnionSet.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α s) (Set.offDiag.{u1} α t)) (Set.prod.{u1, u1} α α s t)) (Set.prod.{u1, u1} α α t s)))
-Case conversion may be inaccurate. Consider using '#align set.off_diag_union Set.offDiag_unionₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -1177,12 +757,6 @@ theorem offDiag_union (h : Disjoint s t) :
   rintro i j (⟨hi, hj⟩ | ⟨hi, hj⟩) rfl <;> exact h.le_bot ⟨‹_›, ‹_›⟩
 #align set.off_diag_union Set.offDiag_union
 
-/- warning: set.off_diag_insert -> Set.offDiag_insert is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {s : Set.{u1} α} {a : α}, (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s)) -> (Eq.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a s)) (Union.union.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.hasUnion.{u1} (Prod.{u1, u1} α α)) (Union.union.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.hasUnion.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α s) (Set.prod.{u1, u1} α α (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a) s)) (Set.prod.{u1, u1} α α s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a))))
-but is expected to have type
-  forall {α : Type.{u1}} {s : Set.{u1} α} {a : α}, (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s)) -> (Eq.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a s)) (Union.union.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instUnionSet.{u1} (Prod.{u1, u1} α α)) (Union.union.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instUnionSet.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α s) (Set.prod.{u1, u1} α α (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a) s)) (Set.prod.{u1, u1} α α s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a))))
-Case conversion may be inaccurate. Consider using '#align set.off_diag_insert Set.offDiag_insertₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem offDiag_insert (ha : a ∉ s) : (insert a s).offDiag = s.offDiag ∪ {a} ×ˢ s ∪ s ×ˢ {a} :=
@@ -1211,23 +785,11 @@ def pi (s : Set ι) (t : ∀ i, Set (α i)) : Set (∀ i, α i) :=
 #align set.pi Set.pi
 -/
 
-/- warning: set.mem_pi -> Set.mem_pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {s : Set.{u1} ι} {t : forall (i : ι), Set.{u2} (α i)} {f : forall (i : ι), α i}, Iff (Membership.Mem.{max u1 u2, max u1 u2} (forall (i : ι), α i) (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasMem.{max u1 u2} (forall (i : ι), α i)) f (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t)) (forall (i : ι), (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (Membership.Mem.{u2, u2} (α i) (Set.{u2} (α i)) (Set.hasMem.{u2} (α i)) (f i) (t i)))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {s : Set.{u2} ι} {t : forall (i : ι), Set.{u1} (α i)} {f : forall (i : ι), α i}, Iff (Membership.mem.{max u2 u1, max u2 u1} (forall (i : ι), α i) (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instMembershipSet.{max u2 u1} (forall (i : ι), α i)) f (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t)) (forall (i : ι), (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) -> (Membership.mem.{u1, u1} (α i) (Set.{u1} (α i)) (Set.instMembershipSet.{u1} (α i)) (f i) (t i)))
-Case conversion may be inaccurate. Consider using '#align set.mem_pi Set.mem_piₓ'. -/
 @[simp]
 theorem mem_pi {f : ∀ i, α i} : f ∈ s.pi t ↔ ∀ i ∈ s, f i ∈ t i :=
   Iff.rfl
 #align set.mem_pi Set.mem_pi
 
-/- warning: set.mem_univ_pi -> Set.mem_univ_pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {t : forall (i : ι), Set.{u2} (α i)} {f : forall (i : ι), α i}, Iff (Membership.Mem.{max u1 u2, max u1 u2} (forall (i : ι), α i) (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasMem.{max u1 u2} (forall (i : ι), α i)) f (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Set.univ.{u1} ι) t)) (forall (i : ι), Membership.Mem.{u2, u2} (α i) (Set.{u2} (α i)) (Set.hasMem.{u2} (α i)) (f i) (t i))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {t : forall (i : ι), Set.{u1} (α i)} {f : forall (i : ι), α i}, Iff (Membership.mem.{max u2 u1, max u1 u2} (forall (i : ι), α i) (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instMembershipSet.{max u2 u1} (forall (i : ι), α i)) f (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (Set.univ.{u2} ι) t)) (forall (i : ι), Membership.mem.{u1, u1} (α i) (Set.{u1} (α i)) (Set.instMembershipSet.{u1} (α i)) (f i) (t i))
-Case conversion may be inaccurate. Consider using '#align set.mem_univ_pi Set.mem_univ_piₓ'. -/
 @[simp]
 theorem mem_univ_pi {f : ∀ i, α i} : f ∈ pi univ t ↔ ∀ i, f i ∈ t i := by simp
 #align set.mem_univ_pi Set.mem_univ_pi
@@ -1238,52 +800,22 @@ theorem empty_pi (s : ∀ i, Set (α i)) : pi ∅ s = univ := by ext; simp [pi]
 #align set.empty_pi Set.empty_pi
 -/
 
-/- warning: set.pi_univ -> Set.pi_univ is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} (s : Set.{u1} ι), Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s (fun (i : ι) => Set.univ.{u2} (α i))) (Set.univ.{max u1 u2} (forall (i : ι), α i))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} (s : Set.{u2} ι), Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s (fun (i : ι) => Set.univ.{u1} (α i))) (Set.univ.{max u2 u1} (forall (i : ι), α i))
-Case conversion may be inaccurate. Consider using '#align set.pi_univ Set.pi_univₓ'. -/
 @[simp]
 theorem pi_univ (s : Set ι) : (pi s fun i => (univ : Set (α i))) = univ :=
   eq_univ_of_forall fun f i hi => mem_univ _
 #align set.pi_univ Set.pi_univ
 
-/- warning: set.pi_mono -> Set.pi_mono is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {s : Set.{u1} ι} {t₁ : forall (i : ι), Set.{u2} (α i)} {t₂ : forall (i : ι), Set.{u2} (α i)}, (forall (i : ι), (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (HasSubset.Subset.{u2} (Set.{u2} (α i)) (Set.hasSubset.{u2} (α i)) (t₁ i) (t₂ i))) -> (HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasSubset.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t₁) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t₂))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {s : Set.{u2} ι} {t₁ : forall (i : ι), Set.{u1} (α i)} {t₂ : forall (i : ι), Set.{u1} (α i)}, (forall (i : ι), (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) -> (HasSubset.Subset.{u1} (Set.{u1} (α i)) (Set.instHasSubsetSet.{u1} (α i)) (t₁ i) (t₂ i))) -> (HasSubset.Subset.{max u1 u2} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instHasSubsetSet.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t₁) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t₂))
-Case conversion may be inaccurate. Consider using '#align set.pi_mono Set.pi_monoₓ'. -/
 theorem pi_mono (h : ∀ i ∈ s, t₁ i ⊆ t₂ i) : pi s t₁ ⊆ pi s t₂ := fun x hx i hi => h i hi <| hx i hi
 #align set.pi_mono Set.pi_mono
 
-/- warning: set.pi_inter_distrib -> Set.pi_inter_distrib is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {s : Set.{u1} ι} {t : forall (i : ι), Set.{u2} (α i)} {t₁ : forall (i : ι), Set.{u2} (α i)}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s (fun (i : ι) => Inter.inter.{u2} (Set.{u2} (α i)) (Set.hasInter.{u2} (α i)) (t i) (t₁ i))) (Inter.inter.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasInter.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t₁))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {s : Set.{u2} ι} {t : forall (i : ι), Set.{u1} (α i)} {t₁ : forall (i : ι), Set.{u1} (α i)}, Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s (fun (i : ι) => Inter.inter.{u1} (Set.{u1} (α i)) (Set.instInterSet.{u1} (α i)) (t i) (t₁ i))) (Inter.inter.{max u2 u1} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instInterSet.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t₁))
-Case conversion may be inaccurate. Consider using '#align set.pi_inter_distrib Set.pi_inter_distribₓ'. -/
 theorem pi_inter_distrib : (s.pi fun i => t i ∩ t₁ i) = s.pi t ∩ s.pi t₁ :=
   ext fun x => by simp only [forall_and, mem_pi, mem_inter_iff]
 #align set.pi_inter_distrib Set.pi_inter_distrib
 
-/- warning: set.pi_congr -> Set.pi_congr is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {s₁ : Set.{u1} ι} {s₂ : Set.{u1} ι} {t₁ : forall (i : ι), Set.{u2} (α i)} {t₂ : forall (i : ι), Set.{u2} (α i)}, (Eq.{succ u1} (Set.{u1} ι) s₁ s₂) -> (forall (i : ι), (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s₁) -> (Eq.{succ u2} (Set.{u2} (α i)) (t₁ i) (t₂ i))) -> (Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s₁ t₁) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s₂ t₂))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {s₁ : Set.{u2} ι} {s₂ : Set.{u2} ι} {t₁ : forall (i : ι), Set.{u1} (α i)} {t₂ : forall (i : ι), Set.{u1} (α i)}, (Eq.{succ u2} (Set.{u2} ι) s₁ s₂) -> (forall (i : ι), (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s₁) -> (Eq.{succ u1} (Set.{u1} (α i)) (t₁ i) (t₂ i))) -> (Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s₁ t₁) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s₂ t₂))
-Case conversion may be inaccurate. Consider using '#align set.pi_congr Set.pi_congrₓ'. -/
 theorem pi_congr (h : s₁ = s₂) (h' : ∀ i ∈ s₁, t₁ i = t₂ i) : s₁.pi t₁ = s₂.pi t₂ :=
   h ▸ ext fun x => forall₂_congr fun i hi => h' i hi ▸ Iff.rfl
 #align set.pi_congr Set.pi_congr
 
-/- warning: set.pi_eq_empty -> Set.pi_eq_empty is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {s : Set.{u1} ι} {t : forall (i : ι), Set.{u2} (α i)} {i : ι}, (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (Eq.{succ u2} (Set.{u2} (α i)) (t i) (EmptyCollection.emptyCollection.{u2} (Set.{u2} (α i)) (Set.hasEmptyc.{u2} (α i)))) -> (Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t) (EmptyCollection.emptyCollection.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasEmptyc.{max u1 u2} (forall (i : ι), α i))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {s : Set.{u2} ι} {t : forall (i : ι), Set.{u1} (α i)} {i : ι}, (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) -> (Eq.{succ u1} (Set.{u1} (α i)) (t i) (EmptyCollection.emptyCollection.{u1} (Set.{u1} (α i)) (Set.instEmptyCollectionSet.{u1} (α i)))) -> (Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t) (EmptyCollection.emptyCollection.{max u2 u1} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instEmptyCollectionSet.{max u2 u1} (forall (i : ι), α i))))
-Case conversion may be inaccurate. Consider using '#align set.pi_eq_empty Set.pi_eq_emptyₓ'. -/
 theorem pi_eq_empty (hs : i ∈ s) (ht : t i = ∅) : s.pi t = ∅ :=
   by
   ext f; simp only [mem_empty_iff_false, not_forall, iff_false_iff, mem_pi, not_imp]
@@ -1296,32 +828,14 @@ theorem univ_pi_eq_empty (ht : t i = ∅) : pi univ t = ∅ :=
 #align set.univ_pi_eq_empty Set.univ_pi_eq_empty
 -/
 
-/- warning: set.pi_nonempty_iff -> Set.pi_nonempty_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {s : Set.{u1} ι} {t : forall (i : ι), Set.{u2} (α i)}, Iff (Set.Nonempty.{max u1 u2} (forall (i : ι), α i) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t)) (forall (i : ι), Exists.{succ u2} (α i) (fun (x : α i) => (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (Membership.Mem.{u2, u2} (α i) (Set.{u2} (α i)) (Set.hasMem.{u2} (α i)) x (t i))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {s : Set.{u2} ι} {t : forall (i : ι), Set.{u1} (α i)}, Iff (Set.Nonempty.{max u2 u1} (forall (i : ι), α i) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t)) (forall (i : ι), Exists.{succ u1} (α i) (fun (x : α i) => (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) -> (Membership.mem.{u1, u1} (α i) (Set.{u1} (α i)) (Set.instMembershipSet.{u1} (α i)) x (t i))))
-Case conversion may be inaccurate. Consider using '#align set.pi_nonempty_iff Set.pi_nonempty_iffₓ'. -/
 theorem pi_nonempty_iff : (s.pi t).Nonempty ↔ ∀ i, ∃ x, i ∈ s → x ∈ t i := by
   simp [Classical.skolem, Set.Nonempty]
 #align set.pi_nonempty_iff Set.pi_nonempty_iff
 
-/- warning: set.univ_pi_nonempty_iff -> Set.univ_pi_nonempty_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {t : forall (i : ι), Set.{u2} (α i)}, Iff (Set.Nonempty.{max u1 u2} (forall (i : ι), α i) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Set.univ.{u1} ι) t)) (forall (i : ι), Set.Nonempty.{u2} (α i) (t i))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {t : forall (i : ι), Set.{u1} (α i)}, Iff (Set.Nonempty.{max u2 u1} (forall (i : ι), α i) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (Set.univ.{u2} ι) t)) (forall (i : ι), Set.Nonempty.{u1} (α i) (t i))
-Case conversion may be inaccurate. Consider using '#align set.univ_pi_nonempty_iff Set.univ_pi_nonempty_iffₓ'. -/
 theorem univ_pi_nonempty_iff : (pi univ t).Nonempty ↔ ∀ i, (t i).Nonempty := by
   simp [Classical.skolem, Set.Nonempty]
 #align set.univ_pi_nonempty_iff Set.univ_pi_nonempty_iff
 
-/- warning: set.pi_eq_empty_iff -> Set.pi_eq_empty_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {s : Set.{u1} ι} {t : forall (i : ι), Set.{u2} (α i)}, Iff (Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t) (EmptyCollection.emptyCollection.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasEmptyc.{max u1 u2} (forall (i : ι), α i)))) (Exists.{succ u1} ι (fun (i : ι) => Or (IsEmpty.{succ u2} (α i)) (And (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) (Eq.{succ u2} (Set.{u2} (α i)) (t i) (EmptyCollection.emptyCollection.{u2} (Set.{u2} (α i)) (Set.hasEmptyc.{u2} (α i)))))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {s : Set.{u2} ι} {t : forall (i : ι), Set.{u1} (α i)}, Iff (Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t) (EmptyCollection.emptyCollection.{max u2 u1} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instEmptyCollectionSet.{max u2 u1} (forall (i : ι), α i)))) (Exists.{succ u2} ι (fun (i : ι) => Or (IsEmpty.{succ u1} (α i)) (And (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (Eq.{succ u1} (Set.{u1} (α i)) (t i) (EmptyCollection.emptyCollection.{u1} (Set.{u1} (α i)) (Set.instEmptyCollectionSet.{u1} (α i)))))))
-Case conversion may be inaccurate. Consider using '#align set.pi_eq_empty_iff Set.pi_eq_empty_iffₓ'. -/
 theorem pi_eq_empty_iff : s.pi t = ∅ ↔ ∃ i, IsEmpty (α i) ∨ i ∈ s ∧ t i = ∅ :=
   by
   rw [← not_nonempty_iff_eq_empty, pi_nonempty_iff]
@@ -1330,45 +844,21 @@ theorem pi_eq_empty_iff : s.pi t = ∅ ↔ ∃ i, IsEmpty (α i) ∨ i ∈ s ∧
   cases isEmpty_or_nonempty (α i) <;> simp [*, forall_and, eq_empty_iff_forall_not_mem]
 #align set.pi_eq_empty_iff Set.pi_eq_empty_iff
 
-/- warning: set.univ_pi_eq_empty_iff -> Set.univ_pi_eq_empty_iff is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {t : forall (i : ι), Set.{u2} (α i)}, Iff (Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Set.univ.{u1} ι) t) (EmptyCollection.emptyCollection.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasEmptyc.{max u1 u2} (forall (i : ι), α i)))) (Exists.{succ u1} ι (fun (i : ι) => Eq.{succ u2} (Set.{u2} (α i)) (t i) (EmptyCollection.emptyCollection.{u2} (Set.{u2} (α i)) (Set.hasEmptyc.{u2} (α i)))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {t : forall (i : ι), Set.{u1} (α i)}, Iff (Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (Set.univ.{u2} ι) t) (EmptyCollection.emptyCollection.{max u2 u1} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instEmptyCollectionSet.{max u2 u1} (forall (i : ι), α i)))) (Exists.{succ u2} ι (fun (i : ι) => Eq.{succ u1} (Set.{u1} (α i)) (t i) (EmptyCollection.emptyCollection.{u1} (Set.{u1} (α i)) (Set.instEmptyCollectionSet.{u1} (α i)))))
-Case conversion may be inaccurate. Consider using '#align set.univ_pi_eq_empty_iff Set.univ_pi_eq_empty_iffₓ'. -/
 @[simp]
 theorem univ_pi_eq_empty_iff : pi univ t = ∅ ↔ ∃ i, t i = ∅ := by
   simp [← not_nonempty_iff_eq_empty, univ_pi_nonempty_iff]
 #align set.univ_pi_eq_empty_iff Set.univ_pi_eq_empty_iff
 
-/- warning: set.univ_pi_empty -> Set.univ_pi_empty is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [h : Nonempty.{succ u1} ι], Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Set.univ.{u1} ι) (fun (i : ι) => EmptyCollection.emptyCollection.{u2} (Set.{u2} (α i)) (Set.hasEmptyc.{u2} (α i)))) (EmptyCollection.emptyCollection.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasEmptyc.{max u1 u2} (forall (i : ι), α i)))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [h : Nonempty.{succ u2} ι], Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (Set.univ.{u2} ι) (fun (i : ι) => EmptyCollection.emptyCollection.{u1} (Set.{u1} (α i)) (Set.instEmptyCollectionSet.{u1} (α i)))) (EmptyCollection.emptyCollection.{max u2 u1} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instEmptyCollectionSet.{max u2 u1} (forall (i : ι), α i)))
-Case conversion may be inaccurate. Consider using '#align set.univ_pi_empty Set.univ_pi_emptyₓ'. -/
 @[simp]
 theorem univ_pi_empty [h : Nonempty ι] : pi univ (fun i => ∅ : ∀ i, Set (α i)) = ∅ :=
   univ_pi_eq_empty_iff.2 <| h.elim fun x => ⟨x, rfl⟩
 #align set.univ_pi_empty Set.univ_pi_empty
 
-/- warning: set.disjoint_univ_pi -> Set.disjoint_univ_pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {t₁ : forall (i : ι), Set.{u2} (α i)} {t₂ : forall (i : ι), Set.{u2} (α i)}, Iff (Disjoint.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (SemilatticeInf.toPartialOrder.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Lattice.toSemilatticeInf.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (GeneralizedCoheytingAlgebra.toLattice.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.booleanAlgebra.{max u1 u2} (forall (i : ι), α i))))))) (GeneralizedBooleanAlgebra.toOrderBot.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.booleanAlgebra.{max u1 u2} (forall (i : ι), α i)))) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Set.univ.{u1} ι) t₁) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Set.univ.{u1} ι) t₂)) (Exists.{succ u1} ι (fun (i : ι) => Disjoint.{u2} (Set.{u2} (α i)) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} (α i)) (Lattice.toSemilatticeInf.{u2} (Set.{u2} (α i)) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} (α i)) (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} (α i)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} (Set.{u2} (α i)) (Set.booleanAlgebra.{u2} (α i))))))) (GeneralizedBooleanAlgebra.toOrderBot.{u2} (Set.{u2} (α i)) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u2} (Set.{u2} (α i)) (Set.booleanAlgebra.{u2} (α i)))) (t₁ i) (t₂ i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {t₁ : forall (i : ι), Set.{u2} (α i)} {t₂ : forall (i : ι), Set.{u2} (α i)}, Iff (Disjoint.{max u2 u1} (Set.{max u1 u2} (forall (i : ι), α i)) (SemilatticeInf.toPartialOrder.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Lattice.toSemilatticeInf.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (GeneralizedCoheytingAlgebra.toLattice.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (BiheytingAlgebra.toCoheytingAlgebra.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (BooleanAlgebra.toBiheytingAlgebra.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.instBooleanAlgebraSet.{max u1 u2} (forall (i : ι), α i)))))))) (BoundedOrder.toOrderBot.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Preorder.toLE.{max u2 u1} (Set.{max u1 u2} (forall (i : ι), α i)) (PartialOrder.toPreorder.{max u2 u1} (Set.{max u1 u2} (forall (i : ι), α i)) (SemilatticeInf.toPartialOrder.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Lattice.toSemilatticeInf.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (GeneralizedCoheytingAlgebra.toLattice.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (BiheytingAlgebra.toCoheytingAlgebra.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (BooleanAlgebra.toBiheytingAlgebra.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.instBooleanAlgebraSet.{max u1 u2} (forall (i : ι), α i)))))))))) (BooleanAlgebra.toBoundedOrder.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.instBooleanAlgebraSet.{max u1 u2} (forall (i : ι), α i)))) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Set.univ.{u1} ι) t₁) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Set.univ.{u1} ι) t₂)) (Exists.{succ u1} ι (fun (i : ι) => Disjoint.{u2} (Set.{u2} (α i)) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} (α i)) (Lattice.toSemilatticeInf.{u2} (Set.{u2} (α i)) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} (α i)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} (α i)) (BiheytingAlgebra.toCoheytingAlgebra.{u2} (Set.{u2} (α i)) (BooleanAlgebra.toBiheytingAlgebra.{u2} (Set.{u2} (α i)) (Set.instBooleanAlgebraSet.{u2} (α i)))))))) (BoundedOrder.toOrderBot.{u2} (Set.{u2} (α i)) (Preorder.toLE.{u2} (Set.{u2} (α i)) (PartialOrder.toPreorder.{u2} (Set.{u2} (α i)) (SemilatticeInf.toPartialOrder.{u2} (Set.{u2} (α i)) (Lattice.toSemilatticeInf.{u2} (Set.{u2} (α i)) (GeneralizedCoheytingAlgebra.toLattice.{u2} (Set.{u2} (α i)) (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u2} (Set.{u2} (α i)) (BiheytingAlgebra.toCoheytingAlgebra.{u2} (Set.{u2} (α i)) (BooleanAlgebra.toBiheytingAlgebra.{u2} (Set.{u2} (α i)) (Set.instBooleanAlgebraSet.{u2} (α i)))))))))) (BooleanAlgebra.toBoundedOrder.{u2} (Set.{u2} (α i)) (Set.instBooleanAlgebraSet.{u2} (α i)))) (t₁ i) (t₂ i)))
-Case conversion may be inaccurate. Consider using '#align set.disjoint_univ_pi Set.disjoint_univ_piₓ'. -/
 @[simp]
 theorem disjoint_univ_pi : Disjoint (pi univ t₁) (pi univ t₂) ↔ ∃ i, Disjoint (t₁ i) (t₂ i) := by
   simp only [disjoint_iff_inter_eq_empty, ← pi_inter_distrib, univ_pi_eq_empty_iff]
 #align set.disjoint_univ_pi Set.disjoint_univ_pi
 
-/- warning: set.range_dcomp -> Set.range_dcomp is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {β : ι -> Type.{u3}} (f : forall (i : ι), (α i) -> (β i)), Eq.{succ (max u1 u3)} (Set.{max u1 u3} (forall (i : ι), β i)) (Set.range.{max u1 u3, max (succ u1) (succ u2)} (forall (i : ι), β i) (forall (i : ι), α i) (fun (g : forall (i : ι), α i) (i : ι) => f i (g i))) (Set.pi.{u1, u3} ι (fun (i : ι) => β i) (Set.univ.{u1} ι) (fun (i : ι) => Set.range.{u3, succ u2} (β i) (α i) (f i)))
-but is expected to have type
-  forall {ι : Type.{u3}} {α : ι -> Type.{u1}} {β : ι -> Type.{u2}} (f : forall (i : ι), (α i) -> (β i)), Eq.{max (succ u3) (succ u2)} (Set.{max u3 u2} (forall (i : ι), β i)) (Set.range.{max u3 u2, max (succ u3) (succ u1)} (forall (i : ι), β i) (forall (i : ι), α i) (fun (g : forall (i : ι), α i) (i : ι) => f i (g i))) (Set.pi.{u3, u2} ι (fun (i : ι) => β i) (Set.univ.{u3} ι) (fun (i : ι) => Set.range.{u2, succ u1} (β i) (α i) (f i)))
-Case conversion may be inaccurate. Consider using '#align set.range_dcomp Set.range_dcompₓ'. -/
 @[simp]
 theorem range_dcomp (f : ∀ i, α i → β i) :
     (range fun g : ∀ i, α i => fun i => f i (g i)) = pi univ fun i => range (f i) :=
@@ -1380,12 +870,6 @@ theorem range_dcomp (f : ∀ i, α i → β i) :
     exact ⟨fun i => y i trivial, funext fun i => hy i trivial⟩
 #align set.range_dcomp Set.range_dcomp
 
-/- warning: set.insert_pi -> Set.insert_pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} (i : ι) (s : Set.{u1} ι) (t : forall (i : ι), Set.{u2} (α i)), Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Insert.insert.{u1, u1} ι (Set.{u1} ι) (Set.hasInsert.{u1} ι) i s) t) (Inter.inter.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasInter.{max u1 u2} (forall (i : ι), α i)) (Set.preimage.{max u1 u2, u2} (forall (i : ι), α i) (α i) (Function.eval.{succ u1, succ u2} ι (fun (i : ι) => α i) i) (t i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} (i : ι) (s : Set.{u2} ι) (t : forall (i : ι), Set.{u1} (α i)), Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (Insert.insert.{u2, u2} ι (Set.{u2} ι) (Set.instInsertSet.{u2} ι) i s) t) (Inter.inter.{max u2 u1} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instInterSet.{max u2 u1} (forall (i : ι), α i)) (Set.preimage.{max u2 u1, u1} (forall (i : ι), α i) (α i) (Function.eval.{succ u2, succ u1} ι α i) (t i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t))
-Case conversion may be inaccurate. Consider using '#align set.insert_pi Set.insert_piₓ'. -/
 @[simp]
 theorem insert_pi (i : ι) (s : Set ι) (t : ∀ i, Set (α i)) :
     pi (insert i s) t = eval i ⁻¹' t i ∩ pi s t := by ext; simp [pi, or_imp, forall_and]
@@ -1403,33 +887,15 @@ theorem singleton_pi' (i : ι) (t : ∀ i, Set (α i)) : pi {i} t = { x | x i 
 #align set.singleton_pi' Set.singleton_pi'
 -/
 
-/- warning: set.univ_pi_singleton -> Set.univ_pi_singleton is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} (f : forall (i : ι), α i), Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Set.univ.{u1} ι) (fun (i : ι) => Singleton.singleton.{u2, u2} (α i) (Set.{u2} (α i)) (Set.hasSingleton.{u2} (α i)) (f i))) (Singleton.singleton.{max u1 u2, max u1 u2} (forall (i : ι), α i) (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasSingleton.{max u1 u2} (forall (i : ι), α i)) f)
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} (f : forall (i : ι), α i), Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (Set.univ.{u2} ι) (fun (i : ι) => Singleton.singleton.{u1, u1} (α i) (Set.{u1} (α i)) (Set.instSingletonSet.{u1} (α i)) (f i))) (Singleton.singleton.{max u2 u1, max u2 u1} (forall (i : ι), α i) (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instSingletonSet.{max u2 u1} (forall (i : ι), α i)) f)
-Case conversion may be inaccurate. Consider using '#align set.univ_pi_singleton Set.univ_pi_singletonₓ'. -/
 theorem univ_pi_singleton (f : ∀ i, α i) : (pi univ fun i => {f i}) = ({f} : Set (∀ i, α i)) :=
   ext fun g => by simp [funext_iff]
 #align set.univ_pi_singleton Set.univ_pi_singleton
 
-/- warning: set.preimage_pi -> Set.preimage_pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {β : ι -> Type.{u3}} (s : Set.{u1} ι) (t : forall (i : ι), Set.{u3} (β i)) (f : forall (i : ι), (α i) -> (β i)), Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.preimage.{max u1 u2, max u1 u3} (forall (i : ι), α i) (forall (i : ι), β i) (fun (g : forall (i : ι), α i) (i : ι) => f i (g i)) (Set.pi.{u1, u3} ι (fun (i : ι) => β i) s t)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s (fun (i : ι) => Set.preimage.{u2, u3} (α i) (β i) (f i) (t i)))
-but is expected to have type
-  forall {ι : Type.{u3}} {α : ι -> Type.{u1}} {β : ι -> Type.{u2}} (s : Set.{u3} ι) (t : forall (i : ι), Set.{u2} (β i)) (f : forall (i : ι), (α i) -> (β i)), Eq.{max (succ u3) (succ u1)} (Set.{max u3 u1} (forall (i : ι), α i)) (Set.preimage.{max u3 u1, max u3 u2} (forall (i : ι), α i) (forall (i : ι), β i) (fun (g : forall (i : ι), α i) (i : ι) => f i (g i)) (Set.pi.{u3, u2} ι (fun (i : ι) => β i) s t)) (Set.pi.{u3, u1} ι (fun (i : ι) => α i) s (fun (i : ι) => Set.preimage.{u1, u2} (α i) (β i) (f i) (t i)))
-Case conversion may be inaccurate. Consider using '#align set.preimage_pi Set.preimage_piₓ'. -/
 theorem preimage_pi (s : Set ι) (t : ∀ i, Set (β i)) (f : ∀ i, α i → β i) :
     (fun (g : ∀ i, α i) i => f _ (g i)) ⁻¹' s.pi t = s.pi fun i => f i ⁻¹' t i :=
   rfl
 #align set.preimage_pi Set.preimage_pi
 
-/- warning: set.pi_if -> Set.pi_if is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {p : ι -> Prop} [h : DecidablePred.{succ u1} ι p] (s : Set.{u1} ι) (t₁ : forall (i : ι), Set.{u2} (α i)) (t₂ : forall (i : ι), Set.{u2} (α i)), Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s (fun (i : ι) => ite.{succ u2} (Set.{u2} (α i)) (p i) (h i) (t₁ i) (t₂ i))) (Inter.inter.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasInter.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Sep.sep.{u1, u1} ι (Set.{u1} ι) (Set.hasSep.{u1} ι) (fun (i : ι) => p i) s) t₁) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Sep.sep.{u1, u1} ι (Set.{u1} ι) (Set.hasSep.{u1} ι) (fun (i : ι) => Not (p i)) s) t₂))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {p : ι -> Prop} [h : DecidablePred.{succ u2} ι p] (s : Set.{u2} ι) (t₁ : forall (i : ι), Set.{u1} (α i)) (t₂ : forall (i : ι), Set.{u1} (α i)), Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s (fun (i : ι) => ite.{succ u1} (Set.{u1} (α i)) (p i) (h i) (t₁ i) (t₂ i))) (Inter.inter.{max u1 u2} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instInterSet.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (setOf.{u2} ι (fun (i : ι) => And (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (p i))) t₁) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (setOf.{u2} ι (fun (i : ι) => And (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (Not (p i)))) t₂))
-Case conversion may be inaccurate. Consider using '#align set.pi_if Set.pi_ifₓ'. -/
 theorem pi_if {p : ι → Prop} [h : DecidablePred p] (s : Set ι) (t₁ t₂ : ∀ i, Set (α i)) :
     (pi s fun i => if p i then t₁ i else t₂ i) =
       pi ({ i ∈ s | p i }) t₁ ∩ pi ({ i ∈ s | ¬p i }) t₂ :=
@@ -1441,44 +907,20 @@ theorem pi_if {p : ι → Prop} [h : DecidablePred p] (s : Set ι) (t₁ t₂ :
     by_cases p i <;> simp_all
 #align set.pi_if Set.pi_if
 
-/- warning: set.union_pi -> Set.union_pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {s₁ : Set.{u1} ι} {s₂ : Set.{u1} ι} {t : forall (i : ι), Set.{u2} (α i)}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Union.union.{u1} (Set.{u1} ι) (Set.hasUnion.{u1} ι) s₁ s₂) t) (Inter.inter.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasInter.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s₁ t) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s₂ t))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {s₁ : Set.{u2} ι} {s₂ : Set.{u2} ι} {t : forall (i : ι), Set.{u1} (α i)}, Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (Union.union.{u2} (Set.{u2} ι) (Set.instUnionSet.{u2} ι) s₁ s₂) t) (Inter.inter.{max u2 u1} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instInterSet.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s₁ t) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s₂ t))
-Case conversion may be inaccurate. Consider using '#align set.union_pi Set.union_piₓ'. -/
 theorem union_pi : (s₁ ∪ s₂).pi t = s₁.pi t ∩ s₂.pi t := by
   simp [pi, or_imp, forall_and, set_of_and]
 #align set.union_pi Set.union_pi
 
-/- warning: set.pi_inter_compl -> Set.pi_inter_compl is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {t : forall (i : ι), Set.{u2} (α i)} (s : Set.{u1} ι), Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Inter.inter.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasInter.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (HasCompl.compl.{u1} (Set.{u1} ι) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} ι) (Set.booleanAlgebra.{u1} ι)) s) t)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Set.univ.{u1} ι) t)
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {t : forall (i : ι), Set.{u1} (α i)} (s : Set.{u2} ι), Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Inter.inter.{max u1 u2} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instInterSet.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (HasCompl.compl.{u2} (Set.{u2} ι) (BooleanAlgebra.toHasCompl.{u2} (Set.{u2} ι) (Set.instBooleanAlgebraSet.{u2} ι)) s) t)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (Set.univ.{u2} ι) t)
-Case conversion may be inaccurate. Consider using '#align set.pi_inter_compl Set.pi_inter_complₓ'. -/
 @[simp]
 theorem pi_inter_compl (s : Set ι) : pi s t ∩ pi (sᶜ) t = pi univ t := by
   rw [← union_pi, union_compl_self]
 #align set.pi_inter_compl Set.pi_inter_compl
 
-/- warning: set.pi_update_of_not_mem -> Set.pi_update_of_not_mem is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {β : ι -> Type.{u3}} {s : Set.{u1} ι} {i : ι} [_inst_1 : DecidableEq.{succ u1} ι], (Not (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s)) -> (forall (f : forall (j : ι), α j) (a : α i) (t : forall (j : ι), (α j) -> (Set.{u3} (β j))), Eq.{succ (max u1 u3)} (Set.{max u1 u3} (forall (i : ι), β i)) (Set.pi.{u1, u3} ι (fun (j : ι) => β j) s (fun (j : ι) => t j (Function.update.{succ u1, succ u2} ι α (fun (a : ι) (b : ι) => _inst_1 a b) f i a j))) (Set.pi.{u1, u3} ι (fun (i : ι) => β i) s (fun (j : ι) => t j (f j))))
-but is expected to have type
-  forall {ι : Type.{u3}} {α : ι -> Type.{u1}} {β : ι -> Type.{u2}} {s : Set.{u3} ι} {i : ι} [_inst_1 : DecidableEq.{succ u3} ι], (Not (Membership.mem.{u3, u3} ι (Set.{u3} ι) (Set.instMembershipSet.{u3} ι) i s)) -> (forall (f : forall (j : ι), α j) (a : α i) (t : forall (j : ι), (α j) -> (Set.{u2} (β j))), Eq.{max (succ u3) (succ u2)} (Set.{max u3 u2} (forall (i : ι), β i)) (Set.pi.{u3, u2} ι (fun (j : ι) => β j) s (fun (j : ι) => t j (Function.update.{succ u3, succ u1} ι (fun (a : ι) => α a) (fun (a : ι) (b : ι) => _inst_1 a b) f i a j))) (Set.pi.{u3, u2} ι (fun (i : ι) => β i) s (fun (j : ι) => t j (f j))))
-Case conversion may be inaccurate. Consider using '#align set.pi_update_of_not_mem Set.pi_update_of_not_memₓ'. -/
 theorem pi_update_of_not_mem [DecidableEq ι] (hi : i ∉ s) (f : ∀ j, α j) (a : α i)
     (t : ∀ j, α j → Set (β j)) : (s.pi fun j => t j (update f i a j)) = s.pi fun j => t j (f j) :=
   pi_congr rfl fun j hj => by rw [update_noteq]; exact fun h => hi (h ▸ hj)
 #align set.pi_update_of_not_mem Set.pi_update_of_not_mem
 
-/- warning: set.pi_update_of_mem -> Set.pi_update_of_mem is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {β : ι -> Type.{u3}} {s : Set.{u1} ι} {i : ι} [_inst_1 : DecidableEq.{succ u1} ι], (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (forall (f : forall (j : ι), α j) (a : α i) (t : forall (j : ι), (α j) -> (Set.{u3} (β j))), Eq.{succ (max u1 u3)} (Set.{max u1 u3} (forall (i : ι), β i)) (Set.pi.{u1, u3} ι (fun (j : ι) => β j) s (fun (j : ι) => t j (Function.update.{succ u1, succ u2} ι α (fun (a : ι) (b : ι) => _inst_1 a b) f i a j))) (Inter.inter.{max u1 u3} (Set.{max u1 u3} (forall (i : ι), β i)) (Set.hasInter.{max u1 u3} (forall (i : ι), β i)) (setOf.{max u1 u3} (forall (i : ι), β i) (fun (x : forall (i : ι), β i) => Membership.Mem.{u3, u3} (β i) (Set.{u3} (β i)) (Set.hasMem.{u3} (β i)) (x i) (t i a))) (Set.pi.{u1, u3} ι (fun (i : ι) => β i) (SDiff.sdiff.{u1} (Set.{u1} ι) (BooleanAlgebra.toHasSdiff.{u1} (Set.{u1} ι) (Set.booleanAlgebra.{u1} ι)) s (Singleton.singleton.{u1, u1} ι (Set.{u1} ι) (Set.hasSingleton.{u1} ι) i)) (fun (j : ι) => t j (f j)))))
-but is expected to have type
-  forall {ι : Type.{u3}} {α : ι -> Type.{u1}} {β : ι -> Type.{u2}} {s : Set.{u3} ι} {i : ι} [_inst_1 : DecidableEq.{succ u3} ι], (Membership.mem.{u3, u3} ι (Set.{u3} ι) (Set.instMembershipSet.{u3} ι) i s) -> (forall (f : forall (j : ι), α j) (a : α i) (t : forall (j : ι), (α j) -> (Set.{u2} (β j))), Eq.{max (succ u3) (succ u2)} (Set.{max u3 u2} (forall (i : ι), β i)) (Set.pi.{u3, u2} ι (fun (j : ι) => β j) s (fun (j : ι) => t j (Function.update.{succ u3, succ u1} ι (fun (a : ι) => α a) (fun (a : ι) (b : ι) => _inst_1 a b) f i a j))) (Inter.inter.{max u3 u2} (Set.{max u3 u2} (forall (i : ι), β i)) (Set.instInterSet.{max u3 u2} (forall (i : ι), β i)) (setOf.{max u3 u2} (forall (i : ι), β i) (fun (x : forall (i : ι), β i) => Membership.mem.{u2, u2} (β i) (Set.{u2} (β i)) (Set.instMembershipSet.{u2} (β i)) (x i) (t i a))) (Set.pi.{u3, u2} ι (fun (i : ι) => β i) (SDiff.sdiff.{u3} (Set.{u3} ι) (Set.instSDiffSet.{u3} ι) s (Singleton.singleton.{u3, u3} ι (Set.{u3} ι) (Set.instSingletonSet.{u3} ι) i)) (fun (j : ι) => t j (f j)))))
-Case conversion may be inaccurate. Consider using '#align set.pi_update_of_mem Set.pi_update_of_memₓ'. -/
 theorem pi_update_of_mem [DecidableEq ι] (hi : i ∈ s) (f : ∀ j, α j) (a : α i)
     (t : ∀ j, α j → Set (β j)) :
     (s.pi fun j => t j (update f i a j)) = { x | x i ∈ t i a } ∩ (s \ {i}).pi fun j => t j (f j) :=
@@ -1490,35 +932,17 @@ theorem pi_update_of_mem [DecidableEq ι] (hi : i ∈ s) (f : ∀ j, α j) (a :
     
 #align set.pi_update_of_mem Set.pi_update_of_mem
 
-/- warning: set.univ_pi_update -> Set.univ_pi_update is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} ι] {β : ι -> Type.{u3}} (i : ι) (f : forall (j : ι), α j) (a : α i) (t : forall (j : ι), (α j) -> (Set.{u3} (β j))), Eq.{succ (max u1 u3)} (Set.{max u1 u3} (forall (i : ι), β i)) (Set.pi.{u1, u3} ι (fun (j : ι) => β j) (Set.univ.{u1} ι) (fun (j : ι) => t j (Function.update.{succ u1, succ u2} ι α (fun (a : ι) (b : ι) => _inst_1 a b) f i a j))) (Inter.inter.{max u1 u3} (Set.{max u1 u3} (forall (i : ι), β i)) (Set.hasInter.{max u1 u3} (forall (i : ι), β i)) (setOf.{max u1 u3} (forall (i : ι), β i) (fun (x : forall (i : ι), β i) => Membership.Mem.{u3, u3} (β i) (Set.{u3} (β i)) (Set.hasMem.{u3} (β i)) (x i) (t i a))) (Set.pi.{u1, u3} ι (fun (i : ι) => β i) (HasCompl.compl.{u1} (Set.{u1} ι) (BooleanAlgebra.toHasCompl.{u1} (Set.{u1} ι) (Set.booleanAlgebra.{u1} ι)) (Singleton.singleton.{u1, u1} ι (Set.{u1} ι) (Set.hasSingleton.{u1} ι) i)) (fun (j : ι) => t j (f j))))
-but is expected to have type
-  forall {ι : Type.{u3}} {α : ι -> Type.{u1}} [_inst_1 : DecidableEq.{succ u3} ι] {β : ι -> Type.{u2}} (i : ι) (f : forall (j : ι), α j) (a : α i) (t : forall (j : ι), (α j) -> (Set.{u2} (β j))), Eq.{max (succ u3) (succ u2)} (Set.{max u3 u2} (forall (i : ι), β i)) (Set.pi.{u3, u2} ι (fun (j : ι) => β j) (Set.univ.{u3} ι) (fun (j : ι) => t j (Function.update.{succ u3, succ u1} ι (fun (a : ι) => α a) (fun (a : ι) (b : ι) => _inst_1 a b) f i a j))) (Inter.inter.{max u2 u3} (Set.{max u2 u3} (forall (i : ι), β i)) (Set.instInterSet.{max u3 u2} (forall (i : ι), β i)) (setOf.{max u2 u3} (forall (i : ι), β i) (fun (x : forall (i : ι), β i) => Membership.mem.{u2, u2} (β i) (Set.{u2} (β i)) (Set.instMembershipSet.{u2} (β i)) (x i) (t i a))) (Set.pi.{u3, u2} ι (fun (i : ι) => β i) (HasCompl.compl.{u3} (Set.{u3} ι) (BooleanAlgebra.toHasCompl.{u3} (Set.{u3} ι) (Set.instBooleanAlgebraSet.{u3} ι)) (Singleton.singleton.{u3, u3} ι (Set.{u3} ι) (Set.instSingletonSet.{u3} ι) i)) (fun (j : ι) => t j (f j))))
-Case conversion may be inaccurate. Consider using '#align set.univ_pi_update Set.univ_pi_updateₓ'. -/
 theorem univ_pi_update [DecidableEq ι] {β : ∀ i, Type _} (i : ι) (f : ∀ j, α j) (a : α i)
     (t : ∀ j, α j → Set (β j)) :
     (pi univ fun j => t j (update f i a j)) = { x | x i ∈ t i a } ∩ pi ({i}ᶜ) fun j => t j (f j) :=
   by rw [compl_eq_univ_diff, ← pi_update_of_mem (mem_univ _)]
 #align set.univ_pi_update Set.univ_pi_update
 
-/- warning: set.univ_pi_update_univ -> Set.univ_pi_update_univ is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : DecidableEq.{succ u1} ι] (i : ι) (s : Set.{u2} (α i)), Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (j : ι) => α j) (Set.univ.{u1} ι) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => Set.{u2} (α i)) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (j : ι) => Set.univ.{u2} (α j)) i s)) (Set.preimage.{max u1 u2, u2} (forall (i : ι), α i) (α i) (Function.eval.{succ u1, succ u2} ι (fun (i : ι) => α i) i) s)
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [_inst_1 : DecidableEq.{succ u2} ι] (i : ι) (s : Set.{u1} (α i)), Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (j : ι) => α j) (Set.univ.{u2} ι) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => Set.{u1} (α i)) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (j : ι) => Set.univ.{u1} (α j)) i s)) (Set.preimage.{max u2 u1, u1} (forall (i : ι), α i) (α i) (Function.eval.{succ u2, succ u1} ι α i) s)
-Case conversion may be inaccurate. Consider using '#align set.univ_pi_update_univ Set.univ_pi_update_univₓ'. -/
 theorem univ_pi_update_univ [DecidableEq ι] (i : ι) (s : Set (α i)) :
     pi univ (update (fun j : ι => (univ : Set (α j))) i s) = eval i ⁻¹' s := by
   rw [univ_pi_update i (fun j => (univ : Set (α j))) s fun j t => t, pi_univ, inter_univ, preimage]
 #align set.univ_pi_update_univ Set.univ_pi_update_univ
 
-/- warning: set.eval_image_pi_subset -> Set.eval_image_pi_subset is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {s : Set.{u1} ι} {t : forall (i : ι), Set.{u2} (α i)} {i : ι}, (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (HasSubset.Subset.{u2} (Set.{u2} (α i)) (Set.hasSubset.{u2} (α i)) (Set.image.{max u1 u2, u2} (forall (x : ι), α x) (α i) (Function.eval.{succ u1, succ u2} ι (fun (x : ι) => α x) i) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t)) (t i))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {s : Set.{u2} ι} {t : forall (i : ι), Set.{u1} (α i)} {i : ι}, (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) -> (HasSubset.Subset.{u1} (Set.{u1} (α i)) (Set.instHasSubsetSet.{u1} (α i)) (Set.image.{max u2 u1, u1} (forall (x : ι), α x) (α i) (Function.eval.{succ u2, succ u1} ι (fun (x : ι) => α x) i) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t)) (t i))
-Case conversion may be inaccurate. Consider using '#align set.eval_image_pi_subset Set.eval_image_pi_subsetₓ'. -/
 theorem eval_image_pi_subset (hs : i ∈ s) : eval i '' s.pi t ⊆ t i :=
   image_subset_iff.2 fun f hf => hf i hs
 #align set.eval_image_pi_subset Set.eval_image_pi_subset
@@ -1529,12 +953,6 @@ theorem eval_image_univ_pi_subset : eval i '' pi univ t ⊆ t i :=
 #align set.eval_image_univ_pi_subset Set.eval_image_univ_pi_subset
 -/
 
-/- warning: set.subset_eval_image_pi -> Set.subset_eval_image_pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {s : Set.{u1} ι} {t : forall (i : ι), Set.{u2} (α i)}, (Set.Nonempty.{max u1 u2} (forall (i : ι), α i) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t)) -> (forall (i : ι), HasSubset.Subset.{u2} (Set.{u2} (α i)) (Set.hasSubset.{u2} (α i)) (t i) (Set.image.{max u1 u2, u2} (forall (x : ι), α x) (α i) (Function.eval.{succ u1, succ u2} ι α i) (Set.pi.{u1, u2} ι (fun (x : ι) => α x) s t)))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {s : Set.{u2} ι} {t : forall (i : ι), Set.{u1} (α i)}, (Set.Nonempty.{max u2 u1} (forall (i : ι), α i) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t)) -> (forall (i : ι), HasSubset.Subset.{u1} (Set.{u1} (α i)) (Set.instHasSubsetSet.{u1} (α i)) (t i) (Set.image.{max u2 u1, u1} (forall (x : ι), α x) (α i) (Function.eval.{succ u2, succ u1} ι α i) (Set.pi.{u2, u1} ι (fun (x : ι) => α x) s t)))
-Case conversion may be inaccurate. Consider using '#align set.subset_eval_image_pi Set.subset_eval_image_piₓ'. -/
 theorem subset_eval_image_pi (ht : (s.pi t).Nonempty) (i : ι) : t i ⊆ eval i '' s.pi t := by
   classical
     obtain ⟨f, hf⟩ := ht
@@ -1542,22 +960,10 @@ theorem subset_eval_image_pi (ht : (s.pi t).Nonempty) (i : ι) : t i ⊆ eval i
     obtain rfl | hji := eq_or_ne j i <;> simp [*, hf _ hj]
 #align set.subset_eval_image_pi Set.subset_eval_image_pi
 
-/- warning: set.eval_image_pi -> Set.eval_image_pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {s : Set.{u1} ι} {t : forall (i : ι), Set.{u2} (α i)} {i : ι}, (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (Set.Nonempty.{max u1 u2} (forall (i : ι), α i) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t)) -> (Eq.{succ u2} (Set.{u2} (α i)) (Set.image.{max u1 u2, u2} (forall (x : ι), α x) (α i) (Function.eval.{succ u1, succ u2} ι (fun (x : ι) => α x) i) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t)) (t i))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {s : Set.{u2} ι} {t : forall (i : ι), Set.{u1} (α i)} {i : ι}, (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) -> (Set.Nonempty.{max u2 u1} (forall (i : ι), α i) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t)) -> (Eq.{succ u1} (Set.{u1} (α i)) (Set.image.{max u2 u1, u1} (forall (x : ι), α x) (α i) (Function.eval.{succ u2, succ u1} ι (fun (x : ι) => α x) i) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t)) (t i))
-Case conversion may be inaccurate. Consider using '#align set.eval_image_pi Set.eval_image_piₓ'. -/
 theorem eval_image_pi (hs : i ∈ s) (ht : (s.pi t).Nonempty) : eval i '' s.pi t = t i :=
   (eval_image_pi_subset hs).antisymm (subset_eval_image_pi ht i)
 #align set.eval_image_pi Set.eval_image_pi
 
-/- warning: set.eval_image_univ_pi -> Set.eval_image_univ_pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {t : forall (i : ι), Set.{u2} (α i)} {i : ι}, (Set.Nonempty.{max u1 u2} (forall (i : ι), α i) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Set.univ.{u1} ι) t)) -> (Eq.{succ u2} (Set.{u2} (α i)) (Set.image.{max u1 u2, u2} (forall (i : ι), α i) (α i) (fun (f : forall (i : ι), α i) => f i) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Set.univ.{u1} ι) t)) (t i))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {t : forall (i : ι), Set.{u1} (α i)} {i : ι}, (Set.Nonempty.{max u2 u1} (forall (i : ι), α i) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (Set.univ.{u2} ι) t)) -> (Eq.{succ u1} (Set.{u1} (α i)) (Set.image.{max u2 u1, u1} (forall (i : ι), α i) (α i) (fun (f : forall (i : ι), α i) => f i) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (Set.univ.{u2} ι) t)) (t i))
-Case conversion may be inaccurate. Consider using '#align set.eval_image_univ_pi Set.eval_image_univ_piₓ'. -/
 @[simp]
 theorem eval_image_univ_pi (ht : (pi univ t).Nonempty) :
     (fun f : ∀ i, α i => f i) '' pi univ t = t i :=
@@ -1582,33 +988,15 @@ theorem univ_pi_subset_univ_pi_iff : pi univ t₁ ⊆ pi univ t₂ ↔ (∀ i, t
 #align set.univ_pi_subset_univ_pi_iff Set.univ_pi_subset_univ_pi_iff
 -/
 
-/- warning: set.eval_preimage -> Set.eval_preimage is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {i : ι} [_inst_1 : DecidableEq.{succ u1} ι] {s : Set.{u2} (α i)}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (x : ι), α x)) (Set.preimage.{max u1 u2, u2} (forall (x : ι), α x) (α i) (Function.eval.{succ u1, succ u2} ι (fun {i : ι} => α i) i) s) (Set.pi.{u1, u2} ι (fun (x : ι) => α x) (Set.univ.{u1} ι) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => Set.{u2} (α i)) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => Set.univ.{u2} (α i)) i s))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {i : ι} [_inst_1 : DecidableEq.{succ u2} ι] {s : Set.{u1} (α i)}, Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (x : ι), α x)) (Set.preimage.{max u2 u1, u1} (forall (x : ι), α x) (α i) (Function.eval.{succ u2, succ u1} ι α i) s) (Set.pi.{u2, u1} ι α (Set.univ.{u2} ι) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => Set.{u1} (α i)) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => Set.univ.{u1} (α i)) i s))
-Case conversion may be inaccurate. Consider using '#align set.eval_preimage Set.eval_preimageₓ'. -/
 theorem eval_preimage [DecidableEq ι] {s : Set (α i)} :
     eval i ⁻¹' s = pi univ (update (fun i => univ) i s) := by ext x;
   simp [@forall_update_iff _ (fun i => Set (α i)) _ _ _ _ fun i' y => x i' ∈ y]
 #align set.eval_preimage Set.eval_preimage
 
-/- warning: set.eval_preimage' -> Set.eval_preimage' is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {i : ι} [_inst_1 : DecidableEq.{succ u1} ι] {s : Set.{u2} (α i)}, Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (x : ι), α x)) (Set.preimage.{max u1 u2, u2} (forall (x : ι), α x) (α i) (Function.eval.{succ u1, succ u2} ι (fun {i : ι} => α i) i) s) (Set.pi.{u1, u2} ι (fun (x : ι) => α x) (Singleton.singleton.{u1, u1} ι (Set.{u1} ι) (Set.hasSingleton.{u1} ι) i) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => Set.{u2} (α i)) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => Set.univ.{u2} (α i)) i s))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {i : ι} [_inst_1 : DecidableEq.{succ u2} ι] {s : Set.{u1} (α i)}, Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (x : ι), α x)) (Set.preimage.{max u2 u1, u1} (forall (x : ι), α x) (α i) (Function.eval.{succ u2, succ u1} ι α i) s) (Set.pi.{u2, u1} ι α (Singleton.singleton.{u2, u2} ι (Set.{u2} ι) (Set.instSingletonSet.{u2} ι) i) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => Set.{u1} (α i)) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => Set.univ.{u1} (α i)) i s))
-Case conversion may be inaccurate. Consider using '#align set.eval_preimage' Set.eval_preimage'ₓ'. -/
 theorem eval_preimage' [DecidableEq ι] {s : Set (α i)} :
     eval i ⁻¹' s = pi {i} (update (fun i => univ) i s) := by ext; simp
 #align set.eval_preimage' Set.eval_preimage'
 
-/- warning: set.update_preimage_pi -> Set.update_preimage_pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {s : Set.{u1} ι} {t : forall (i : ι), Set.{u2} (α i)} {i : ι} [_inst_1 : DecidableEq.{succ u1} ι] {f : forall (i : ι), α i}, (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) -> (forall (j : ι), (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) j s) -> (Ne.{succ u1} ι j i) -> (Membership.Mem.{u2, u2} (α j) (Set.{u2} (α j)) (Set.hasMem.{u2} (α j)) (f j) (t j))) -> (Eq.{succ u2} (Set.{u2} (α i)) (Set.preimage.{u2, max u1 u2} (α i) (forall (a : ι), α a) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) f i) (Set.pi.{u1, u2} ι (fun (a : ι) => α a) s t)) (t i))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {s : Set.{u2} ι} {t : forall (i : ι), Set.{u1} (α i)} {i : ι} [_inst_1 : DecidableEq.{succ u2} ι] {f : forall (i : ι), α i}, (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) -> (forall (j : ι), (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) j s) -> (Ne.{succ u2} ι j i) -> (Membership.mem.{u1, u1} (α j) (Set.{u1} (α j)) (Set.instMembershipSet.{u1} (α j)) (f j) (t j))) -> (Eq.{succ u1} (Set.{u1} (α i)) (Set.preimage.{u1, max u2 u1} (α i) (forall (a : ι), α a) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) f i) (Set.pi.{u2, u1} ι (fun (a : ι) => α a) s t)) (t i))
-Case conversion may be inaccurate. Consider using '#align set.update_preimage_pi Set.update_preimage_piₓ'. -/
 theorem update_preimage_pi [DecidableEq ι] {f : ∀ i, α i} (hi : i ∈ s)
     (hf : ∀ j ∈ s, j ≠ i → f j ∈ t j) : update f i ⁻¹' s.pi t = t i :=
   by
@@ -1622,34 +1010,16 @@ theorem update_preimage_pi [DecidableEq ι] {f : ∀ i, α i} (hi : i ∈ s)
       exact hf j hj h
 #align set.update_preimage_pi Set.update_preimage_pi
 
-/- warning: set.update_preimage_univ_pi -> Set.update_preimage_univ_pi is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} {t : forall (i : ι), Set.{u2} (α i)} {i : ι} [_inst_1 : DecidableEq.{succ u1} ι] {f : forall (i : ι), α i}, (forall (j : ι), (Ne.{succ u1} ι j i) -> (Membership.Mem.{u2, u2} (α j) (Set.{u2} (α j)) (Set.hasMem.{u2} (α j)) (f j) (t j))) -> (Eq.{succ u2} (Set.{u2} (α i)) (Set.preimage.{u2, max u1 u2} (α i) (forall (a : ι), α a) (Function.update.{succ u1, succ u2} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) f i) (Set.pi.{u1, u2} ι (fun (a : ι) => α a) (Set.univ.{u1} ι) t)) (t i))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {t : forall (i : ι), Set.{u1} (α i)} {i : ι} [_inst_1 : DecidableEq.{succ u2} ι] {f : forall (i : ι), α i}, (forall (j : ι), (Ne.{succ u2} ι j i) -> (Membership.mem.{u1, u1} (α j) (Set.{u1} (α j)) (Set.instMembershipSet.{u1} (α j)) (f j) (t j))) -> (Eq.{succ u1} (Set.{u1} (α i)) (Set.preimage.{u1, max u2 u1} (α i) (forall (a : ι), α a) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) f i) (Set.pi.{u2, u1} ι (fun (a : ι) => α a) (Set.univ.{u2} ι) t)) (t i))
-Case conversion may be inaccurate. Consider using '#align set.update_preimage_univ_pi Set.update_preimage_univ_piₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (j «expr ≠ » i) -/
 theorem update_preimage_univ_pi [DecidableEq ι] {f : ∀ i, α i} (hf : ∀ (j) (_ : j ≠ i), f j ∈ t j) :
     update f i ⁻¹' pi univ t = t i :=
   update_preimage_pi (mem_univ i) fun j _ => hf j
 #align set.update_preimage_univ_pi Set.update_preimage_univ_pi
 
-/- warning: set.subset_pi_eval_image -> Set.subset_pi_eval_image is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} (s : Set.{u1} ι) (u : Set.{max u1 u2} (forall (i : ι), α i)), HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.hasSubset.{max u1 u2} (forall (i : ι), α i)) u (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s (fun (i : ι) => Set.image.{max u1 u2, u2} (forall (x : ι), α x) (α i) (Function.eval.{succ u1, succ u2} ι α i) u))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} (s : Set.{u2} ι) (u : Set.{max u2 u1} (forall (i : ι), α i)), HasSubset.Subset.{max u2 u1} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.instHasSubsetSet.{max u2 u1} (forall (i : ι), α i)) u (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s (fun (i : ι) => Set.image.{max u2 u1, u1} (forall (x : ι), α x) (α i) (Function.eval.{succ u2, succ u1} ι α i) u))
-Case conversion may be inaccurate. Consider using '#align set.subset_pi_eval_image Set.subset_pi_eval_imageₓ'. -/
 theorem subset_pi_eval_image (s : Set ι) (u : Set (∀ i, α i)) : u ⊆ pi s fun i => eval i '' u :=
   fun f hf i hi => ⟨f, hf, rfl⟩
 #align set.subset_pi_eval_image Set.subset_pi_eval_image
 
-/- warning: set.univ_pi_ite -> Set.univ_pi_ite is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} (s : Set.{u1} ι) [_inst_1 : DecidablePred.{succ u1} ι (fun (_x : ι) => Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) _x s)] (t : forall (i : ι), Set.{u2} (α i)), Eq.{succ (max u1 u2)} (Set.{max u1 u2} (forall (i : ι), α i)) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) (Set.univ.{u1} ι) (fun (i : ι) => ite.{succ u2} (Set.{u2} (α i)) (Membership.Mem.{u1, u1} ι (Set.{u1} ι) (Set.hasMem.{u1} ι) i s) (_inst_1 i) (t i) (Set.univ.{u2} (α i)))) (Set.pi.{u1, u2} ι (fun (i : ι) => α i) s t)
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} (s : Set.{u2} ι) [_inst_1 : DecidablePred.{succ u2} ι (fun (_x : ι) => Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) _x s)] (t : forall (i : ι), Set.{u1} (α i)), Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (Set.univ.{u2} ι) (fun (i : ι) => ite.{succ u1} (Set.{u1} (α i)) (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (_inst_1 i) (t i) (Set.univ.{u1} (α i)))) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t)
-Case conversion may be inaccurate. Consider using '#align set.univ_pi_ite Set.univ_pi_iteₓ'. -/
 theorem univ_pi_ite (s : Set ι) [DecidablePred (· ∈ s)] (t : ∀ i, Set (α i)) :
     (pi univ fun i => if i ∈ s then t i else univ) = s.pi t := by ext; simp_rw [mem_univ_pi];
   refine' forall_congr' fun i => _; split_ifs <;> simp [h]

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -203,9 +203,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.prod_empty Set.prod_emptyₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
-theorem prod_empty : s ×ˢ (∅ : Set β) = ∅ := by
-  ext
-  exact and_false_iff _
+theorem prod_empty : s ×ˢ (∅ : Set β) = ∅ := by ext; exact and_false_iff _
 #align set.prod_empty Set.prod_empty
 
 /- warning: set.empty_prod -> Set.empty_prod is a dubious translation:
@@ -216,9 +214,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.empty_prod Set.empty_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
-theorem empty_prod : (∅ : Set α) ×ˢ t = ∅ := by
-  ext
-  exact false_and_iff _
+theorem empty_prod : (∅ : Set α) ×ˢ t = ∅ := by ext; exact false_and_iff _
 #align set.empty_prod Set.empty_prod
 
 /- warning: set.univ_prod_univ -> Set.univ_prod_univ is a dubious translation:
@@ -229,10 +225,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.univ_prod_univ Set.univ_prod_univₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
-theorem univ_prod_univ : @univ α ×ˢ @univ β = univ :=
-  by
-  ext
-  exact true_and_iff _
+theorem univ_prod_univ : @univ α ×ˢ @univ β = univ := by ext; exact true_and_iff _
 #align set.univ_prod_univ Set.univ_prod_univ
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
@@ -259,9 +252,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.singleton_prod Set.singleton_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
-theorem singleton_prod : ({a} : Set α) ×ˢ t = Prod.mk a '' t :=
-  by
-  ext ⟨x, y⟩
+theorem singleton_prod : ({a} : Set α) ×ˢ t = Prod.mk a '' t := by ext ⟨x, y⟩;
   simp [and_left_comm, eq_comm]
 #align set.singleton_prod Set.singleton_prod
 
@@ -273,9 +264,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.prod_singleton Set.prod_singletonₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
-theorem prod_singleton : s ×ˢ ({b} : Set β) = (fun a => (a, b)) '' s :=
-  by
-  ext ⟨x, y⟩
+theorem prod_singleton : s ×ˢ ({b} : Set β) = (fun a => (a, b)) '' s := by ext ⟨x, y⟩;
   simp [and_left_comm, eq_comm]
 #align set.prod_singleton Set.prod_singleton
 
@@ -299,10 +288,7 @@ Case conversion may be inaccurate. Consider using '#align set.union_prod Set.uni
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
-theorem union_prod : (s₁ ∪ s₂) ×ˢ t = s₁ ×ˢ t ∪ s₂ ×ˢ t :=
-  by
-  ext ⟨x, y⟩
-  simp [or_and_right]
+theorem union_prod : (s₁ ∪ s₂) ×ˢ t = s₁ ×ˢ t ∪ s₂ ×ˢ t := by ext ⟨x, y⟩; simp [or_and_right]
 #align set.union_prod Set.union_prod
 
 /- warning: set.prod_union -> Set.prod_union is a dubious translation:
@@ -315,10 +301,7 @@ Case conversion may be inaccurate. Consider using '#align set.prod_union Set.pro
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
-theorem prod_union : s ×ˢ (t₁ ∪ t₂) = s ×ˢ t₁ ∪ s ×ˢ t₂ :=
-  by
-  ext ⟨x, y⟩
-  simp [and_or_left]
+theorem prod_union : s ×ˢ (t₁ ∪ t₂) = s ×ˢ t₁ ∪ s ×ˢ t₂ := by ext ⟨x, y⟩; simp [and_or_left]
 #align set.prod_union Set.prod_union
 
 /- warning: set.inter_prod -> Set.inter_prod is a dubious translation:
@@ -330,9 +313,7 @@ Case conversion may be inaccurate. Consider using '#align set.inter_prod Set.int
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-theorem inter_prod : (s₁ ∩ s₂) ×ˢ t = s₁ ×ˢ t ∩ s₂ ×ˢ t :=
-  by
-  ext ⟨x, y⟩
+theorem inter_prod : (s₁ ∩ s₂) ×ˢ t = s₁ ×ˢ t ∩ s₂ ×ˢ t := by ext ⟨x, y⟩;
   simp only [← and_and_right, mem_inter_iff, mem_prod]
 #align set.inter_prod Set.inter_prod
 
@@ -345,9 +326,7 @@ Case conversion may be inaccurate. Consider using '#align set.prod_inter Set.pro
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-theorem prod_inter : s ×ˢ (t₁ ∩ t₂) = s ×ˢ t₁ ∩ s ×ˢ t₂ :=
-  by
-  ext ⟨x, y⟩
+theorem prod_inter : s ×ˢ (t₁ ∩ t₂) = s ×ˢ t₁ ∩ s ×ˢ t₂ := by ext ⟨x, y⟩;
   simp only [← and_and_left, mem_inter_iff, mem_prod]
 #align set.prod_inter Set.prod_inter
 
@@ -360,9 +339,7 @@ Case conversion may be inaccurate. Consider using '#align set.prod_inter_prod Se
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-theorem prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂) :=
-  by
-  ext ⟨x, y⟩
+theorem prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂) := by ext ⟨x, y⟩;
   simp [and_assoc', and_left_comm]
 #align set.prod_inter_prod Set.prod_inter_prod
 
@@ -387,9 +364,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.insert_prod Set.insert_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-theorem insert_prod : insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t :=
-  by
-  ext ⟨x, y⟩
+theorem insert_prod : insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t := by ext ⟨x, y⟩;
   simp (config := { contextual := true }) [image, iff_def, or_imp, Imp.swap]
 #align set.insert_prod Set.insert_prod
 
@@ -401,9 +376,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.prod_insert Set.prod_insertₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-theorem prod_insert : s ×ˢ insert b t = (fun a => (a, b)) '' s ∪ s ×ˢ t :=
-  by
-  ext ⟨x, y⟩
+theorem prod_insert : s ×ˢ insert b t = (fun a => (a, b)) '' s ∪ s ×ˢ t := by ext ⟨x, y⟩;
   simp (config := { contextual := true }) [image, iff_def, or_imp, Imp.swap]
 #align set.prod_insert Set.prod_insert
 
@@ -474,10 +447,7 @@ theorem mk_preimage_prod (f : γ → α) (g : γ → β) :
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.mk_preimage_prod_left /-
 @[simp]
-theorem mk_preimage_prod_left (hb : b ∈ t) : (fun a => (a, b)) ⁻¹' s ×ˢ t = s :=
-  by
-  ext a
-  simp [hb]
+theorem mk_preimage_prod_left (hb : b ∈ t) : (fun a => (a, b)) ⁻¹' s ×ˢ t = s := by ext a; simp [hb]
 #align set.mk_preimage_prod_left Set.mk_preimage_prod_left
 -/
 
@@ -489,18 +459,13 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.mk_preimage_prod_right Set.mk_preimage_prod_rightₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
-theorem mk_preimage_prod_right (ha : a ∈ s) : Prod.mk a ⁻¹' s ×ˢ t = t :=
-  by
-  ext b
-  simp [ha]
+theorem mk_preimage_prod_right (ha : a ∈ s) : Prod.mk a ⁻¹' s ×ˢ t = t := by ext b; simp [ha]
 #align set.mk_preimage_prod_right Set.mk_preimage_prod_right
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.mk_preimage_prod_left_eq_empty /-
 @[simp]
-theorem mk_preimage_prod_left_eq_empty (hb : b ∉ t) : (fun a => (a, b)) ⁻¹' s ×ˢ t = ∅ :=
-  by
-  ext a
+theorem mk_preimage_prod_left_eq_empty (hb : b ∉ t) : (fun a => (a, b)) ⁻¹' s ×ˢ t = ∅ := by ext a;
   simp [hb]
 #align set.mk_preimage_prod_left_eq_empty Set.mk_preimage_prod_left_eq_empty
 -/
@@ -513,9 +478,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.mk_preimage_prod_right_eq_empty Set.mk_preimage_prod_right_eq_emptyₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
-theorem mk_preimage_prod_right_eq_empty (ha : a ∉ s) : Prod.mk a ⁻¹' s ×ˢ t = ∅ :=
-  by
-  ext b
+theorem mk_preimage_prod_right_eq_empty (ha : a ∉ s) : Prod.mk a ⁻¹' s ×ˢ t = ∅ := by ext b;
   simp [ha]
 #align set.mk_preimage_prod_right_eq_empty Set.mk_preimage_prod_right_eq_empty
 
@@ -570,9 +533,7 @@ Case conversion may be inaccurate. Consider using '#align set.preimage_swap_prod
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 @[simp]
-theorem preimage_swap_prod (s : Set α) (t : Set β) : Prod.swap ⁻¹' s ×ˢ t = t ×ˢ s :=
-  by
-  ext ⟨x, y⟩
+theorem preimage_swap_prod (s : Set α) (t : Set β) : Prod.swap ⁻¹' s ×ˢ t = t ×ˢ s := by ext ⟨x, y⟩;
   simp [and_comm']
 #align set.preimage_swap_prod Set.preimage_swap_prod
 
@@ -734,18 +695,14 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.image_prod_mk_subset_prod Set.image_prod_mk_subset_prodₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 theorem image_prod_mk_subset_prod {f : α → β} {g : α → γ} {s : Set α} :
-    (fun x => (f x, g x)) '' s ⊆ (f '' s) ×ˢ (g '' s) :=
-  by
-  rintro _ ⟨x, hx, rfl⟩
+    (fun x => (f x, g x)) '' s ⊆ (f '' s) ×ˢ (g '' s) := by rintro _ ⟨x, hx, rfl⟩;
   exact mk_mem_prod (mem_image_of_mem f hx) (mem_image_of_mem g hx)
 #align set.image_prod_mk_subset_prod Set.image_prod_mk_subset_prod
 
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 #print Set.image_prod_mk_subset_prod_left /-
-theorem image_prod_mk_subset_prod_left (hb : b ∈ t) : (fun a => (a, b)) '' s ⊆ s ×ˢ t :=
-  by
-  rintro _ ⟨a, ha, rfl⟩
-  exact ⟨ha, hb⟩
+theorem image_prod_mk_subset_prod_left (hb : b ∈ t) : (fun a => (a, b)) '' s ⊆ s ×ˢ t := by
+  rintro _ ⟨a, ha, rfl⟩; exact ⟨ha, hb⟩
 #align set.image_prod_mk_subset_prod_left Set.image_prod_mk_subset_prod_left
 -/
 
@@ -756,10 +713,8 @@ but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} {s : Set.{u2} α} {t : Set.{u1} β} {a : α}, (Membership.mem.{u2, u2} α (Set.{u2} α) (Set.instMembershipSet.{u2} α) a s) -> (HasSubset.Subset.{max u1 u2} (Set.{max u1 u2} (Prod.{u2, u1} α β)) (Set.instHasSubsetSet.{max u2 u1} (Prod.{u2, u1} α β)) (Set.image.{u1, max u1 u2} β (Prod.{u2, u1} α β) (Prod.mk.{u2, u1} α β a) t) (Set.prod.{u2, u1} α β s t))
 Case conversion may be inaccurate. Consider using '#align set.image_prod_mk_subset_prod_right Set.image_prod_mk_subset_prod_rightₓ'. -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-theorem image_prod_mk_subset_prod_right (ha : a ∈ s) : Prod.mk a '' t ⊆ s ×ˢ t :=
-  by
-  rintro _ ⟨b, hb, rfl⟩
-  exact ⟨ha, hb⟩
+theorem image_prod_mk_subset_prod_right (ha : a ∈ s) : Prod.mk a '' t ⊆ s ×ˢ t := by
+  rintro _ ⟨b, hb, rfl⟩; exact ⟨ha, hb⟩
 #align set.image_prod_mk_subset_prod_right Set.image_prod_mk_subset_prod_right
 
 /- warning: set.prod_subset_preimage_fst -> Set.prod_subset_preimage_fst is a dubious translation:
@@ -838,9 +793,7 @@ Case conversion may be inaccurate. Consider using '#align set.prod_diff_prod Set
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
 /- ./././Mathport/Syntax/Translate/Expr.lean:177:8: unsupported: ambiguous notation -/
-theorem prod_diff_prod : s ×ˢ t \ s₁ ×ˢ t₁ = s ×ˢ (t \ t₁) ∪ (s \ s₁) ×ˢ t :=
-  by
-  ext x
+theorem prod_diff_prod : s ×ˢ t \ s₁ ×ˢ t₁ = s ×ˢ (t \ t₁) ∪ (s \ s₁) ×ˢ t := by ext x;
   by_cases h₁ : x.1 ∈ s₁ <;> by_cases h₂ : x.2 ∈ t₁ <;> simp [*]
 #align set.prod_diff_prod Set.prod_diff_prod
 
@@ -884,8 +837,7 @@ theorem prod_eq_prod_iff_of_nonempty (h : (s ×ˢ t).Nonempty) :
     rw [prod_nonempty_iff] at h h₁
     rw [← fst_image_prod s h.2, ← fst_image_prod s₁ h₁.2, HEq, eq_self_iff_true, true_and_iff, ←
       snd_image_prod h.1 t, ← snd_image_prod h₁.1 t₁, HEq]
-  · rintro ⟨rfl, rfl⟩
-    rfl
+  · rintro ⟨rfl, rfl⟩; rfl
 #align set.prod_eq_prod_iff_of_nonempty Set.prod_eq_prod_iff_of_nonempty
 
 /- warning: set.prod_eq_prod_iff -> Set.prod_eq_prod_iff is a dubious translation:
@@ -904,8 +856,7 @@ theorem prod_eq_prod_iff :
   cases' eq_empty_or_nonempty (s ×ˢ t) with h h
   · simp_rw [h, @eq_comm _ ∅, prod_eq_empty_iff, prod_eq_empty_iff.mp h, true_and_iff,
       or_iff_right_iff_imp]
-    rintro ⟨rfl, rfl⟩
-    exact prod_eq_empty_iff.mp h
+    rintro ⟨rfl, rfl⟩; exact prod_eq_empty_iff.mp h
   rw [prod_eq_prod_iff_of_nonempty h]
   rw [nonempty_iff_ne_empty, Ne.def, prod_eq_empty_iff] at h
   simp_rw [h, false_and_iff, or_false_iff]
@@ -1019,19 +970,14 @@ instance decidableMemDiagonal [h : DecidableEq α] (x : α × α) : Decidable (x
 -/
 
 #print Set.preimage_coe_coe_diagonal /-
-theorem preimage_coe_coe_diagonal (s : Set α) : Prod.map coe coe ⁻¹' diagonal α = diagonal s :=
-  by
-  ext ⟨⟨x, hx⟩, ⟨y, hy⟩⟩
-  simp [Set.diagonal]
+theorem preimage_coe_coe_diagonal (s : Set α) : Prod.map coe coe ⁻¹' diagonal α = diagonal s := by
+  ext ⟨⟨x, hx⟩, ⟨y, hy⟩⟩; simp [Set.diagonal]
 #align set.preimage_coe_coe_diagonal Set.preimage_coe_coe_diagonal
 -/
 
 #print Set.range_diag /-
 @[simp]
-theorem range_diag : (range fun x => (x, x)) = diagonal α :=
-  by
-  ext ⟨x, y⟩
-  simp [diagonal, eq_comm]
+theorem range_diag : (range fun x => (x, x)) = diagonal α := by ext ⟨x, y⟩; simp [diagonal, eq_comm]
 #align set.range_diag Set.range_diag
 -/
 
@@ -1082,8 +1028,7 @@ Case conversion may be inaccurate. Consider using '#align set.diag_image Set.dia
 theorem diag_image (s : Set α) : (fun x => (x, x)) '' s = diagonal α ∩ s ×ˢ s :=
   by
   ext x; constructor
-  · rintro ⟨x, hx, rfl⟩
-    exact ⟨rfl, hx, hx⟩
+  · rintro ⟨x, hx, rfl⟩; exact ⟨rfl, hx, hx⟩
   · obtain ⟨x, y⟩ := x
     rintro ⟨rfl : x = y, h2x⟩
     exact mem_image_of_mem _ h2x.1
@@ -1207,9 +1152,7 @@ but is expected to have type
   forall {α : Type.{u1}} (s : Set.{u1} α) (t : Set.{u1} α), Eq.{succ u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α (Inter.inter.{u1} (Set.{u1} α) (Set.instInterSet.{u1} α) s t)) (Inter.inter.{u1} (Set.{u1} (Prod.{u1, u1} α α)) (Set.instInterSet.{u1} (Prod.{u1, u1} α α)) (Set.offDiag.{u1} α s) (Set.offDiag.{u1} α t))
 Case conversion may be inaccurate. Consider using '#align set.off_diag_inter Set.offDiag_interₓ'. -/
 theorem offDiag_inter : (s ∩ t).offDiag = s.offDiag ∩ t.offDiag :=
-  ext fun x => by
-    simp only [mem_off_diag, mem_inter_iff]
-    tauto
+  ext fun x => by simp only [mem_off_diag, mem_inter_iff]; tauto
 #align set.off_diag_inter Set.offDiag_inter
 
 variable {s t}
@@ -1291,10 +1234,7 @@ theorem mem_univ_pi {f : ∀ i, α i} : f ∈ pi univ t ↔ ∀ i, f i ∈ t i :
 
 #print Set.empty_pi /-
 @[simp]
-theorem empty_pi (s : ∀ i, Set (α i)) : pi ∅ s = univ :=
-  by
-  ext
-  simp [pi]
+theorem empty_pi (s : ∀ i, Set (α i)) : pi ∅ s = univ := by ext; simp [pi]
 #align set.empty_pi Set.empty_pi
 -/
 
@@ -1346,8 +1286,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.pi_eq_empty Set.pi_eq_emptyₓ'. -/
 theorem pi_eq_empty (hs : i ∈ s) (ht : t i = ∅) : s.pi t = ∅ :=
   by
-  ext f
-  simp only [mem_empty_iff_false, not_forall, iff_false_iff, mem_pi, not_imp]
+  ext f; simp only [mem_empty_iff_false, not_forall, iff_false_iff, mem_pi, not_imp]
   exact ⟨i, hs, by simp [ht]⟩
 #align set.pi_eq_empty Set.pi_eq_empty
 
@@ -1449,18 +1388,12 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.insert_pi Set.insert_piₓ'. -/
 @[simp]
 theorem insert_pi (i : ι) (s : Set ι) (t : ∀ i, Set (α i)) :
-    pi (insert i s) t = eval i ⁻¹' t i ∩ pi s t :=
-  by
-  ext
-  simp [pi, or_imp, forall_and]
+    pi (insert i s) t = eval i ⁻¹' t i ∩ pi s t := by ext; simp [pi, or_imp, forall_and]
 #align set.insert_pi Set.insert_pi
 
 #print Set.singleton_pi /-
 @[simp]
-theorem singleton_pi (i : ι) (t : ∀ i, Set (α i)) : pi {i} t = eval i ⁻¹' t i :=
-  by
-  ext
-  simp [pi]
+theorem singleton_pi (i : ι) (t : ∀ i, Set (α i)) : pi {i} t = eval i ⁻¹' t i := by ext; simp [pi]
 #align set.singleton_pi Set.singleton_pi
 -/
 
@@ -1503,10 +1436,7 @@ theorem pi_if {p : ι → Prop} [h : DecidablePred p] (s : Set ι) (t₁ t₂ :
   by
   ext f
   refine' ⟨fun h => _, _⟩
-  ·
-    constructor <;>
-      · rintro i ⟨his, hpi⟩
-        simpa [*] using h i
+  · constructor <;> · rintro i ⟨his, hpi⟩; simpa [*] using h i
   · rintro ⟨ht₁, ht₂⟩ i his
     by_cases p i <;> simp_all
 #align set.pi_if Set.pi_if
@@ -1540,9 +1470,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.pi_update_of_not_mem Set.pi_update_of_not_memₓ'. -/
 theorem pi_update_of_not_mem [DecidableEq ι] (hi : i ∉ s) (f : ∀ j, α j) (a : α i)
     (t : ∀ j, α j → Set (β j)) : (s.pi fun j => t j (update f i a j)) = s.pi fun j => t j (f j) :=
-  pi_congr rfl fun j hj => by
-    rw [update_noteq]
-    exact fun h => hi (h ▸ hj)
+  pi_congr rfl fun j hj => by rw [update_noteq]; exact fun h => hi (h ▸ hj)
 #align set.pi_update_of_not_mem Set.pi_update_of_not_mem
 
 /- warning: set.pi_update_of_mem -> Set.pi_update_of_mem is a dubious translation:
@@ -1557,10 +1485,8 @@ theorem pi_update_of_mem [DecidableEq ι] (hi : i ∈ s) (f : ∀ j, α j) (a :
   calc
     (s.pi fun j => t j (update f i a j)) = ({i} ∪ s \ {i}).pi fun j => t j (update f i a j) := by
       rw [union_diff_self, union_eq_self_of_subset_left (singleton_subset_iff.2 hi)]
-    _ = { x | x i ∈ t i a } ∩ (s \ {i}).pi fun j => t j (f j) :=
-      by
-      rw [union_pi, singleton_pi', update_same, pi_update_of_not_mem]
-      simp
+    _ = { x | x i ∈ t i a } ∩ (s \ {i}).pi fun j => t j (f j) := by
+      rw [union_pi, singleton_pi', update_same, pi_update_of_not_mem]; simp
     
 #align set.pi_update_of_mem Set.pi_update_of_mem
 
@@ -1663,9 +1589,7 @@ but is expected to have type
   forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {i : ι} [_inst_1 : DecidableEq.{succ u2} ι] {s : Set.{u1} (α i)}, Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (x : ι), α x)) (Set.preimage.{max u2 u1, u1} (forall (x : ι), α x) (α i) (Function.eval.{succ u2, succ u1} ι α i) s) (Set.pi.{u2, u1} ι α (Set.univ.{u2} ι) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => Set.{u1} (α i)) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => Set.univ.{u1} (α i)) i s))
 Case conversion may be inaccurate. Consider using '#align set.eval_preimage Set.eval_preimageₓ'. -/
 theorem eval_preimage [DecidableEq ι] {s : Set (α i)} :
-    eval i ⁻¹' s = pi univ (update (fun i => univ) i s) :=
-  by
-  ext x
+    eval i ⁻¹' s = pi univ (update (fun i => univ) i s) := by ext x;
   simp [@forall_update_iff _ (fun i => Set (α i)) _ _ _ _ fun i' y => x i' ∈ y]
 #align set.eval_preimage Set.eval_preimage
 
@@ -1676,10 +1600,7 @@ but is expected to have type
   forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {i : ι} [_inst_1 : DecidableEq.{succ u2} ι] {s : Set.{u1} (α i)}, Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (x : ι), α x)) (Set.preimage.{max u2 u1, u1} (forall (x : ι), α x) (α i) (Function.eval.{succ u2, succ u1} ι α i) s) (Set.pi.{u2, u1} ι α (Singleton.singleton.{u2, u2} ι (Set.{u2} ι) (Set.instSingletonSet.{u2} ι) i) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => Set.{u1} (α i)) (fun (a : ι) (b : ι) => _inst_1 a b) (fun (i : ι) => Set.univ.{u1} (α i)) i s))
 Case conversion may be inaccurate. Consider using '#align set.eval_preimage' Set.eval_preimage'ₓ'. -/
 theorem eval_preimage' [DecidableEq ι] {s : Set (α i)} :
-    eval i ⁻¹' s = pi {i} (update (fun i => univ) i s) :=
-  by
-  ext
-  simp
+    eval i ⁻¹' s = pi {i} (update (fun i => univ) i s) := by ext; simp
 #align set.eval_preimage' Set.eval_preimage'
 
 /- warning: set.update_preimage_pi -> Set.update_preimage_pi is a dubious translation:
@@ -1730,12 +1651,8 @@ but is expected to have type
   forall {ι : Type.{u2}} {α : ι -> Type.{u1}} (s : Set.{u2} ι) [_inst_1 : DecidablePred.{succ u2} ι (fun (_x : ι) => Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) _x s)] (t : forall (i : ι), Set.{u1} (α i)), Eq.{max (succ u2) (succ u1)} (Set.{max u2 u1} (forall (i : ι), α i)) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) (Set.univ.{u2} ι) (fun (i : ι) => ite.{succ u1} (Set.{u1} (α i)) (Membership.mem.{u2, u2} ι (Set.{u2} ι) (Set.instMembershipSet.{u2} ι) i s) (_inst_1 i) (t i) (Set.univ.{u1} (α i)))) (Set.pi.{u2, u1} ι (fun (i : ι) => α i) s t)
 Case conversion may be inaccurate. Consider using '#align set.univ_pi_ite Set.univ_pi_iteₓ'. -/
 theorem univ_pi_ite (s : Set ι) [DecidablePred (· ∈ s)] (t : ∀ i, Set (α i)) :
-    (pi univ fun i => if i ∈ s then t i else univ) = s.pi t :=
-  by
-  ext
-  simp_rw [mem_univ_pi]
-  refine' forall_congr' fun i => _
-  split_ifs <;> simp [h]
+    (pi univ fun i => if i ∈ s then t i else univ) = s.pi t := by ext; simp_rw [mem_univ_pi];
+  refine' forall_congr' fun i => _; split_ifs <;> simp [h]
 #align set.univ_pi_ite Set.univ_pi_ite
 
 end Pi

bump to nightly-2023-03-01-20

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

20cadee0

Diff

@@ -1707,7 +1707,7 @@ lean 3 declaration is
 but is expected to have type
   forall {ι : Type.{u2}} {α : ι -> Type.{u1}} {t : forall (i : ι), Set.{u1} (α i)} {i : ι} [_inst_1 : DecidableEq.{succ u2} ι] {f : forall (i : ι), α i}, (forall (j : ι), (Ne.{succ u2} ι j i) -> (Membership.mem.{u1, u1} (α j) (Set.{u1} (α j)) (Set.instMembershipSet.{u1} (α j)) (f j) (t j))) -> (Eq.{succ u1} (Set.{u1} (α i)) (Set.preimage.{u1, max u2 u1} (α i) (forall (a : ι), α a) (Function.update.{succ u2, succ u1} ι (fun (i : ι) => α i) (fun (a : ι) (b : ι) => _inst_1 a b) f i) (Set.pi.{u2, u1} ι (fun (a : ι) => α a) (Set.univ.{u2} ι) t)) (t i))
 Case conversion may be inaccurate. Consider using '#align set.update_preimage_univ_pi Set.update_preimage_univ_piₓ'. -/
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (j «expr ≠ » i) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (j «expr ≠ » i) -/
 theorem update_preimage_univ_pi [DecidableEq ι] {f : ∀ i, α i} (hf : ∀ (j) (_ : j ≠ i), f j ∈ t j) :
     update f i ⁻¹' pi univ t = t i :=
   update_preimage_pi (mem_univ i) fun j _ => hf j

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore: superfluous parentheses (#12116)

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

596d5eca

Diff

@@ -682,7 +682,7 @@ theorem offDiag_union (h : Disjoint s t) :
   · rintro (((⟨h0, h1, h2⟩|⟨h0, h1, h2⟩)|⟨h0, h1⟩)|⟨h0, h1⟩) <;> simp [*]
     · rintro h3
       rw [h3] at h0
-      exact (Set.disjoint_left.mp h h0 h1)
+      exact Set.disjoint_left.mp h h0 h1
     · rintro h3
       rw [h3] at h0
       exact (Set.disjoint_right.mp h h0 h1).elim

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

1b40c7bc

Diff

@@ -414,7 +414,7 @@ theorem prod_eq_prod_iff :
     rintro ⟨rfl, rfl⟩
     exact prod_eq_empty_iff.mp h
   rw [prod_eq_prod_iff_of_nonempty h]
-  rw [nonempty_iff_ne_empty, Ne.def, prod_eq_empty_iff] at h
+  rw [nonempty_iff_ne_empty, Ne, prod_eq_empty_iff] at h
   simp_rw [h, false_and_iff, or_false_iff]
 #align set.prod_eq_prod_iff Set.prod_eq_prod_iff
 
@@ -928,7 +928,7 @@ theorem eval_image_univ_pi (ht : (pi univ t).Nonempty) :
 theorem pi_subset_pi_iff : pi s t₁ ⊆ pi s t₂ ↔ (∀ i ∈ s, t₁ i ⊆ t₂ i) ∨ pi s t₁ = ∅ := by
   refine'
     ⟨fun h => or_iff_not_imp_right.2 _, fun h => h.elim pi_mono fun h' => h'.symm ▸ empty_subset _⟩
-  rw [← Ne.def, ← nonempty_iff_ne_empty]
+  rw [← Ne, ← nonempty_iff_ne_empty]
   intro hne i hi
   simpa only [eval_image_pi hi hne, eval_image_pi hi (hne.mono h)] using
     image_subset (fun f : ∀ i, α i => f i) h

feat: better polishSpace_of_complete_second_countable (#10890)

Make it work for a UniformSpace with extra properties.
Use it to golf some instances.

Co-authored-by: @ADedecker

00106234

Diff

@@ -518,6 +518,14 @@ theorem diagonal_eq_univ [Subsingleton α] : diagonal α = univ := diagonal_eq_u
 
 end Diagonal
 
+/-- A function is `Function.const α a` for some `a` if and only if `∀ x y, f x = f y`. -/
+theorem range_const_eq_diagonal {α β : Type*} [hβ : Nonempty β] :
+    range (const α) = {f : α → β | ∀ x y, f x = f y} := by
+  refine (range_eq_iff _ _).mpr ⟨fun _ _ _ ↦ rfl, fun f hf ↦ ?_⟩
+  rcases isEmpty_or_nonempty α with h|⟨⟨a⟩⟩
+  · exact hβ.elim fun b ↦ ⟨b, Subsingleton.elim _ _⟩
+  · exact ⟨f a, funext fun x ↦ hf _ _⟩
+
 end Set
 
 section Pullback

feat(UniformSpace): add Unique instance (#10774)

There is only one UniformSpace structure on a Subsingleton.

00df8d1b

Diff

@@ -511,6 +511,11 @@ theorem diag_image (s : Set α) : (fun x => (x, x)) '' s = diagonal α ∩ s ×
     exact mem_image_of_mem _ h2x.1
 #align set.diag_image Set.diag_image
 
+theorem diagonal_eq_univ_iff : diagonal α = univ ↔ Subsingleton α := by
+  simp only [subsingleton_iff, eq_univ_iff_forall, Prod.forall, mem_diagonal_iff]
+
+theorem diagonal_eq_univ [Subsingleton α] : diagonal α = univ := diagonal_eq_univ_iff.2 ‹_›
+
 end Diagonal
 
 end Set

chore: classify was simp porting notes (#10746)

Classifies by adding issue number (#10745) to porting notes claiming was simp.

71e045ac

Diff

@@ -181,7 +181,8 @@ theorem insert_prod : insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t := by
 
 theorem prod_insert : s ×ˢ insert b t = (fun a => (a, b)) '' s ∪ s ×ˢ t := by
   ext ⟨x, y⟩
-  -- Porting note: was `simp (config := { contextual := true }) [image, iff_def, or_imp, Imp.swap]`
+  -- porting note (#10745):
+  -- was `simp (config := { contextual := true }) [image, iff_def, or_imp, Imp.swap]`
   simp only [mem_prod, mem_insert_iff, image, mem_union, mem_setOf_eq, Prod.mk.injEq]
   refine ⟨fun h => ?_, fun h => ?_⟩
   · obtain ⟨hx, rfl|hy⟩ := h

feat(Algebra/InfiniteSum): drop [T2Space _] assumption (#10060)

Add CanLift instance for Function.Embedding.
Assume Injective i instead of an equivalent condition in hasSum_iff_hasSum_of_ne_zero_bij.
Add tsum_eq_sum', a version of tsum_eq_sum that explicitly mentions support f.
Add Function.Injective.tsum_eq, use it to drop [T2Space _] assumption in
- Equiv.tsum_eq;
- tsum_subtype_eq_of_support_subset;
- tsum_subtype_support;
- tsum_subtype;
- tsum_univ;
- tsum_image;
- tsum_range;
- tsum_setElem_eq_tsum_setElem_diff;
- tsum_eq_tsum_diff_singleton;
- tsum_eq_tsum_of_ne_zero_bij;
- Equiv.tsum_eq_tsum_of_support;
- tsum_extend_zero;
Golf some proofs.
Drop Equiv.Set.prod_singleton_left and Equiv.Set.prod_singleton_right added in #10038. @MichaelStollBayreuth, if you need these Equivs, then please
- restore them in Logic/Equiv/Set, not in Data/Set/Prod;
- call them Equiv.Set.singletonProd and Equiv.Set.prodSingleton, following the lowerCamelCase naming convention for defs;
- reuse the existing Equiv.Set.prod and Equiv.prodUnique/Equiv.uniqueProd in the definitions.

1fa9ebf0

Diff

@@ -1002,21 +1002,3 @@ theorem sumPiEquivProdPi_symm_preimage_univ_pi (π : ι ⊕ ι' → Type*) (t :
   · rintro ⟨h₁, h₂⟩ (i|i) <;> simp <;> apply_assumption
 
 end Equiv
-
-namespace Equiv.Set
-
-/-- The canonical equivalence between `{a} ×ˢ t` and `t`, considered as types. -/
-def prod_singleton_left {α β : Type*} (a : α) (t : Set β) : ↑({a} ×ˢ t) ≃ ↑t where
-  toFun := fun x ↦ ⟨x.val.snd, (Set.mem_prod.mp x.prop).2⟩
-  invFun := fun b ↦ ⟨(a, b.val), Set.mem_prod.mpr ⟨Set.mem_singleton a, Subtype.mem b⟩⟩
-  left_inv := by simp [Function.LeftInverse]
-  right_inv := by simp [Function.RightInverse, Function.LeftInverse]
-
-/-- The canonical equivalence between `s ×ˢ {b}` and `s`, considered as types. -/
-def prod_singleton_right {α β : Type*} (s : Set α) (b : β) : ↑(s ×ˢ {b}) ≃ ↑s where
-  toFun := fun x ↦ ⟨x.val.fst, (Set.mem_prod.mp x.prop).1⟩
-  invFun := fun a ↦ ⟨(a.val, b), Set.mem_prod.mpr ⟨Subtype.mem a, Set.mem_singleton b⟩⟩
-  left_inv := by simp [Function.LeftInverse]
-  right_inv := by simp [Function.RightInverse, Function.LeftInverse]
-
-end Equiv.Set

feat(Topology/Algebra/InfiniteSum/Basic): add some lemmas on tsums (#10038)

This is the fifth PR in a sequence that adds auxiliary lemmas from the EulerProducts project to Mathlib.

It adds three lemmas on tsums:

lemma HasSum.tsum_fiberwise {α β γ : Type*} [AddCommGroup α] [UniformSpace α] [UniformAddGroup α]
    [T2Space α] [RegularSpace α] [CompleteSpace α] {f : β → α}
    {a : α} (hf : HasSum f a) (g : β → γ) :
    HasSum (fun c : γ ↦ ∑' b : g ⁻¹' {c}, f b) a

lemma tsum_setProd_singleton_left {α β γ : Type*} [AddCommMonoid γ] [TopologicalSpace γ] [T2Space γ]
    (a : α) (t : Set β) (f : α × β → γ) : (∑' x : {a} ×ˢ t, f x) = ∑' b : t, f (a, b)

lemma tsum_setProd_singleton_right {α β γ : Type*} [AddCommMonoid γ] [TopologicalSpace γ] [T2Space γ]
    (s : Set α) (b : β) (f : α × β → γ) : (∑' x : s ×ˢ {b}, f x) = ∑' a : s, f (a, b)

and the necessary equivalences

def prod_singleton_left {α β : Type*} (a : α) (t : Set β) : ↑({a} ×ˢ t) ≃ ↑t

def prod_singleton_right {α β : Type*} (s : Set α) (b : β) : ↑(s ×ˢ {b}) ≃ ↑s

e4e10f95

Diff

@@ -1002,3 +1002,21 @@ theorem sumPiEquivProdPi_symm_preimage_univ_pi (π : ι ⊕ ι' → Type*) (t :
   · rintro ⟨h₁, h₂⟩ (i|i) <;> simp <;> apply_assumption
 
 end Equiv
+
+namespace Equiv.Set
+
+/-- The canonical equivalence between `{a} ×ˢ t` and `t`, considered as types. -/
+def prod_singleton_left {α β : Type*} (a : α) (t : Set β) : ↑({a} ×ˢ t) ≃ ↑t where
+  toFun := fun x ↦ ⟨x.val.snd, (Set.mem_prod.mp x.prop).2⟩
+  invFun := fun b ↦ ⟨(a, b.val), Set.mem_prod.mpr ⟨Set.mem_singleton a, Subtype.mem b⟩⟩
+  left_inv := by simp [Function.LeftInverse]
+  right_inv := by simp [Function.RightInverse, Function.LeftInverse]
+
+/-- The canonical equivalence between `s ×ˢ {b}` and `s`, considered as types. -/
+def prod_singleton_right {α β : Type*} (s : Set α) (b : β) : ↑(s ×ˢ {b}) ≃ ↑s where
+  toFun := fun x ↦ ⟨x.val.fst, (Set.mem_prod.mp x.prop).1⟩
+  invFun := fun a ↦ ⟨(a.val, b), Set.mem_prod.mpr ⟨Subtype.mem a, Set.mem_singleton b⟩⟩
+  left_inv := by simp [Function.LeftInverse]
+  right_inv := by simp [Function.RightInverse, Function.LeftInverse]
+
+end Equiv.Set

chore(Data/Set): move definitions to a new file (#9737)

This and other similar PRs will help us reduce import dependencies and improve parallel compilation in the future.

9fb36425

Diff

@@ -35,38 +35,6 @@ section Prod
 
 variable {α β γ δ : Type*} {s s₁ s₂ : Set α} {t t₁ t₂ : Set β} {a : α} {b : β}
 
-/-- The cartesian product `Set.prod s t` is the set of `(a, b)` such that `a ∈ s` and `b ∈ t`. -/
-def prod (s : Set α) (t : Set β) : Set (α × β) :=
-  { p | p.1 ∈ s ∧ p.2 ∈ t }
-#align set.prod Set.prod
-
-@[default_instance]
-instance instSProd : SProd (Set α) (Set β) (Set (α × β)) where
-  sprod := Set.prod
-
-theorem prod_eq (s : Set α) (t : Set β) : s ×ˢ t = Prod.fst ⁻¹' s ∩ Prod.snd ⁻¹' t :=
-  rfl
-#align set.prod_eq Set.prod_eq
-
-theorem mem_prod_eq {p : α × β} : (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) :=
-  rfl
-#align set.mem_prod_eq Set.mem_prod_eq
-
-@[simp, mfld_simps]
-theorem mem_prod {p : α × β} : p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t :=
-  Iff.rfl
-#align set.mem_prod Set.mem_prod
-
--- Porting note: Removing `simp` as `simp` can prove it
-@[mfld_simps]
-theorem prod_mk_mem_set_prod_eq : ((a, b) ∈ s ×ˢ t) = (a ∈ s ∧ b ∈ t) :=
-  rfl
-#align set.prod_mk_mem_set_prod_eq Set.prod_mk_mem_set_prod_eq
-
-theorem mk_mem_prod (ha : a ∈ s) (hb : b ∈ t) : (a, b) ∈ s ×ˢ t :=
-  ⟨ha, hb⟩
-#align set.mk_mem_prod Set.mk_mem_prod
-
 theorem Subsingleton.prod (hs : s.Subsingleton) (ht : t.Subsingleton) :
     (s ×ˢ t).Subsingleton := fun _x hx _y hy ↦
   Prod.ext (hs hx.1 hy.1) (ht hx.2 hy.2)
@@ -494,19 +462,6 @@ section Diagonal
 
 variable {α : Type*} {s t : Set α}
 
-/-- `diagonal α` is the set of `α × α` consisting of all pairs of the form `(a, a)`. -/
-def diagonal (α : Type*) : Set (α × α) :=
-  { p | p.1 = p.2 }
-#align set.diagonal Set.diagonal
-
-theorem mem_diagonal (x : α) : (x, x) ∈ diagonal α := by simp [diagonal]
-#align set.mem_diagonal Set.mem_diagonal
-
-@[simp]
-theorem mem_diagonal_iff {x : α × α} : x ∈ diagonal α ↔ x.1 = x.2 :=
-  Iff.rfl
-#align set.mem_diagonal_iff Set.mem_diagonal_iff
-
 lemma diagonal_nonempty [Nonempty α] : (diagonal α).Nonempty :=
   Nonempty.elim ‹_› fun x => ⟨_, mem_diagonal x⟩
 #align set.diagonal_nonempty Set.diagonal_nonempty
@@ -644,16 +599,6 @@ section OffDiag
 
 variable {α : Type*} {s t : Set α} {x : α × α} {a : α}
 
-/-- The off-diagonal of a set `s` is the set of pairs `(a, b)` with `a, b ∈ s` and `a ≠ b`. -/
-def offDiag (s : Set α) : Set (α × α) :=
-  { x | x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2 }
-#align set.off_diag Set.offDiag
-
-@[simp]
-theorem mem_offDiag : x ∈ s.offDiag ↔ x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2 :=
-  Iff.rfl
-#align set.mem_off_diag Set.mem_offDiag
-
 theorem offDiag_mono : Monotone (offDiag : Set α → Set (α × α)) := fun _ _ h _ =>
   And.imp (@h _) <| And.imp_left <| @h _
 #align set.off_diag_mono Set.offDiag_mono
@@ -745,22 +690,6 @@ section Pi
 
 variable {ι : Type*} {α β : ι → Type*} {s s₁ s₂ : Set ι} {t t₁ t₂ : ∀ i, Set (α i)} {i : ι}
 
-/-- Given an index set `ι` and a family of sets `t : Π i, Set (α i)`, `pi s t`
-is the set of dependent functions `f : Πa, π a` such that `f a` belongs to `t a`
-whenever `a ∈ s`. -/
-def pi (s : Set ι) (t : ∀ i, Set (α i)) : Set (∀ i, α i) :=
-  { f | ∀ i ∈ s, f i ∈ t i }
-#align set.pi Set.pi
-
-@[simp]
-theorem mem_pi {f : ∀ i, α i} : f ∈ s.pi t ↔ ∀ i ∈ s, f i ∈ t i :=
-  Iff.rfl
-#align set.mem_pi Set.mem_pi
-
--- Porting note: Removing `simp` as `simp` can prove it
-theorem mem_univ_pi {f : ∀ i, α i} : f ∈ pi univ t ↔ ∀ i, f i ∈ t i := by simp
-#align set.mem_univ_pi Set.mem_univ_pi
-
 @[simp]
 theorem empty_pi (s : ∀ i, Set (α i)) : pi ∅ s = univ := by
   ext

chore(*): use α → β instead of ∀ _ : α, β (#9529)

5618e431

Diff

@@ -946,7 +946,7 @@ theorem pi_update_of_mem [DecidableEq ι] (hi : i ∈ s) (f : ∀ j, α j) (a :
         by rw [union_pi, singleton_pi', update_same, pi_update_of_not_mem]; simp
 #align set.pi_update_of_mem Set.pi_update_of_mem
 
-theorem univ_pi_update [DecidableEq ι] {β : ∀ _, Type*} (i : ι) (f : ∀ j, α j) (a : α i)
+theorem univ_pi_update [DecidableEq ι] {β : ι → Type*} (i : ι) (f : ∀ j, α j) (a : α i)
     (t : ∀ j, α j → Set (β j)) :
     (pi univ fun j => t j (update f i a j)) = { x | x i ∈ t i a } ∩ pi {i}ᶜ fun j => t j (f j) :=
   by rw [compl_eq_univ_diff, ← pi_update_of_mem (mem_univ _)]

chore(*): drop $/<| before fun (#9361)

Subset of #9319

3694e27d

Diff

@@ -508,7 +508,7 @@ theorem mem_diagonal_iff {x : α × α} : x ∈ diagonal α ↔ x.1 = x.2 :=
 #align set.mem_diagonal_iff Set.mem_diagonal_iff
 
 lemma diagonal_nonempty [Nonempty α] : (diagonal α).Nonempty :=
-  Nonempty.elim ‹_› <| fun x => ⟨_, mem_diagonal x⟩
+  Nonempty.elim ‹_› fun x => ⟨_, mem_diagonal x⟩
 #align set.diagonal_nonempty Set.diagonal_nonempty
 
 instance decidableMemDiagonal [h : DecidableEq α] (x : α × α) : Decidable (x ∈ diagonal α) :=

chore(*): use ∃ x ∈ s, _ instead of ∃ (x) (_ : x ∈ s), _ (#9184)

Search for [∀∃].*(_ and manually replace some occurrences with more readable versions. In case of ∀, the new expressions are defeq to the old ones. In case of ∃, they differ by exists_prop.

In some rare cases, golf proofs that needed fixing.

14c72960

Diff

@@ -906,7 +906,7 @@ theorem union_pi : (s₁ ∪ s₂).pi t = s₁.pi t ∩ s₂.pi t := by
 #align set.union_pi Set.union_pi
 
 theorem union_pi_inter
-    (ht₁ : ∀ (i) (_ : i ∉ s₁), t₁ i = univ) (ht₂ : ∀ (i) (_ : i ∉ s₂), t₂ i = univ) :
+    (ht₁ : ∀ i ∉ s₁, t₁ i = univ) (ht₂ : ∀ i ∉ s₂, t₂ i = univ) :
     (s₁ ∪ s₂).pi (fun i ↦ t₁ i ∩ t₂ i) = s₁.pi t₁ ∩ s₂.pi t₂ := by
   ext x
   simp only [mem_pi, mem_union, mem_inter_iff]
@@ -1019,7 +1019,7 @@ theorem update_preimage_pi [DecidableEq ι] {f : ∀ i, α i} (hi : i ∈ s)
       exact hf j hj h
 #align set.update_preimage_pi Set.update_preimage_pi
 
-theorem update_preimage_univ_pi [DecidableEq ι] {f : ∀ i, α i} (hf : ∀ (j) (_ : j ≠ i), f j ∈ t j) :
+theorem update_preimage_univ_pi [DecidableEq ι] {f : ∀ i, α i} (hf : ∀ j ≠ i, f j ∈ t j) :
     update f i ⁻¹' pi univ t = t i :=
   update_preimage_pi (mem_univ i) fun j _ => hf j
 #align set.update_preimage_univ_pi Set.update_preimage_univ_pi

chore: remove uses of cases' (#9171)

I literally went through and regex'd some uses of cases', replacing them with rcases; this is meant to be a low effort PR as I hope that tools can do this in the future.

rcases is an easier replacement than cases, though with better tools we could in future do a second pass converting simple rcases added here (and existing ones) to cases.

3fca282c

Diff

@@ -411,7 +411,7 @@ theorem prod_diff_prod : s ×ˢ t \ s₁ ×ˢ t₁ = s ×ˢ (t \ t₁) ∪ (s \
 /-- A product set is included in a product set if and only factors are included, or a factor of the
 first set is empty. -/
 theorem prod_subset_prod_iff : s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t ⊆ t₁ ∨ s = ∅ ∨ t = ∅ := by
-  cases' (s ×ˢ t).eq_empty_or_nonempty with h h
+  rcases (s ×ˢ t).eq_empty_or_nonempty with h | h
   · simp [h, prod_eq_empty_iff.1 h]
   have st : s.Nonempty ∧ t.Nonempty := by rwa [prod_nonempty_iff] at h
   refine' ⟨fun H => Or.inl ⟨_, _⟩, _⟩
@@ -439,7 +439,7 @@ theorem prod_eq_prod_iff_of_nonempty (h : (s ×ˢ t).Nonempty) :
 theorem prod_eq_prod_iff :
     s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁ ∨ (s = ∅ ∨ t = ∅) ∧ (s₁ = ∅ ∨ t₁ = ∅) := by
   symm
-  cases' eq_empty_or_nonempty (s ×ˢ t) with h h
+  rcases eq_empty_or_nonempty (s ×ˢ t) with h | h
   · simp_rw [h, @eq_comm _ ∅, prod_eq_empty_iff, prod_eq_empty_iff.mp h, true_and_iff,
       or_iff_right_iff_imp]
     rintro ⟨rfl, rfl⟩

feat: s × t = univ ↔ s = univ ∧ t = univ (#8976)

for sets and finsets

From LeanCamCombi

de48aea2

Diff

@@ -133,6 +133,9 @@ theorem univ_prod {t : Set β} : (univ : Set α) ×ˢ t = Prod.snd ⁻¹' t := b
 theorem prod_univ {s : Set α} : s ×ˢ (univ : Set β) = Prod.fst ⁻¹' s := by simp [prod_eq]
 #align set.prod_univ Set.prod_univ
 
+@[simp] lemma prod_eq_univ [Nonempty α] [Nonempty β] : s ×ˢ t = univ ↔ s = univ ∧ t = univ := by
+  simp [eq_univ_iff_forall, forall_and]
+
 @[simp]
 theorem singleton_prod : ({a} : Set α) ×ˢ t = Prod.mk a '' t := by
   ext ⟨x, y⟩

feat: pi-systems generating the product sigma algebra (#7566)

We define pi-systems of cylinders and prove that they generate MeasurableSpace.pi.

Co-authored-by: Peter Pfaffelhuber From the Kolmogorov extension theorem project.

Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

55a024a3

Diff

@@ -902,6 +902,25 @@ theorem union_pi : (s₁ ∪ s₂).pi t = s₁.pi t ∩ s₂.pi t := by
   simp [pi, or_imp, forall_and, setOf_and]
 #align set.union_pi Set.union_pi
 
+theorem union_pi_inter
+    (ht₁ : ∀ (i) (_ : i ∉ s₁), t₁ i = univ) (ht₂ : ∀ (i) (_ : i ∉ s₂), t₂ i = univ) :
+    (s₁ ∪ s₂).pi (fun i ↦ t₁ i ∩ t₂ i) = s₁.pi t₁ ∩ s₂.pi t₂ := by
+  ext x
+  simp only [mem_pi, mem_union, mem_inter_iff]
+  refine ⟨fun h ↦ ⟨fun i his₁ ↦ (h i (Or.inl his₁)).1, fun i his₂ ↦ (h i (Or.inr his₂)).2⟩,
+    fun h i hi ↦ ?_⟩
+  cases' hi with hi hi
+  · by_cases hi2 : i ∈ s₂
+    · exact ⟨h.1 i hi, h.2 i hi2⟩
+    · refine ⟨h.1 i hi, ?_⟩
+      rw [ht₂ i hi2]
+      exact mem_univ _
+  · by_cases hi1 : i ∈ s₁
+    · exact ⟨h.1 i hi1, h.2 i hi⟩
+    · refine ⟨?_, h.2 i hi⟩
+      rw [ht₁ i hi1]
+      exact mem_univ _
+
 @[simp]
 theorem pi_inter_compl (s : Set ι) : pi s t ∩ pi sᶜ t = pi univ t := by
   rw [← union_pi, union_compl_self]

feat: define updateFinset which updates a finite number components of a vector (#7341)

from the Sobolev project (formerly: marginal project)

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

0eb6b931

Diff

@@ -833,6 +833,9 @@ theorem Disjoint.set_pi (hi : i ∈ s) (ht : Disjoint (t₁ i) (t₂ i)) : Disjo
   disjoint_left.2 fun _ h₁ h₂ => disjoint_left.1 ht (h₁ _ hi) (h₂ _ hi)
 #align set.disjoint.set_pi Set.Disjoint.set_pi
 
+theorem uniqueElim_preimage [Unique ι] (t : ∀ i, Set (α i)) :
+    uniqueElim ⁻¹' pi univ t = t (default : ι) := by ext; simp [Unique.forall_iff]
+
 section Nonempty
 
 variable [∀ i, Nonempty (α i)]

feat: separated and locally injective maps (#7911)

A function from a topological space X to a type Y is a separated map if any two distinct points in X with the same image in Y can be separated by open neighborhoods. A constant function is a separated map if and only if X is a T2Space.

A function from a topological space X is locally injective if every point of X has a neighborhood on which f is injective. A constant function is locally injective if and only if X is discrete.

Given f : X → Y one can form the pullback $X \times_Y X$; the diagonal map $\Delta: X \to X \times_Y X$ is always an embedding. It is a closed embedding iff f is a separated map, iff the equal locus of any two continuous maps equalized by f is closed. It is an open embedding iff f is locally injective, iff any such equal locus is open. Therefore, if f is a locally injective separated map (e.g. a covering map), the equal locus of two continuous maps equalized by f is clopen, so if the two maps agree on a point, then they agree on the whole connected component. This is crucial to showing the uniqueness of path lifting and the uniqueness and continuity of homotopy lifting for covering spaces.

The analogue of separated maps and locally injective maps in algebraic geometry are separated morphisms and unramified morphisms, respectively.

83b113a5

Diff

@@ -554,6 +554,89 @@ theorem diag_image (s : Set α) : (fun x => (x, x)) '' s = diagonal α ∩ s ×
 
 end Diagonal
 
+end Set
+
+section Pullback
+
+open Set
+
+variable {X Y Z}
+
+/-- The fiber product $X \times_Y Z$. -/
+abbrev Function.Pullback (f : X → Y) (g : Z → Y) := {p : X × Z // f p.1 = g p.2}
+
+/-- The fiber product $X \times_Y X$. -/
+abbrev Function.PullbackSelf (f : X → Y) := f.Pullback f
+
+/-- The projection from the fiber product to the first factor. -/
+def Function.Pullback.fst {f : X → Y} {g : Z → Y} (p : f.Pullback g) : X := p.val.1
+
+/-- The projection from the fiber product to the second factor. -/
+def Function.Pullback.snd {f : X → Y} {g : Z → Y} (p : f.Pullback g) : Z := p.val.2
+
+open Function.Pullback in
+lemma Function.pullback_comm_sq (f : X → Y) (g : Z → Y) :
+    f ∘ @fst X Y Z f g = g ∘ @snd X Y Z f g := funext fun p ↦ p.2
+
+/-- The diagonal map $\Delta: X \to X \times_Y X$. -/
+def toPullbackDiag (f : X → Y) (x : X) : f.Pullback f := ⟨(x, x), rfl⟩
+
+/-- The diagonal $\Delta(X) \subseteq X \times_Y X$. -/
+def Function.pullbackDiagonal (f : X → Y) : Set (f.Pullback f) := {p | p.fst = p.snd}
+
+/-- Three functions between the three pairs of spaces $X_i, Y_i, Z_i$ that are compatible
+  induce a function $X_1 \times_{Y_1} Z_1 \to X_2 \times_{Y_2} Z_2$. -/
+def Function.mapPullback {X₁ X₂ Y₁ Y₂ Z₁ Z₂}
+    {f₁ : X₁ → Y₁} {g₁ : Z₁ → Y₁} {f₂ : X₂ → Y₂} {g₂ : Z₂ → Y₂}
+    (mapX : X₁ → X₂) (mapY : Y₁ → Y₂) (mapZ : Z₁ → Z₂)
+    (commX : f₂ ∘ mapX = mapY ∘ f₁) (commZ : g₂ ∘ mapZ = mapY ∘ g₁)
+    (p : f₁.Pullback g₁) : f₂.Pullback g₂ :=
+  ⟨(mapX p.fst, mapZ p.snd),
+    (congr_fun commX _).trans <| (congr_arg mapY p.2).trans <| congr_fun commZ.symm _⟩
+
+open Function.Pullback in
+/-- The projection $(X \times_Y Z) \times_Z (X \times_Y Z) \to X \times_Y X$. -/
+def Function.PullbackSelf.map_fst {f : X → Y} {g : Z → Y} :
+    (@snd X Y Z f g).PullbackSelf → f.PullbackSelf :=
+  mapPullback fst g fst (pullback_comm_sq f g) (pullback_comm_sq f g)
+
+open Function.Pullback in
+/-- The projection $(X \times_Y Z) \times_X (X \times_Y Z) \to Z \times_Y Z$. -/
+def Function.PullbackSelf.map_snd {f : X → Y} {g : Z → Y} :
+    (@fst X Y Z f g).PullbackSelf → g.PullbackSelf :=
+  mapPullback snd f snd (pullback_comm_sq f g).symm (pullback_comm_sq f g).symm
+
+open Function.PullbackSelf Function.Pullback
+theorem preimage_map_fst_pullbackDiagonal {f : X → Y} {g : Z → Y} :
+    @map_fst X Y Z f g ⁻¹' pullbackDiagonal f = pullbackDiagonal (@snd X Y Z f g) := by
+  ext ⟨⟨p₁, p₂⟩, he⟩
+  simp_rw [pullbackDiagonal, mem_setOf, Subtype.ext_iff, Prod.ext_iff]
+  exact (and_iff_left he).symm
+
+theorem Function.Injective.preimage_pullbackDiagonal {f : X → Y} {g : Z → X} (inj : g.Injective) :
+    mapPullback g id g (by rfl) (by rfl) ⁻¹' pullbackDiagonal f = pullbackDiagonal (f ∘ g) :=
+  ext fun _ ↦ inj.eq_iff
+
+theorem image_toPullbackDiag (f : X → Y) (s : Set X) :
+    toPullbackDiag f '' s = pullbackDiagonal f ∩ Subtype.val ⁻¹' s ×ˢ s := by
+  ext x
+  constructor
+  · rintro ⟨x, hx, rfl⟩
+    exact ⟨rfl, hx, hx⟩
+  · obtain ⟨⟨x, y⟩, h⟩ := x
+    rintro ⟨rfl : x = y, h2x⟩
+    exact mem_image_of_mem _ h2x.1
+
+theorem range_toPullbackDiag (f : X → Y) : range (toPullbackDiag f) = pullbackDiagonal f := by
+  rw [← image_univ, image_toPullbackDiag, univ_prod_univ, preimage_univ, inter_univ]
+
+theorem injective_toPullbackDiag (f : X → Y) : (toPullbackDiag f).Injective :=
+  fun _ _ h ↦ congr_arg Prod.fst (congr_arg Subtype.val h)
+
+end Pullback
+
+namespace Set
+
 section OffDiag
 
 variable {α : Type*} {s t : Set α} {x : α × α} {a : α}

chore: remove nonterminal simp (#7580)

Removes nonterminal simps on lines looking like simp [...]

6fc8e6ec

Diff

@@ -211,7 +211,7 @@ theorem insert_prod : insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t := by
 theorem prod_insert : s ×ˢ insert b t = (fun a => (a, b)) '' s ∪ s ×ˢ t := by
   ext ⟨x, y⟩
   -- Porting note: was `simp (config := { contextual := true }) [image, iff_def, or_imp, Imp.swap]`
-  simp [image, or_imp]
+  simp only [mem_prod, mem_insert_iff, image, mem_union, mem_setOf_eq, Prod.mk.injEq]
   refine ⟨fun h => ?_, fun h => ?_⟩
   · obtain ⟨hx, rfl|hy⟩ := h
     · exact Or.inl ⟨x, hx, rfl, rfl⟩

chore: remove many Type _ before the colon (#7718)

We have turned to Type* instead of Type _, but many of them remained in mathlib because the straight replacement did not work. In general, having Type _ before the colon is a code smell, though, as it hides which types should be in the same universe and which shouldn't, and is not very robust.

This PR replaces most of the remaining Type _ before the colon (except those in category theory) by Type* or Type u. This has uncovered a few bugs (where declarations were not as polymorphic as they should be).

I had to increase heartbeats at two places when replacing Type _ by Type*, but I think it's worth it as it's really more robust.

fe9572d2

Diff

@@ -955,7 +955,7 @@ theorem piCongrLeft_preimage_univ_pi (f : ι' ≃ ι) (t : ∀ i, Set (α i)) :
     f.piCongrLeft α ⁻¹' univ.pi t = univ.pi fun i => t (f i) := by
   simpa [f.surjective.range_eq] using piCongrLeft_preimage_pi f univ t
 
-theorem sumPiEquivProdPi_symm_preimage_univ_pi (π : ι ⊕ ι' → Type _) (t : ∀ i, Set (π i)) :
+theorem sumPiEquivProdPi_symm_preimage_univ_pi (π : ι ⊕ ι' → Type*) (t : ∀ i, Set (π i)) :
     (sumPiEquivProdPi π).symm ⁻¹' univ.pi t =
     univ.pi (fun i => t (.inl i)) ×ˢ univ.pi fun i => t (.inr i) := by
   ext

feat: lemmas about equiv and logic (#7338)

From the marginal project

20cc2dcd

Diff

@@ -690,6 +690,11 @@ theorem pi_univ (s : Set ι) : (pi s fun i => (univ : Set (α i))) = univ :=
   eq_univ_of_forall fun _ _ _ => mem_univ _
 #align set.pi_univ Set.pi_univ
 
+@[simp]
+theorem pi_univ_ite (s : Set ι) [DecidablePred (· ∈ s)] (t : ∀ i, Set (α i)) :
+    (pi univ fun i => if i ∈ s then t i else univ) = s.pi t := by
+  ext; simp_rw [Set.mem_pi]; apply forall_congr'; intro i; split_ifs with h <;> simp [h]
+
 theorem pi_mono (h : ∀ i ∈ s, t₁ i ⊆ t₂ i) : pi s t₁ ⊆ pi s t₂ := fun _ hx i hi => h i hi <| hx i hi
 #align set.pi_mono Set.pi_mono
 
@@ -926,3 +931,37 @@ theorem univ_pi_ite (s : Set ι) [DecidablePred (· ∈ s)] (t : ∀ i, Set (α
 end Pi
 
 end Set
+
+namespace Equiv
+
+open Set
+variable {ι ι' : Type*} {α : ι → Type*}
+
+theorem piCongrLeft_symm_preimage_pi (f : ι' ≃ ι) (s : Set ι') (t : ∀ i, Set (α i)) :
+    (f.piCongrLeft α).symm ⁻¹' s.pi (fun i' => t <| f i') = (f '' s).pi t := by
+  ext; simp
+
+theorem piCongrLeft_symm_preimage_univ_pi (f : ι' ≃ ι) (t : ∀ i, Set (α i)) :
+    (f.piCongrLeft α).symm ⁻¹' univ.pi (fun i' => t <| f i') = univ.pi t := by
+  simpa [f.surjective.range_eq] using piCongrLeft_symm_preimage_pi f univ t
+
+theorem piCongrLeft_preimage_pi (f : ι' ≃ ι) (s : Set ι') (t : ∀ i, Set (α i)) :
+    f.piCongrLeft α ⁻¹' (f '' s).pi t = s.pi fun i => t (f i) := by
+  apply Set.ext;
+  rw [← (f.piCongrLeft α).symm.forall_congr_left]
+  simp
+
+theorem piCongrLeft_preimage_univ_pi (f : ι' ≃ ι) (t : ∀ i, Set (α i)) :
+    f.piCongrLeft α ⁻¹' univ.pi t = univ.pi fun i => t (f i) := by
+  simpa [f.surjective.range_eq] using piCongrLeft_preimage_pi f univ t
+
+theorem sumPiEquivProdPi_symm_preimage_univ_pi (π : ι ⊕ ι' → Type _) (t : ∀ i, Set (π i)) :
+    (sumPiEquivProdPi π).symm ⁻¹' univ.pi t =
+    univ.pi (fun i => t (.inl i)) ×ˢ univ.pi fun i => t (.inr i) := by
+  ext
+  simp_rw [mem_preimage, mem_prod, mem_univ_pi, sumPiEquivProdPi_symm_apply]
+  constructor
+  · intro h; constructor <;> intro i <;> apply h
+  · rintro ⟨h₁, h₂⟩ (i|i) <;> simp <;> apply_assumption
+
+end Equiv

chore: generalize layercake formulas to null-measurable and a.e.-nonnegative functions (#6936)

The layercake formulas (a typical example of which is ∫⁻ f^p ∂μ = p * ∫⁻ t in 0..∞, t^(p-1) * μ {ω | f(ω) > t}) had been originally proven assuming measurability and nonnegativity of f. This PR generalizes them to null-measurable and a.e.-nonnegative f.

Co-authored-by: kkytola <“kalle.kytola@aalto.fi”> Co-authored-by: kkytola <39528102+kkytola@users.noreply.github.com>

65ef10e6

Diff

@@ -176,6 +176,17 @@ theorem prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×
   simp [and_assoc, and_left_comm]
 #align set.prod_inter_prod Set.prod_inter_prod
 
+lemma compl_prod_eq_union {α β : Type*} (s : Set α) (t : Set β) :
+    (s ×ˢ t)ᶜ = (sᶜ ×ˢ univ) ∪ (univ ×ˢ tᶜ) := by
+  ext p
+  simp only [mem_compl_iff, mem_prod, not_and, mem_union, mem_univ, and_true, true_and]
+  constructor <;> intro h
+  · by_cases fst_in_s : p.fst ∈ s
+    · exact Or.inr (h fst_in_s)
+    · exact Or.inl fst_in_s
+  · intro fst_in_s
+    simpa only [fst_in_s, not_true, false_or] using h
+
 @[simp]
 theorem disjoint_prod : Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂ := by
   simp_rw [disjoint_left, mem_prod, not_and_or, Prod.forall, and_imp, ← @forall_or_right α, ←

feat: patch for new alias command (#6172)

19e0ba92

Diff

@@ -571,10 +571,10 @@ theorem offDiag_eq_empty : s.offDiag = ∅ ↔ s.Subsingleton := by
   rw [← not_nonempty_iff_eq_empty, ← not_nontrivial_iff, offDiag_nonempty.not]
 #align set.off_diag_eq_empty Set.offDiag_eq_empty
 
-alias offDiag_nonempty ↔ _ Nontrivial.offDiag_nonempty
+alias ⟨_, Nontrivial.offDiag_nonempty⟩ := offDiag_nonempty
 #align set.nontrivial.off_diag_nonempty Set.Nontrivial.offDiag_nonempty
 
-alias offDiag_nonempty ↔ _ Subsingleton.offDiag_eq_empty
+alias ⟨_, Subsingleton.offDiag_eq_empty⟩ := offDiag_nonempty
 #align set.subsingleton.off_diag_eq_empty Set.Subsingleton.offDiag_eq_empty
 
 variable (s t)

feat(Set/Prod): add Set.Subsingleton.prod (#6529)

Add Set.Subsingleton.prod and Set.subsingleton_univ_pi.

9560eb0d

Diff

@@ -67,6 +67,10 @@ theorem mk_mem_prod (ha : a ∈ s) (hb : b ∈ t) : (a, b) ∈ s ×ˢ t :=
   ⟨ha, hb⟩
 #align set.mk_mem_prod Set.mk_mem_prod
 
+theorem Subsingleton.prod (hs : s.Subsingleton) (ht : t.Subsingleton) :
+    (s ×ˢ t).Subsingleton := fun _x hx _y hy ↦
+  Prod.ext (hs hx.1 hy.1) (ht hx.2 hy.2)
+
 noncomputable instance decidableMemProd [DecidablePred (· ∈ s)] [DecidablePred (· ∈ t)] :
     DecidablePred (· ∈ s ×ˢ t) := fun _ => And.decidable
 #align set.decidable_mem_prod Set.decidableMemProd
@@ -666,6 +670,10 @@ theorem empty_pi (s : ∀ i, Set (α i)) : pi ∅ s = univ := by
   simp [pi]
 #align set.empty_pi Set.empty_pi
 
+theorem subsingleton_univ_pi (ht : ∀ i, (t i).Subsingleton) :
+    (univ.pi t).Subsingleton := fun _f hf _g hg ↦ funext fun i ↦
+  (ht i) (hf _ <| mem_univ _) (hg _ <| mem_univ _)
+
 @[simp]
 theorem pi_univ (s : Set ι) : (pi s fun i => (univ : Set (α i))) = univ :=
   eq_univ_of_forall fun _ _ _ => mem_univ _

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

@@ -33,7 +33,7 @@ namespace Set
 
 section Prod
 
-variable {α β γ δ : Type _} {s s₁ s₂ : Set α} {t t₁ t₂ : Set β} {a : α} {b : β}
+variable {α β γ δ : Type*} {s s₁ s₂ : Set α} {t t₁ t₂ : Set β} {a : α} {b : β}
 
 /-- The cartesian product `Set.prod s t` is the set of `(a, b)` such that `a ∈ s` and `b ∈ t`. -/
 def prod (s : Set α) (t : Set β) : Set (α × β) :=
@@ -474,10 +474,10 @@ In this section we prove some lemmas about the diagonal set `{p | p.1 = p.2}` an
 
 section Diagonal
 
-variable {α : Type _} {s t : Set α}
+variable {α : Type*} {s t : Set α}
 
 /-- `diagonal α` is the set of `α × α` consisting of all pairs of the form `(a, a)`. -/
-def diagonal (α : Type _) : Set (α × α) :=
+def diagonal (α : Type*) : Set (α × α) :=
   { p | p.1 = p.2 }
 #align set.diagonal Set.diagonal
 
@@ -541,7 +541,7 @@ end Diagonal
 
 section OffDiag
 
-variable {α : Type _} {s t : Set α} {x : α × α} {a : α}
+variable {α : Type*} {s t : Set α} {x : α × α} {a : α}
 
 /-- The off-diagonal of a set `s` is the set of pairs `(a, b)` with `a, b ∈ s` and `a ≠ b`. -/
 def offDiag (s : Set α) : Set (α × α) :=
@@ -642,7 +642,7 @@ end OffDiag
 
 section Pi
 
-variable {ι : Type _} {α β : ι → Type _} {s s₁ s₂ : Set ι} {t t₁ t₂ : ∀ i, Set (α i)} {i : ι}
+variable {ι : Type*} {α β : ι → Type*} {s s₁ s₂ : Set ι} {t t₁ t₂ : ∀ i, Set (α i)} {i : ι}
 
 /-- Given an index set `ι` and a family of sets `t : Π i, Set (α i)`, `pi s t`
 is the set of dependent functions `f : Πa, π a` such that `f a` belongs to `t a`
@@ -814,7 +814,7 @@ theorem pi_update_of_mem [DecidableEq ι] (hi : i ∈ s) (f : ∀ j, α j) (a :
         by rw [union_pi, singleton_pi', update_same, pi_update_of_not_mem]; simp
 #align set.pi_update_of_mem Set.pi_update_of_mem
 
-theorem univ_pi_update [DecidableEq ι] {β : ∀ _, Type _} (i : ι) (f : ∀ j, α j) (a : α i)
+theorem univ_pi_update [DecidableEq ι] {β : ∀ _, Type*} (i : ι) (f : ∀ j, α j) (a : α i)
     (t : ∀ j, α j → Set (β j)) :
     (pi univ fun j => t j (update f i a j)) = { x | x i ∈ t i a } ∩ pi {i}ᶜ fun j => t j (f j) :=
   by rw [compl_eq_univ_diff, ← pi_update_of_mem (mem_univ _)]

chore(Data/Set): add 2 @[simp] attrs (#6251)

The corresponding Finset lemmas are already marked simp.

ff2de957

Diff

@@ -327,10 +327,12 @@ theorem Nonempty.fst : (s ×ˢ t).Nonempty → s.Nonempty := fun ⟨x, hx⟩ =>
 theorem Nonempty.snd : (s ×ˢ t).Nonempty → t.Nonempty := fun ⟨x, hx⟩ => ⟨x.2, hx.2⟩
 #align set.nonempty.snd Set.Nonempty.snd
 
+@[simp]
 theorem prod_nonempty_iff : (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty :=
   ⟨fun h => ⟨h.fst, h.snd⟩, fun h => h.1.prod h.2⟩
 #align set.prod_nonempty_iff Set.prod_nonempty_iff
 
+@[simp]
 theorem prod_eq_empty_iff : s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅ := by
   simp only [not_nonempty_iff_eq_empty.symm, prod_nonempty_iff, not_and_or]
 #align set.prod_eq_empty_iff Set.prod_eq_empty_iff

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,15 +2,12 @@
 Copyright (c) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro, Johannes Hölzl, Patrick Massot
-
-! This file was ported from Lean 3 source module data.set.prod
-! leanprover-community/mathlib commit 48fb5b5280e7c81672afc9524185ae994553ebf4
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Set.Image
 import Mathlib.Data.SProd
 
+#align_import data.set.prod from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
+
 /-!
 # Sets in product and pi types

refactor: move all register_simp_attrs to 1 file (#5681)

There are slight differences between mathlib3 and mathlib4 (different set of attributes, different lemmas are in core/std), so I redid the same refactor instead of forward-porting changes.

mathlib3 PR: leanprover-community/mathlib#19223

ceaa4ecb

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro, Johannes Hölzl, Patrick Massot
 
 ! This file was ported from Lean 3 source module data.set.prod
-! leanprover-community/mathlib commit c4c2ed622f43768eff32608d4a0f8a6cec1c047d
+! leanprover-community/mathlib commit 48fb5b5280e7c81672afc9524185ae994553ebf4
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -55,12 +55,13 @@ theorem mem_prod_eq {p : α × β} : (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t
   rfl
 #align set.mem_prod_eq Set.mem_prod_eq
 
-@[simp]
+@[simp, mfld_simps]
 theorem mem_prod {p : α × β} : p ∈ s ×ˢ t ↔ p.1 ∈ s ∧ p.2 ∈ t :=
   Iff.rfl
 #align set.mem_prod Set.mem_prod
 
 -- Porting note: Removing `simp` as `simp` can prove it
+@[mfld_simps]
 theorem prod_mk_mem_set_prod_eq : ((a, b) ∈ s ×ˢ t) = (a ∈ s ∧ b ∈ t) :=
   rfl
 #align set.prod_mk_mem_set_prod_eq Set.prod_mk_mem_set_prod_eq
@@ -119,7 +120,7 @@ theorem empty_prod : (∅ : Set α) ×ˢ t = ∅ := by
   exact false_and_iff _
 #align set.empty_prod Set.empty_prod
 
-@[simp]
+@[simp, mfld_simps]
 theorem univ_prod_univ : @univ α ×ˢ @univ β = univ := by
   ext
   exact true_and_iff _
@@ -168,6 +169,7 @@ theorem prod_inter : s ×ˢ (t₁ ∩ t₂) = s ×ˢ t₁ ∩ s ×ˢ t₂ := by
   simp only [← and_and_left, mem_inter_iff, mem_prod]
 #align set.prod_inter Set.prod_inter
 
+@[mfld_simps]
 theorem prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂) := by
   ext ⟨x, y⟩
   simp [and_assoc, and_left_comm]
@@ -296,7 +298,7 @@ theorem prod_range_range_eq {m₁ : α → γ} {m₂ : β → δ} :
   ext <| by simp [range]
 #align set.prod_range_range_eq Set.prod_range_range_eq
 
-@[simp]
+@[simp, mfld_simps]
 theorem range_prod_map {m₁ : α → γ} {m₂ : β → δ} : range (Prod.map m₁ m₂) = range m₁ ×ˢ range m₂ :=
   prod_range_range_eq.symm
 #align set.range_prod_map Set.range_prod_map

fix: change compl precedence (#5586)

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

4d4f0f25

Diff

@@ -513,7 +513,7 @@ theorem diagonal_subset_iff {s} : diagonal α ⊆ s ↔ ∀ x, (x, x) ∈ s := b
 #align set.diagonal_subset_iff Set.diagonal_subset_iff
 
 @[simp]
-theorem prod_subset_compl_diagonal_iff_disjoint : s ×ˢ t ⊆ diagonal αᶜ ↔ Disjoint s t :=
+theorem prod_subset_compl_diagonal_iff_disjoint : s ×ˢ t ⊆ (diagonal α)ᶜ ↔ Disjoint s t :=
   prod_subset_iff.trans disjoint_iff_forall_ne.symm
 #align set.prod_subset_compl_diagonal_iff_disjoint Set.prod_subset_compl_diagonal_iff_disjoint
 
@@ -590,7 +590,7 @@ theorem offDiag_singleton (a : α) : ({a} : Set α).offDiag = ∅ := by simp
 #align set.off_diag_singleton Set.offDiag_singleton
 
 @[simp]
-theorem offDiag_univ : (univ : Set α).offDiag = diagonal αᶜ :=
+theorem offDiag_univ : (univ : Set α).offDiag = (diagonal α)ᶜ :=
   ext <| by simp
 #align set.off_diag_univ Set.offDiag_univ
 
@@ -792,7 +792,7 @@ theorem union_pi : (s₁ ∪ s₂).pi t = s₁.pi t ∩ s₂.pi t := by
 #align set.union_pi Set.union_pi
 
 @[simp]
-theorem pi_inter_compl (s : Set ι) : pi s t ∩ pi (sᶜ) t = pi univ t := by
+theorem pi_inter_compl (s : Set ι) : pi s t ∩ pi sᶜ t = pi univ t := by
   rw [← union_pi, union_compl_self]
 #align set.pi_inter_compl Set.pi_inter_compl
 
@@ -815,7 +815,7 @@ theorem pi_update_of_mem [DecidableEq ι] (hi : i ∈ s) (f : ∀ j, α j) (a :
 
 theorem univ_pi_update [DecidableEq ι] {β : ∀ _, Type _} (i : ι) (f : ∀ j, α j) (a : α i)
     (t : ∀ j, α j → Set (β j)) :
-    (pi univ fun j => t j (update f i a j)) = { x | x i ∈ t i a } ∩ pi ({i}ᶜ) fun j => t j (f j) :=
+    (pi univ fun j => t j (update f i a j)) = { x | x i ∈ t i a } ∩ pi {i}ᶜ fun j => t j (f j) :=
   by rw [compl_eq_univ_diff, ← pi_update_of_mem (mem_univ _)]
 #align set.univ_pi_update Set.univ_pi_update

Match https://github.com/leanprover-community/mathlib/pull/11932

feat: More sup_indep lemmas (#5196)

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

e266a22f

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro, Johannes Hölzl, Patrick Massot
 
 ! This file was ported from Lean 3 source module data.set.prod
-! leanprover-community/mathlib commit 27f315c5591c84687852f816d8ef31fe103d03de
+! leanprover-community/mathlib commit c4c2ed622f43768eff32608d4a0f8a6cec1c047d
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -173,11 +173,22 @@ theorem prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×
   simp [and_assoc, and_left_comm]
 #align set.prod_inter_prod Set.prod_inter_prod
 
+@[simp]
 theorem disjoint_prod : Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂ := by
   simp_rw [disjoint_left, mem_prod, not_and_or, Prod.forall, and_imp, ← @forall_or_right α, ←
     @forall_or_left β, ← @forall_or_right (_ ∈ s₁), ← @forall_or_left (_ ∈ t₁)]
 #align set.disjoint_prod Set.disjoint_prod
 
+theorem Disjoint.set_prod_left (hs : Disjoint s₁ s₂) (t₁ t₂ : Set β) :
+    Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) :=
+  disjoint_left.2 fun ⟨_a, _b⟩ ⟨ha₁, _⟩ ⟨ha₂, _⟩ => disjoint_left.1 hs ha₁ ha₂
+#align set.disjoint.set_prod_left Set.Disjoint.set_prod_left
+
+theorem Disjoint.set_prod_right (ht : Disjoint t₁ t₂) (s₁ s₂ : Set α) :
+    Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) :=
+  disjoint_left.2 fun ⟨_a, _b⟩ ⟨_, hb₁⟩ ⟨_, hb₂⟩ => disjoint_left.1 ht hb₁ hb₂
+#align set.disjoint.set_prod_right Set.Disjoint.set_prod_right
+
 theorem insert_prod : insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t := by
   ext ⟨x, y⟩
   simp (config := { contextual := true }) [image, iff_def, or_imp, Imp.swap]
@@ -710,6 +721,24 @@ theorem disjoint_univ_pi : Disjoint (pi univ t₁) (pi univ t₂) ↔ ∃ i, Dis
   simp only [disjoint_iff_inter_eq_empty, ← pi_inter_distrib, univ_pi_eq_empty_iff]
 #align set.disjoint_univ_pi Set.disjoint_univ_pi
 
+theorem Disjoint.set_pi (hi : i ∈ s) (ht : Disjoint (t₁ i) (t₂ i)) : Disjoint (s.pi t₁) (s.pi t₂) :=
+  disjoint_left.2 fun _ h₁ h₂ => disjoint_left.1 ht (h₁ _ hi) (h₂ _ hi)
+#align set.disjoint.set_pi Set.Disjoint.set_pi
+
+section Nonempty
+
+variable [∀ i, Nonempty (α i)]
+
+theorem pi_eq_empty_iff' : s.pi t = ∅ ↔ ∃ i ∈ s, t i = ∅ := by simp [pi_eq_empty_iff]
+#align set.pi_eq_empty_iff' Set.pi_eq_empty_iff'
+
+@[simp]
+theorem disjoint_pi : Disjoint (s.pi t₁) (s.pi t₂) ↔ ∃ i ∈ s, Disjoint (t₁ i) (t₂ i) := by
+  simp only [disjoint_iff_inter_eq_empty, ← pi_inter_distrib, pi_eq_empty_iff']
+#align set.disjoint_pi Set.disjoint_pi
+
+end Nonempty
+
 -- Porting note: Removing `simp` - LHS does not simplify
 theorem range_dcomp (f : ∀ i, α i → β i) :
     (range fun g : ∀ i, α i => fun i => f i (g i)) = pi univ fun i => range (f i) := by

chore: convert lambda in docs to fun (#5045)

Found with git grep -n "λ [a-zA-Z_ ]*,"

1164cf04

Diff

@@ -456,7 +456,7 @@ end Prod
 /-! ### Diagonal
 
 In this section we prove some lemmas about the diagonal set `{p | p.1 = p.2}` and the diagonal map
-`λ x, (x, x)`.
+`fun x ↦ (x, x)`.
 -/

chore: formatting issues (#4947)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

5068808d

Diff

@@ -478,7 +478,7 @@ theorem mem_diagonal_iff {x : α × α} : x ∈ diagonal α ↔ x.1 = x.2 :=
 #align set.mem_diagonal_iff Set.mem_diagonal_iff
 
 lemma diagonal_nonempty [Nonempty α] : (diagonal α).Nonempty :=
-Nonempty.elim ‹_› <| fun x => ⟨_, mem_diagonal x⟩
+  Nonempty.elim ‹_› <| fun x => ⟨_, mem_diagonal x⟩
 #align set.diagonal_nonempty Set.diagonal_nonempty
 
 instance decidableMemDiagonal [h : DecidableEq α] (x : α × α) : Decidable (x ∈ diagonal α) :=

refactor: use the typeclass SProd to implement overloaded notation · ×ˢ · (#4200)

Currently, the following notations are changed from · ×ˢ · because Lean 4 can't deal with ambiguous notations. | Definition | Notation | | :

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Kyle Miller <kmill31415@gmail.com> Co-authored-by: Chris Hughes <chrishughes24@gmail.com>

6c01dc6e

Diff

@@ -9,6 +9,7 @@ Authors: Mario Carneiro, Johannes Hölzl, Patrick Massot
 ! if you have ported upstream changes.
 -/
 import Mathlib.Data.Set.Image
+import Mathlib.Data.SProd
 
 /-!
 # Sets in product and pi types
@@ -42,9 +43,9 @@ def prod (s : Set α) (t : Set β) : Set (α × β) :=
   { p | p.1 ∈ s ∧ p.2 ∈ t }
 #align set.prod Set.prod
 
--- This notation binds more strongly than (pre)images, unions and intersections.
-/-- The cartesian product `s ×ˢ t` is the set of `(a, b)` such that `a ∈ s` and `b ∈ t`. -/
-infixr:82 " ×ˢ " => Set.prod
+@[default_instance]
+instance instSProd : SProd (Set α) (Set β) (Set (α × β)) where
+  sprod := Set.prod
 
 theorem prod_eq (s : Set α) (t : Set β) : s ×ˢ t = Prod.fst ⁻¹' s ∩ Prod.snd ⁻¹' t :=
   rfl

chore: fix upper/lowercase in comments (#4360)

Run a non-interactive version of fix-comments.py on all files.
Go through the diff and manually add/discard/edit chunks.

27d257fc

Diff

@@ -37,7 +37,7 @@ section Prod
 
 variable {α β γ δ : Type _} {s s₁ s₂ : Set α} {t t₁ t₂ : Set β} {a : α} {b : β}
 
-/-- The cartesian product `prod s t` is the set of `(a, b)` such that `a ∈ s` and `b ∈ t`. -/
+/-- The cartesian product `Set.prod s t` is the set of `(a, b)` such that `a ∈ s` and `b ∈ t`. -/
 def prod (s : Set α) (t : Set β) : Set (α × β) :=
   { p | p.1 ∈ s ∧ p.2 ∈ t }
 #align set.prod Set.prod
@@ -631,7 +631,7 @@ section Pi
 
 variable {ι : Type _} {α β : ι → Type _} {s s₁ s₂ : Set ι} {t t₁ t₂ : ∀ i, Set (α i)} {i : ι}
 
-/-- Given an index set `ι` and a family of sets `t : Π i, set (α i)`, `pi s t`
+/-- Given an index set `ι` and a family of sets `t : Π i, Set (α i)`, `pi s t`
 is the set of dependent functions `f : Πa, π a` such that `f a` belongs to `t a`
 whenever `a ∈ s`. -/
 def pi (s : Set ι) (t : ∀ i, Set (α i)) : Set (∀ i, α i) :=

closes #3680, see https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Stepping.20through.20simp_rw/near/326712986

feat: implement intermediate state for simp_rw (#3738)

ff334843

Diff

@@ -420,7 +420,7 @@ theorem prod_eq_prod_iff :
 
 @[simp]
 theorem prod_eq_iff_eq (ht : t.Nonempty) : s ×ˢ t = s₁ ×ˢ t ↔ s = s₁ := by
-  simp_rw [prod_eq_prod_iff, ht.ne_empty, eq_self_iff_true, and_true_iff, or_iff_left_iff_imp,
+  simp_rw [prod_eq_prod_iff, ht.ne_empty, and_true_iff, or_iff_left_iff_imp,
     or_false_iff]
   rintro ⟨rfl, rfl⟩
   rfl

chore: fix #align lines (#3640)

This PR fixes two things:

Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

2b42dc7c

Diff

@@ -781,7 +781,6 @@ theorem pi_update_of_mem [DecidableEq ι] (hi : i ∈ s) (f : ∀ j, α j) (a :
         by rw [union_diff_self, union_eq_self_of_subset_left (singleton_subset_iff.2 hi)]
     _ = { x | x i ∈ t i a } ∩ (s \ {i}).pi fun j => t j (f j) :=
         by rw [union_pi, singleton_pi', update_same, pi_update_of_not_mem]; simp
-
 #align set.pi_update_of_mem Set.pi_update_of_mem
 
 theorem univ_pi_update [DecidableEq ι] {β : ∀ _, Type _} (i : ι) (f : ∀ j, α j) (a : α i)

chore: add missing #align statements (#1902)

This PR is the result of a slight variant on the following "algorithm"

take all mathlib 3 names, remove _ and make all uppercase letters into lowercase
take all mathlib 4 names, remove _ and make all uppercase letters into lowercase
look for matches, and create pairs (original_lean3_name, OriginalLean4Name)
for pairs that do not have an align statement:
- use Lean 4 to lookup the file + position of the Lean 4 name
- add an #align statement just before the next empty line
manually fix some tiny mistakes (e.g., empty lines in proofs might cause the #align statement to have been inserted too early)

b72bb858

Diff

@@ -555,8 +555,10 @@ theorem offDiag_eq_empty : s.offDiag = ∅ ↔ s.Subsingleton := by
 #align set.off_diag_eq_empty Set.offDiag_eq_empty
 
 alias offDiag_nonempty ↔ _ Nontrivial.offDiag_nonempty
+#align set.nontrivial.off_diag_nonempty Set.Nontrivial.offDiag_nonempty
 
 alias offDiag_nonempty ↔ _ Subsingleton.offDiag_eq_empty
+#align set.subsingleton.off_diag_eq_empty Set.Subsingleton.offDiag_eq_empty
 
 variable (s t)

leanprover-community/mathlib#16946

feat: synchronize with mathlib#16946 (#1833)

Co-authored-by: Chris Hughes <33847686+ChrisHughes24@users.noreply.github.com>

e7e9757f

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro, Johannes Hölzl, Patrick Massot
 
 ! This file was ported from Lean 3 source module data.set.prod
-! leanprover-community/mathlib commit 996b0ff959da753a555053a480f36e5f264d4207
+! leanprover-community/mathlib commit 27f315c5591c84687852f816d8ef31fe103d03de
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -514,6 +514,16 @@ theorem diag_preimage_prod_self (s : Set α) : (fun x => (x, x)) ⁻¹' s ×ˢ s
   inter_self s
 #align set.diag_preimage_prod_self Set.diag_preimage_prod_self
 
+theorem diag_image (s : Set α) : (fun x => (x, x)) '' s = diagonal α ∩ s ×ˢ s := by
+  ext x
+  constructor
+  · rintro ⟨x, hx, rfl⟩
+    exact ⟨rfl, hx, hx⟩
+  · obtain ⟨x, y⟩ := x
+    rintro ⟨rfl : x = y, h2x⟩
+    exact mem_image_of_mem _ h2x.1
+#align set.diag_image Set.diag_image
+
 end Diagonal
 
 section OffDiag

996b0ff9

Feat: add lemmas about Set.diagonal (#1438)

This is a partial forward-port of leanprover-community/mathlib#18111

11d5cd71

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro, Johannes Hölzl, Patrick Massot
 
 ! This file was ported from Lean 3 source module data.set.prod
-! leanprover-community/mathlib commit 2ed7e4aec72395b6a7c3ac4ac7873a7a43ead17c
+! leanprover-community/mathlib commit 996b0ff959da753a555053a480f36e5f264d4207
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -476,6 +476,10 @@ theorem mem_diagonal_iff {x : α × α} : x ∈ diagonal α ↔ x.1 = x.2 :=
   Iff.rfl
 #align set.mem_diagonal_iff Set.mem_diagonal_iff
 
+lemma diagonal_nonempty [Nonempty α] : (diagonal α).Nonempty :=
+Nonempty.elim ‹_› <| fun x => ⟨_, mem_diagonal x⟩
+#align set.diagonal_nonempty Set.diagonal_nonempty
+
 instance decidableMemDiagonal [h : DecidableEq α] (x : α × α) : Decidable (x ∈ diagonal α) :=
   h x.1 x.2
 #align set.decidable_mem_diagonal Set.decidableMemDiagonal
@@ -492,11 +496,13 @@ theorem range_diag : (range fun x => (x, x)) = diagonal α := by
   simp [diagonal, eq_comm]
 #align set.range_diag Set.range_diag
 
+theorem diagonal_subset_iff {s} : diagonal α ⊆ s ↔ ∀ x, (x, x) ∈ s := by
+  rw [← range_diag, range_subset_iff]
+#align set.diagonal_subset_iff Set.diagonal_subset_iff
+
 @[simp]
 theorem prod_subset_compl_diagonal_iff_disjoint : s ×ˢ t ⊆ diagonal αᶜ ↔ Disjoint s t :=
-  subset_compl_comm.trans <| by
-    simp_rw [← range_diag, range_subset_iff, disjoint_left, mem_compl_iff, prod_mk_mem_set_prod_eq,
-      not_and]
+  prod_subset_iff.trans disjoint_iff_forall_ne.symm
 #align set.prod_subset_compl_diagonal_iff_disjoint Set.prod_subset_compl_diagonal_iff_disjoint
 
 @[simp]

chore: format by line breaks (#1523)

During porting, I usually fix the desired format we seem to want for the line breaks around by with

awk '{do {{if (match($0, "^  by$") && length(p) < 98) {p=p " by";} else {if (NR!=1) {print p}; p=$0}}} while (getline == 1) if (getline==0) print p}' Mathlib/File/Im/Working/On.lean

I noticed there are some more files that slipped through.

This pull request is the result of running this command:

grep -lr "^  by\$" Mathlib | xargs -n 1 awk -i inplace '{do {{if (match($0, "^  by$") && length(p) < 98 && not (match(p, "^[ \t]*--"))) {p=p " by";} else {if (NR!=1) {print p}; p=$0}}} while (getline == 1) if (getline==0) print p}'

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

d6d859a7

Diff

@@ -729,8 +729,7 @@ theorem preimage_pi (s : Set ι) (t : ∀ i, Set (β i)) (f : ∀ i, α i → β
 
 theorem pi_if {p : ι → Prop} [h : DecidablePred p] (s : Set ι) (t₁ t₂ : ∀ i, Set (α i)) :
     (pi s fun i => if p i then t₁ i else t₂ i) =
-      pi ({ i ∈ s | p i }) t₁ ∩ pi ({ i ∈ s | ¬p i }) t₂ :=
-  by
+      pi ({ i ∈ s | p i }) t₁ ∩ pi ({ i ∈ s | ¬p i }) t₂ := by
   ext f
   refine' ⟨fun h => _, _⟩
   · constructor <;>

chore: remove iff_self from simp only after lean4#1933 (#1406)

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

72b23bd4

Diff

@@ -159,12 +159,12 @@ theorem prod_union : s ×ˢ (t₁ ∪ t₂) = s ×ˢ t₁ ∪ s ×ˢ t₂ := by
 
 theorem inter_prod : (s₁ ∩ s₂) ×ˢ t = s₁ ×ˢ t ∩ s₂ ×ˢ t := by
   ext ⟨x, y⟩
-  simp only [← and_and_right, mem_inter_iff, mem_prod, iff_self]
+  simp only [← and_and_right, mem_inter_iff, mem_prod]
 #align set.inter_prod Set.inter_prod
 
 theorem prod_inter : s ×ˢ (t₁ ∩ t₂) = s ×ˢ t₁ ∩ s ×ˢ t₂ := by
   ext ⟨x, y⟩
-  simp only [← and_and_left, mem_inter_iff, mem_prod, iff_self]
+  simp only [← and_and_left, mem_inter_iff, mem_prod]
 #align set.prod_inter Set.prod_inter
 
 theorem prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂) := by
@@ -321,7 +321,7 @@ theorem prod_nonempty_iff : (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty :=
 #align set.prod_nonempty_iff Set.prod_nonempty_iff
 
 theorem prod_eq_empty_iff : s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅ := by
-  simp only [not_nonempty_iff_eq_empty.symm, prod_nonempty_iff, not_and_or, iff_self]
+  simp only [not_nonempty_iff_eq_empty.symm, prod_nonempty_iff, not_and_or]
 #align set.prod_eq_empty_iff Set.prod_eq_empty_iff
 
 theorem prod_sub_preimage_iff {W : Set γ} {f : α × β → γ} :
@@ -644,7 +644,7 @@ theorem pi_mono (h : ∀ i ∈ s, t₁ i ⊆ t₂ i) : pi s t₁ ⊆ pi s t₂ :
 #align set.pi_mono Set.pi_mono
 
 theorem pi_inter_distrib : (s.pi fun i => t i ∩ t₁ i) = s.pi t ∩ s.pi t₁ :=
-  ext fun x => by simp only [forall_and, mem_pi, mem_inter_iff, iff_self]
+  ext fun x => by simp only [forall_and, mem_pi, mem_inter_iff]
 #align set.pi_inter_distrib Set.pi_inter_distrib
 
 theorem pi_congr (h : s₁ = s₂) (h' : ∀ i ∈ s₁, t₁ i = t₂ i) : s₁.pi t₁ = s₂.pi t₂ :=
@@ -688,7 +688,7 @@ theorem univ_pi_empty [h : Nonempty ι] : pi univ (fun _ => ∅ : ∀ i, Set (α
 
 @[simp]
 theorem disjoint_univ_pi : Disjoint (pi univ t₁) (pi univ t₂) ↔ ∃ i, Disjoint (t₁ i) (t₂ i) := by
-  simp only [disjoint_iff_inter_eq_empty, ← pi_inter_distrib, univ_pi_eq_empty_iff, iff_self]
+  simp only [disjoint_iff_inter_eq_empty, ← pi_inter_distrib, univ_pi_eq_empty_iff]
 #align set.disjoint_univ_pi Set.disjoint_univ_pi
 
 -- Porting note: Removing `simp` - LHS does not simplify

chore: Update SHAs (#1385)

Update SHAs after

2877afd7

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro, Johannes Hölzl, Patrick Massot
 
 ! This file was ported from Lean 3 source module data.set.prod
-! leanprover-community/mathlib commit fc2ed6f838ce7c9b7c7171e58d78eaf7b438fb0e
+! leanprover-community/mathlib commit 2ed7e4aec72395b6a7c3ac4ac7873a7a43ead17c
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

feat: implement basic version of tauto tactic (#1081)

Adds a basic version of the tauto tactic, mostly a line-by-line translation of the Lean 3 version.

As per this zulip discussion, makes tauto always-classical and eliminates tauto!.
Does not yet add any symmetry-based logic or the fancy union-find datastructure from https://github.com/leanprover-community/mathlib/pull/180.
Adds a andThenOnSubgoals tactic combinator in Mathlib.Tactic.Basic.

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

3f9ce172

Diff

@@ -577,12 +577,7 @@ theorem disjoint_diagonal_offDiag : Disjoint (diagonal α) s.offDiag :=
 theorem offDiag_inter : (s ∩ t).offDiag = s.offDiag ∩ t.offDiag :=
   ext fun x => by
     simp only [mem_offDiag, mem_inter_iff]
-    -- Porting note: was `tauto`
-    constructor
-    · rintro ⟨⟨h0, h1⟩, ⟨h2, h3⟩, h4⟩
-      refine ⟨⟨h0, h2, h4⟩, ⟨h1, h3, h4⟩⟩
-    · rintro ⟨⟨h0, h1, h2⟩, ⟨h3, h4, -⟩⟩
-      exact ⟨⟨h0, h3⟩, ⟨h1, h4⟩, h2⟩
+    tauto
 #align set.off_diag_inter Set.offDiag_inter
 
 variable {s t}

chore: update lean4/std4 (#1096)

a9a1f7d7

Diff

@@ -174,7 +174,7 @@ theorem prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×
 
 theorem disjoint_prod : Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂ := by
   simp_rw [disjoint_left, mem_prod, not_and_or, Prod.forall, and_imp, ← @forall_or_right α, ←
-    @forall_or_left β, ← @forall_or_right (_ ∈ s₁), ← @forall_or_left (_ ∈ t₁), iff_self]
+    @forall_or_left β, ← @forall_or_right (_ ∈ s₁), ← @forall_or_left (_ ∈ t₁)]
 #align set.disjoint_prod Set.disjoint_prod
 
 theorem insert_prod : insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t := by
@@ -416,7 +416,6 @@ theorem prod_eq_prod_iff :
   rw [prod_eq_prod_iff_of_nonempty h]
   rw [nonempty_iff_ne_empty, Ne.def, prod_eq_empty_iff] at h
   simp_rw [h, false_and_iff, or_false_iff]
-  rfl
 #align set.prod_eq_prod_iff Set.prod_eq_prod_iff
 
 @[simp]
@@ -497,7 +496,7 @@ theorem range_diag : (range fun x => (x, x)) = diagonal α := by
 theorem prod_subset_compl_diagonal_iff_disjoint : s ×ˢ t ⊆ diagonal αᶜ ↔ Disjoint s t :=
   subset_compl_comm.trans <| by
     simp_rw [← range_diag, range_subset_iff, disjoint_left, mem_compl_iff, prod_mk_mem_set_prod_eq,
-      not_and, iff_self]
+      not_and]
 #align set.prod_subset_compl_diagonal_iff_disjoint Set.prod_subset_compl_diagonal_iff_disjoint
 
 @[simp]