combinatorics.set_family.intersecting ⟷ Mathlib.Combinatorics.SetFamily.Intersecting

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

@@ -105,8 +105,8 @@ theorem intersecting_iff_pairwise_not_disjoint :
   · rintro rfl
     exact intersecting_singleton.1 h rfl
   · have := h.1.Eq ha hb (Classical.not_not.2 hab)
-    rw [this, disjoint_self] at hab 
-    rw [hab] at hb 
+    rw [this, disjoint_self] at hab
+    rw [hab] at hb
     exact
       h.2
         (eq_singleton_iff_unique_mem.2
@@ -234,8 +234,8 @@ theorem Intersecting.is_max_iff_card_eq (hs : (s : Set α).Intersecting) :
   refine' hs.insert _ fun b hb hab => ha.2 <| (hs.is_upper_set' h) hab.le_compl_left hb
   rintro rfl
   have := h {⊤} (by rw [coe_singleton]; exact intersecting_singleton.2 top_ne_bot)
-  rw [compl_bot] at ha 
-  rw [coe_eq_empty.1 ((hs.is_upper_set' h).not_top_mem.1 ha.2)] at this 
+  rw [compl_bot] at ha
+  rw [coe_eq_empty.1 ((hs.is_upper_set' h).not_top_mem.1 ha.2)] at this
   exact Finset.singleton_ne_empty _ (this <| empty_subset _).symm
 #align set.intersecting.is_max_iff_card_eq Set.Intersecting.is_max_iff_card_eq
 -/
@@ -245,13 +245,13 @@ theorem Intersecting.exists_card_eq (hs : (s : Set α).Intersecting) :
     ∃ t, s ⊆ t ∧ 2 * t.card = Fintype.card α ∧ (t : Set α).Intersecting :=
   by
   have := hs.card_le
-  rw [mul_comm, ← Nat.le_div_iff_mul_le' two_pos] at this 
+  rw [mul_comm, ← Nat.le_div_iff_mul_le' two_pos] at this
   revert hs
   refine' s.strong_downward_induction_on _ this
   rintro s ih hcard hs
   by_cases ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t
   · exact ⟨s, subset.rfl, hs.is_max_iff_card_eq.1 h, hs⟩
-  push_neg at h 
+  push_neg at h
   obtain ⟨t, ht, hst⟩ := h
   refine' (ih _ (_root_.ssubset_iff_subset_ne.2 hst) ht).imp fun u => And.imp_left hst.1.trans
   rw [Nat.le_div_iff_mul_le' two_pos, mul_comm]

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

@@ -137,7 +137,13 @@ theorem intersecting_iff_eq_empty_of_subsingleton [Subsingleton α] (s : Set α)
 #print Set.Intersecting.isUpperSet /-
 /-- Maximal intersecting families are upper sets. -/
 protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
-    (h : ∀ t : Set α, t.Intersecting → s ⊆ t → s = t) : IsUpperSet s := by classical
+    (h : ∀ t : Set α, t.Intersecting → s ⊆ t → s = t) : IsUpperSet s := by
+  classical
+  rintro a b hab ha
+  rw [h (insert b s) _ (subset_insert _ _)]
+  · exact mem_insert _ _
+  exact
+    hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
 #align set.intersecting.is_upper_set Set.Intersecting.isUpperSet
 -/
 
@@ -146,6 +152,12 @@ protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
 theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting)
     (h : ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) : IsUpperSet (s : Set α) := by
   classical
+  rintro a b hab ha
+  rw [h (insert b s) _ (Finset.subset_insert _ _)]
+  · exact mem_insert_self _ _
+  rw [coe_insert]
+  exact
+    hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
 #align set.intersecting.is_upper_set' Set.Intersecting.isUpperSet'
 -/
 
@@ -192,7 +204,10 @@ theorem Intersecting.disjoint_map_compl {s : Finset α} (hs : (s : Set α).Inter
 
 #print Set.Intersecting.card_le /-
 theorem Intersecting.card_le [Fintype α] {s : Finset α} (hs : (s : Set α).Intersecting) :
-    2 * s.card ≤ Fintype.card α := by classical
+    2 * s.card ≤ Fintype.card α := by
+  classical
+  refine' (s.disj_union _ hs.disjoint_map_compl).card_le_univ.trans_eq' _
+  rw [two_mul, card_disj_union, card_map]
 #align set.intersecting.card_le Set.Intersecting.card_le
 -/
 
@@ -203,6 +218,25 @@ variable [Nontrivial α] [Fintype α] {s : Finset α}
 theorem Intersecting.is_max_iff_card_eq (hs : (s : Set α).Intersecting) :
     (∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) ↔ 2 * s.card = Fintype.card α := by
   classical
+  refine'
+    ⟨fun h => _, fun h t ht hst =>
+      Finset.eq_of_subset_of_card_le hst <|
+        le_of_mul_le_mul_left (ht.card_le.trans_eq h.symm) two_pos⟩
+  suffices s.disj_union (s.map ⟨compl, compl_injective⟩) hs.disjoint_map_compl = Finset.univ by
+    rw [Fintype.card, ← this, two_mul, card_disj_union, card_map]
+  rw [← coe_eq_univ, disj_union_eq_union, coe_union, coe_map, Function.Embedding.coeFn_mk,
+    image_eq_preimage_of_inverse compl_compl compl_compl]
+  refine' eq_univ_of_forall fun a => _
+  simp_rw [mem_union, mem_preimage]
+  by_contra! ha
+  refine' s.ne_insert_of_not_mem _ ha.1 (h _ _ <| s.subset_insert _)
+  rw [coe_insert]
+  refine' hs.insert _ fun b hb hab => ha.2 <| (hs.is_upper_set' h) hab.le_compl_left hb
+  rintro rfl
+  have := h {⊤} (by rw [coe_singleton]; exact intersecting_singleton.2 top_ne_bot)
+  rw [compl_bot] at ha 
+  rw [coe_eq_empty.1 ((hs.is_upper_set' h).not_top_mem.1 ha.2)] at this 
+  exact Finset.singleton_ne_empty _ (this <| empty_subset _).symm
 #align set.intersecting.is_max_iff_card_eq Set.Intersecting.is_max_iff_card_eq
 -/
 

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

@@ -137,13 +137,7 @@ theorem intersecting_iff_eq_empty_of_subsingleton [Subsingleton α] (s : Set α)
 #print Set.Intersecting.isUpperSet /-
 /-- Maximal intersecting families are upper sets. -/
 protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
-    (h : ∀ t : Set α, t.Intersecting → s ⊆ t → s = t) : IsUpperSet s := by
-  classical
-  rintro a b hab ha
-  rw [h (insert b s) _ (subset_insert _ _)]
-  · exact mem_insert _ _
-  exact
-    hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
+    (h : ∀ t : Set α, t.Intersecting → s ⊆ t → s = t) : IsUpperSet s := by classical
 #align set.intersecting.is_upper_set Set.Intersecting.isUpperSet
 -/
 
@@ -152,12 +146,6 @@ protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
 theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting)
     (h : ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) : IsUpperSet (s : Set α) := by
   classical
-  rintro a b hab ha
-  rw [h (insert b s) _ (Finset.subset_insert _ _)]
-  · exact mem_insert_self _ _
-  rw [coe_insert]
-  exact
-    hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
 #align set.intersecting.is_upper_set' Set.Intersecting.isUpperSet'
 -/
 
@@ -204,10 +192,7 @@ theorem Intersecting.disjoint_map_compl {s : Finset α} (hs : (s : Set α).Inter
 
 #print Set.Intersecting.card_le /-
 theorem Intersecting.card_le [Fintype α] {s : Finset α} (hs : (s : Set α).Intersecting) :
-    2 * s.card ≤ Fintype.card α := by
-  classical
-  refine' (s.disj_union _ hs.disjoint_map_compl).card_le_univ.trans_eq' _
-  rw [two_mul, card_disj_union, card_map]
+    2 * s.card ≤ Fintype.card α := by classical
 #align set.intersecting.card_le Set.Intersecting.card_le
 -/
 
@@ -218,25 +203,6 @@ variable [Nontrivial α] [Fintype α] {s : Finset α}
 theorem Intersecting.is_max_iff_card_eq (hs : (s : Set α).Intersecting) :
     (∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) ↔ 2 * s.card = Fintype.card α := by
   classical
-  refine'
-    ⟨fun h => _, fun h t ht hst =>
-      Finset.eq_of_subset_of_card_le hst <|
-        le_of_mul_le_mul_left (ht.card_le.trans_eq h.symm) two_pos⟩
-  suffices s.disj_union (s.map ⟨compl, compl_injective⟩) hs.disjoint_map_compl = Finset.univ by
-    rw [Fintype.card, ← this, two_mul, card_disj_union, card_map]
-  rw [← coe_eq_univ, disj_union_eq_union, coe_union, coe_map, Function.Embedding.coeFn_mk,
-    image_eq_preimage_of_inverse compl_compl compl_compl]
-  refine' eq_univ_of_forall fun a => _
-  simp_rw [mem_union, mem_preimage]
-  by_contra! ha
-  refine' s.ne_insert_of_not_mem _ ha.1 (h _ _ <| s.subset_insert _)
-  rw [coe_insert]
-  refine' hs.insert _ fun b hb hab => ha.2 <| (hs.is_upper_set' h) hab.le_compl_left hb
-  rintro rfl
-  have := h {⊤} (by rw [coe_singleton]; exact intersecting_singleton.2 top_ne_bot)
-  rw [compl_bot] at ha 
-  rw [coe_eq_empty.1 ((hs.is_upper_set' h).not_top_mem.1 ha.2)] at this 
-  exact Finset.singleton_ne_empty _ (this <| empty_subset _).symm
 #align set.intersecting.is_max_iff_card_eq Set.Intersecting.is_max_iff_card_eq
 -/
 

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

@@ -228,7 +228,7 @@ theorem Intersecting.is_max_iff_card_eq (hs : (s : Set α).Intersecting) :
     image_eq_preimage_of_inverse compl_compl compl_compl]
   refine' eq_univ_of_forall fun a => _
   simp_rw [mem_union, mem_preimage]
-  by_contra' ha
+  by_contra! ha
   refine' s.ne_insert_of_not_mem _ ha.1 (h _ _ <| s.subset_insert _)
   rw [coe_insert]
   refine' hs.insert _ fun b hb hab => ha.2 <| (hs.is_upper_set' h) hab.le_compl_left hb

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

@@ -3,8 +3,8 @@ Copyright (c) 2022 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 -/
-import Mathbin.Data.Fintype.Card
-import Mathbin.Order.UpperLower.Basic
+import Data.Fintype.Card
+import Order.UpperLower.Basic
 
 #align_import combinatorics.set_family.intersecting from "leanprover-community/mathlib"@"0ebfdb71919ac6ca5d7fbc61a082fa2519556818"
 

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

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module combinatorics.set_family.intersecting
-! leanprover-community/mathlib commit 0ebfdb71919ac6ca5d7fbc61a082fa2519556818
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Fintype.Card
 import Mathbin.Order.UpperLower.Basic
 
+#align_import combinatorics.set_family.intersecting from "leanprover-community/mathlib"@"0ebfdb71919ac6ca5d7fbc61a082fa2519556818"
+
 /-!
 # Intersecting families
 

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

@@ -57,22 +57,29 @@ theorem Intersecting.mono (h : t ⊆ s) (hs : s.Intersecting) : t.Intersecting :
 #align set.intersecting.mono Set.Intersecting.mono
 -/
 
+#print Set.Intersecting.not_bot_mem /-
 theorem Intersecting.not_bot_mem (hs : s.Intersecting) : ⊥ ∉ s := fun h => hs h h disjoint_bot_left
 #align set.intersecting.not_bot_mem Set.Intersecting.not_bot_mem
+-/
 
+#print Set.Intersecting.ne_bot /-
 theorem Intersecting.ne_bot (hs : s.Intersecting) (ha : a ∈ s) : a ≠ ⊥ :=
   ne_of_mem_of_not_mem ha hs.not_bot_mem
 #align set.intersecting.ne_bot Set.Intersecting.ne_bot
+-/
 
 #print Set.intersecting_empty /-
 theorem intersecting_empty : (∅ : Set α).Intersecting := fun _ => False.elim
 #align set.intersecting_empty Set.intersecting_empty
 -/
 
+#print Set.intersecting_singleton /-
 @[simp]
 theorem intersecting_singleton : ({a} : Set α).Intersecting ↔ a ≠ ⊥ := by simp [intersecting]
 #align set.intersecting_singleton Set.intersecting_singleton
+-/
 
+#print Set.Intersecting.insert /-
 theorem Intersecting.insert (hs : s.Intersecting) (ha : a ≠ ⊥) (h : ∀ b ∈ s, ¬Disjoint a b) :
     (insert a s).Intersecting := by
   rintro b (rfl | hb) c (rfl | hc)
@@ -81,7 +88,9 @@ theorem Intersecting.insert (hs : s.Intersecting) (ha : a ≠ ⊥) (h : ∀ b 
   · exact fun H => h _ hb H.symm
   · exact hs hb hc
 #align set.intersecting.insert Set.Intersecting.insert
+-/
 
+#print Set.intersecting_insert /-
 theorem intersecting_insert :
     (insert a s).Intersecting ↔ s.Intersecting ∧ a ≠ ⊥ ∧ ∀ b ∈ s, ¬Disjoint a b :=
   ⟨fun h =>
@@ -89,7 +98,9 @@ theorem intersecting_insert :
       h (mem_insert _ _) <| mem_insert_of_mem _ hb⟩,
     fun h => h.1.insert h.2.1 h.2.2⟩
 #align set.intersecting_insert Set.intersecting_insert
+-/
 
+#print Set.intersecting_iff_pairwise_not_disjoint /-
 theorem intersecting_iff_pairwise_not_disjoint :
     s.Intersecting ↔ (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥} :=
   by
@@ -104,10 +115,13 @@ theorem intersecting_iff_pairwise_not_disjoint :
         (eq_singleton_iff_unique_mem.2
           ⟨hb, fun c hc => not_ne_iff.1 fun H => h.1 hb hc H.symm disjoint_bot_left⟩)
 #align set.intersecting_iff_pairwise_not_disjoint Set.intersecting_iff_pairwise_not_disjoint
+-/
 
+#print Set.Subsingleton.intersecting /-
 protected theorem Subsingleton.intersecting (hs : s.Subsingleton) : s.Intersecting ↔ s ≠ {⊥} :=
   intersecting_iff_pairwise_not_disjoint.trans <| and_iff_right <| hs.Pairwise _
 #align set.subsingleton.intersecting Set.Subsingleton.intersecting
+-/
 
 #print Set.intersecting_iff_eq_empty_of_subsingleton /-
 theorem intersecting_iff_eq_empty_of_subsingleton [Subsingleton α] (s : Set α) :
@@ -152,15 +166,19 @@ theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting
 
 end SemilatticeInf
 
+#print Set.Intersecting.exists_mem_set /-
 theorem Intersecting.exists_mem_set {𝒜 : Set (Set α)} (h𝒜 : 𝒜.Intersecting) {s t : Set α}
     (hs : s ∈ 𝒜) (ht : t ∈ 𝒜) : ∃ a, a ∈ s ∧ a ∈ t :=
   not_disjoint_iff.1 <| h𝒜 hs ht
 #align set.intersecting.exists_mem_set Set.Intersecting.exists_mem_set
+-/
 
+#print Set.Intersecting.exists_mem_finset /-
 theorem Intersecting.exists_mem_finset [DecidableEq α] {𝒜 : Set (Finset α)} (h𝒜 : 𝒜.Intersecting)
     {s t : Finset α} (hs : s ∈ 𝒜) (ht : t ∈ 𝒜) : ∃ a, a ∈ s ∧ a ∈ t :=
   not_disjoint_iff.1 <| disjoint_coe.Not.2 <| h𝒜 hs ht
 #align set.intersecting.exists_mem_finset Set.Intersecting.exists_mem_finset
+-/
 
 variable [BooleanAlgebra α]
 
@@ -176,6 +194,7 @@ theorem Intersecting.not_mem {s : Set α} (hs : s.Intersecting) {a : α} (ha : a
 #align set.intersecting.not_mem Set.Intersecting.not_mem
 -/
 
+#print Set.Intersecting.disjoint_map_compl /-
 theorem Intersecting.disjoint_map_compl {s : Finset α} (hs : (s : Set α).Intersecting) :
     Disjoint s (s.map ⟨compl, compl_injective⟩) :=
   by
@@ -184,6 +203,7 @@ theorem Intersecting.disjoint_map_compl {s : Finset α} (hs : (s : Set α).Inter
   obtain ⟨x, hx', rfl⟩ := mem_map.mp hxc
   exact hs.not_compl_mem hx' hx
 #align set.intersecting.disjoint_map_compl Set.Intersecting.disjoint_map_compl
+-/
 
 #print Set.Intersecting.card_le /-
 theorem Intersecting.card_le [Fintype α] {s : Finset α} (hs : (s : Set α).Intersecting) :

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

@@ -128,11 +128,11 @@ theorem intersecting_iff_eq_empty_of_subsingleton [Subsingleton α] (s : Set α)
 protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
     (h : ∀ t : Set α, t.Intersecting → s ⊆ t → s = t) : IsUpperSet s := by
   classical
-    rintro a b hab ha
-    rw [h (insert b s) _ (subset_insert _ _)]
-    · exact mem_insert _ _
-    exact
-      hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
+  rintro a b hab ha
+  rw [h (insert b s) _ (subset_insert _ _)]
+  · exact mem_insert _ _
+  exact
+    hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
 #align set.intersecting.is_upper_set Set.Intersecting.isUpperSet
 -/
 
@@ -141,12 +141,12 @@ protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
 theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting)
     (h : ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) : IsUpperSet (s : Set α) := by
   classical
-    rintro a b hab ha
-    rw [h (insert b s) _ (Finset.subset_insert _ _)]
-    · exact mem_insert_self _ _
-    rw [coe_insert]
-    exact
-      hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
+  rintro a b hab ha
+  rw [h (insert b s) _ (Finset.subset_insert _ _)]
+  · exact mem_insert_self _ _
+  rw [coe_insert]
+  exact
+    hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
 #align set.intersecting.is_upper_set' Set.Intersecting.isUpperSet'
 -/
 
@@ -189,8 +189,8 @@ theorem Intersecting.disjoint_map_compl {s : Finset α} (hs : (s : Set α).Inter
 theorem Intersecting.card_le [Fintype α] {s : Finset α} (hs : (s : Set α).Intersecting) :
     2 * s.card ≤ Fintype.card α := by
   classical
-    refine' (s.disj_union _ hs.disjoint_map_compl).card_le_univ.trans_eq' _
-    rw [two_mul, card_disj_union, card_map]
+  refine' (s.disj_union _ hs.disjoint_map_compl).card_le_univ.trans_eq' _
+  rw [two_mul, card_disj_union, card_map]
 #align set.intersecting.card_le Set.Intersecting.card_le
 -/
 
@@ -201,25 +201,25 @@ variable [Nontrivial α] [Fintype α] {s : Finset α}
 theorem Intersecting.is_max_iff_card_eq (hs : (s : Set α).Intersecting) :
     (∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) ↔ 2 * s.card = Fintype.card α := by
   classical
-    refine'
-      ⟨fun h => _, fun h t ht hst =>
-        Finset.eq_of_subset_of_card_le hst <|
-          le_of_mul_le_mul_left (ht.card_le.trans_eq h.symm) two_pos⟩
-    suffices s.disj_union (s.map ⟨compl, compl_injective⟩) hs.disjoint_map_compl = Finset.univ by
-      rw [Fintype.card, ← this, two_mul, card_disj_union, card_map]
-    rw [← coe_eq_univ, disj_union_eq_union, coe_union, coe_map, Function.Embedding.coeFn_mk,
-      image_eq_preimage_of_inverse compl_compl compl_compl]
-    refine' eq_univ_of_forall fun a => _
-    simp_rw [mem_union, mem_preimage]
-    by_contra' ha
-    refine' s.ne_insert_of_not_mem _ ha.1 (h _ _ <| s.subset_insert _)
-    rw [coe_insert]
-    refine' hs.insert _ fun b hb hab => ha.2 <| (hs.is_upper_set' h) hab.le_compl_left hb
-    rintro rfl
-    have := h {⊤} (by rw [coe_singleton]; exact intersecting_singleton.2 top_ne_bot)
-    rw [compl_bot] at ha 
-    rw [coe_eq_empty.1 ((hs.is_upper_set' h).not_top_mem.1 ha.2)] at this 
-    exact Finset.singleton_ne_empty _ (this <| empty_subset _).symm
+  refine'
+    ⟨fun h => _, fun h t ht hst =>
+      Finset.eq_of_subset_of_card_le hst <|
+        le_of_mul_le_mul_left (ht.card_le.trans_eq h.symm) two_pos⟩
+  suffices s.disj_union (s.map ⟨compl, compl_injective⟩) hs.disjoint_map_compl = Finset.univ by
+    rw [Fintype.card, ← this, two_mul, card_disj_union, card_map]
+  rw [← coe_eq_univ, disj_union_eq_union, coe_union, coe_map, Function.Embedding.coeFn_mk,
+    image_eq_preimage_of_inverse compl_compl compl_compl]
+  refine' eq_univ_of_forall fun a => _
+  simp_rw [mem_union, mem_preimage]
+  by_contra' ha
+  refine' s.ne_insert_of_not_mem _ ha.1 (h _ _ <| s.subset_insert _)
+  rw [coe_insert]
+  refine' hs.insert _ fun b hb hab => ha.2 <| (hs.is_upper_set' h) hab.le_compl_left hb
+  rintro rfl
+  have := h {⊤} (by rw [coe_singleton]; exact intersecting_singleton.2 top_ne_bot)
+  rw [compl_bot] at ha 
+  rw [coe_eq_empty.1 ((hs.is_upper_set' h).not_top_mem.1 ha.2)] at this 
+  exact Finset.singleton_ne_empty _ (this <| empty_subset _).symm
 #align set.intersecting.is_max_iff_card_eq Set.Intersecting.is_max_iff_card_eq
 -/
 
@@ -234,7 +234,7 @@ theorem Intersecting.exists_card_eq (hs : (s : Set α).Intersecting) :
   rintro s ih hcard hs
   by_cases ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t
   · exact ⟨s, subset.rfl, hs.is_max_iff_card_eq.1 h, hs⟩
-  push_neg  at h 
+  push_neg at h 
   obtain ⟨t, ht, hst⟩ := h
   refine' (ih _ (_root_.ssubset_iff_subset_ne.2 hst) ht).imp fun u => And.imp_left hst.1.trans
   rw [Nat.le_div_iff_mul_le' two_pos, mul_comm]

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

@@ -97,8 +97,8 @@ theorem intersecting_iff_pairwise_not_disjoint :
   · rintro rfl
     exact intersecting_singleton.1 h rfl
   · have := h.1.Eq ha hb (Classical.not_not.2 hab)
-    rw [this, disjoint_self] at hab
-    rw [hab] at hb
+    rw [this, disjoint_self] at hab 
+    rw [hab] at hb 
     exact
       h.2
         (eq_singleton_iff_unique_mem.2
@@ -217,8 +217,8 @@ theorem Intersecting.is_max_iff_card_eq (hs : (s : Set α).Intersecting) :
     refine' hs.insert _ fun b hb hab => ha.2 <| (hs.is_upper_set' h) hab.le_compl_left hb
     rintro rfl
     have := h {⊤} (by rw [coe_singleton]; exact intersecting_singleton.2 top_ne_bot)
-    rw [compl_bot] at ha
-    rw [coe_eq_empty.1 ((hs.is_upper_set' h).not_top_mem.1 ha.2)] at this
+    rw [compl_bot] at ha 
+    rw [coe_eq_empty.1 ((hs.is_upper_set' h).not_top_mem.1 ha.2)] at this 
     exact Finset.singleton_ne_empty _ (this <| empty_subset _).symm
 #align set.intersecting.is_max_iff_card_eq Set.Intersecting.is_max_iff_card_eq
 -/
@@ -228,13 +228,13 @@ theorem Intersecting.exists_card_eq (hs : (s : Set α).Intersecting) :
     ∃ t, s ⊆ t ∧ 2 * t.card = Fintype.card α ∧ (t : Set α).Intersecting :=
   by
   have := hs.card_le
-  rw [mul_comm, ← Nat.le_div_iff_mul_le' two_pos] at this
+  rw [mul_comm, ← Nat.le_div_iff_mul_le' two_pos] at this 
   revert hs
   refine' s.strong_downward_induction_on _ this
   rintro s ih hcard hs
   by_cases ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t
   · exact ⟨s, subset.rfl, hs.is_max_iff_card_eq.1 h, hs⟩
-  push_neg  at h
+  push_neg  at h 
   obtain ⟨t, ht, hst⟩ := h
   refine' (ih _ (_root_.ssubset_iff_subset_ne.2 hst) ht).imp fun u => And.imp_left hst.1.trans
   rw [Nat.le_div_iff_mul_le' two_pos, mul_comm]

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

@@ -43,15 +43,19 @@ section SemilatticeInf
 
 variable [SemilatticeInf α] [OrderBot α] {s t : Set α} {a b c : α}
 
+#print Set.Intersecting /-
 /-- A set family is intersecting if every pair of elements is non-disjoint. -/
 def Intersecting (s : Set α) : Prop :=
   ∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ s → ¬Disjoint a b
 #align set.intersecting Set.Intersecting
+-/
 
+#print Set.Intersecting.mono /-
 @[mono]
 theorem Intersecting.mono (h : t ⊆ s) (hs : s.Intersecting) : t.Intersecting := fun a ha b hb =>
   hs (h ha) (h hb)
 #align set.intersecting.mono Set.Intersecting.mono
+-/
 
 theorem Intersecting.not_bot_mem (hs : s.Intersecting) : ⊥ ∉ s := fun h => hs h h disjoint_bot_left
 #align set.intersecting.not_bot_mem Set.Intersecting.not_bot_mem
@@ -60,8 +64,10 @@ theorem Intersecting.ne_bot (hs : s.Intersecting) (ha : a ∈ s) : a ≠ ⊥ :=
   ne_of_mem_of_not_mem ha hs.not_bot_mem
 #align set.intersecting.ne_bot Set.Intersecting.ne_bot
 
+#print Set.intersecting_empty /-
 theorem intersecting_empty : (∅ : Set α).Intersecting := fun _ => False.elim
 #align set.intersecting_empty Set.intersecting_empty
+-/
 
 @[simp]
 theorem intersecting_singleton : ({a} : Set α).Intersecting ↔ a ≠ ⊥ := by simp [intersecting]
@@ -103,6 +109,7 @@ protected theorem Subsingleton.intersecting (hs : s.Subsingleton) : s.Intersecti
   intersecting_iff_pairwise_not_disjoint.trans <| and_iff_right <| hs.Pairwise _
 #align set.subsingleton.intersecting Set.Subsingleton.intersecting
 
+#print Set.intersecting_iff_eq_empty_of_subsingleton /-
 theorem intersecting_iff_eq_empty_of_subsingleton [Subsingleton α] (s : Set α) :
     s.Intersecting ↔ s = ∅ :=
   by
@@ -114,7 +121,9 @@ theorem intersecting_iff_eq_empty_of_subsingleton [Subsingleton α] (s : Set α)
   · rintro rfl
     exact (Set.singleton_nonempty _).ne_empty.symm
 #align set.intersecting_iff_eq_empty_of_subsingleton Set.intersecting_iff_eq_empty_of_subsingleton
+-/
 
+#print Set.Intersecting.isUpperSet /-
 /-- Maximal intersecting families are upper sets. -/
 protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
     (h : ∀ t : Set α, t.Intersecting → s ⊆ t → s = t) : IsUpperSet s := by
@@ -125,7 +134,9 @@ protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
     exact
       hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
 #align set.intersecting.is_upper_set Set.Intersecting.isUpperSet
+-/
 
+#print Set.Intersecting.isUpperSet' /-
 /-- Maximal intersecting families are upper sets. Finset version. -/
 theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting)
     (h : ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) : IsUpperSet (s : Set α) := by
@@ -137,6 +148,7 @@ theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting
     exact
       hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
 #align set.intersecting.is_upper_set' Set.Intersecting.isUpperSet'
+-/
 
 end SemilatticeInf
 

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

@@ -43,72 +43,30 @@ section SemilatticeInf
 
 variable [SemilatticeInf α] [OrderBot α] {s t : Set α} {a b c : α}
 
-/- warning: set.intersecting -> Set.Intersecting is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))], (Set.{u1} α) -> Prop
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))], (Set.{u1} α) -> Prop
-Case conversion may be inaccurate. Consider using '#align set.intersecting Set.Intersectingₓ'. -/
 /-- A set family is intersecting if every pair of elements is non-disjoint. -/
 def Intersecting (s : Set α) : Prop :=
   ∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ s → ¬Disjoint a b
 #align set.intersecting Set.Intersecting
 
-/- warning: set.intersecting.mono -> Set.Intersecting.mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {t : Set.{u1} α}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) t s) -> (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Set.Intersecting.{u1} α _inst_1 _inst_2 t)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {t : Set.{u1} α}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) t s) -> (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Set.Intersecting.{u1} α _inst_1 _inst_2 t)
-Case conversion may be inaccurate. Consider using '#align set.intersecting.mono Set.Intersecting.monoₓ'. -/
 @[mono]
 theorem Intersecting.mono (h : t ⊆ s) (hs : s.Intersecting) : t.Intersecting := fun a ha b hb =>
   hs (h ha) (h hb)
 #align set.intersecting.mono Set.Intersecting.mono
 
-/- warning: set.intersecting.not_bot_mem -> Set.Intersecting.not_bot_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)) s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)) s))
-Case conversion may be inaccurate. Consider using '#align set.intersecting.not_bot_mem Set.Intersecting.not_bot_memₓ'. -/
 theorem Intersecting.not_bot_mem (hs : s.Intersecting) : ⊥ ∉ s := fun h => hs h h disjoint_bot_left
 #align set.intersecting.not_bot_mem Set.Intersecting.not_bot_mem
 
-/- warning: set.intersecting.ne_bot -> Set.Intersecting.ne_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align set.intersecting.ne_bot Set.Intersecting.ne_botₓ'. -/
 theorem Intersecting.ne_bot (hs : s.Intersecting) (ha : a ∈ s) : a ≠ ⊥ :=
   ne_of_mem_of_not_mem ha hs.not_bot_mem
 #align set.intersecting.ne_bot Set.Intersecting.ne_bot
 
-/- warning: set.intersecting_empty -> Set.intersecting_empty is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))], Set.Intersecting.{u1} α _inst_1 _inst_2 (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))], Set.Intersecting.{u1} α _inst_1 _inst_2 (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α))
-Case conversion may be inaccurate. Consider using '#align set.intersecting_empty Set.intersecting_emptyₓ'. -/
 theorem intersecting_empty : (∅ : Set α).Intersecting := fun _ => False.elim
 #align set.intersecting_empty Set.intersecting_empty
 
-/- warning: set.intersecting_singleton -> Set.intersecting_singleton is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {a : α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a)) (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {a : α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a)) (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align set.intersecting_singleton Set.intersecting_singletonₓ'. -/
 @[simp]
 theorem intersecting_singleton : ({a} : Set α).Intersecting ↔ a ≠ ⊥ := by simp [intersecting]
 #align set.intersecting_singleton Set.intersecting_singleton
 
-/- warning: set.intersecting.insert -> Set.Intersecting.insert is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2))) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b))) -> (Set.Intersecting.{u1} α _inst_1 _inst_2 (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2))) -> (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b))) -> (Set.Intersecting.{u1} α _inst_1 _inst_2 (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a s))
-Case conversion may be inaccurate. Consider using '#align set.intersecting.insert Set.Intersecting.insertₓ'. -/
 theorem Intersecting.insert (hs : s.Intersecting) (ha : a ≠ ⊥) (h : ∀ b ∈ s, ¬Disjoint a b) :
     (insert a s).Intersecting := by
   rintro b (rfl | hb) c (rfl | hc)
@@ -118,12 +76,6 @@ theorem Intersecting.insert (hs : s.Intersecting) (ha : a ≠ ⊥) (h : ∀ b 
   · exact hs hb hc
 #align set.intersecting.insert Set.Intersecting.insert
 
-/- warning: set.intersecting_insert -> Set.intersecting_insert is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a s)) (And (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (And (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2))) (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a s)) (And (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (And (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2))) (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b)))))
-Case conversion may be inaccurate. Consider using '#align set.intersecting_insert Set.intersecting_insertₓ'. -/
 theorem intersecting_insert :
     (insert a s).Intersecting ↔ s.Intersecting ∧ a ≠ ⊥ ∧ ∀ b ∈ s, ¬Disjoint a b :=
   ⟨fun h =>
@@ -132,12 +84,6 @@ theorem intersecting_insert :
     fun h => h.1.insert h.2.1 h.2.2⟩
 #align set.intersecting_insert Set.intersecting_insert
 
-/- warning: set.intersecting_iff_pairwise_not_disjoint -> Set.intersecting_iff_pairwise_not_disjoint is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (And (Set.Pairwise.{u1} α s (fun (a : α) (b : α) => Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b))) (Ne.{succ u1} (Set.{u1} α) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (And (Set.Pairwise.{u1} α s (fun (a : α) (b : α) => Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b))) (Ne.{succ u1} (Set.{u1} α) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))))
-Case conversion may be inaccurate. Consider using '#align set.intersecting_iff_pairwise_not_disjoint Set.intersecting_iff_pairwise_not_disjointₓ'. -/
 theorem intersecting_iff_pairwise_not_disjoint :
     s.Intersecting ↔ (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥} :=
   by
@@ -153,22 +99,10 @@ theorem intersecting_iff_pairwise_not_disjoint :
           ⟨hb, fun c hc => not_ne_iff.1 fun H => h.1 hb hc H.symm disjoint_bot_left⟩)
 #align set.intersecting_iff_pairwise_not_disjoint Set.intersecting_iff_pairwise_not_disjoint
 
-/- warning: set.subsingleton.intersecting -> Set.Subsingleton.intersecting is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Subsingleton.{u1} α s) -> (Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (Ne.{succ u1} (Set.{u1} α) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Subsingleton.{u1} α s) -> (Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (Ne.{succ u1} (Set.{u1} α) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))))
-Case conversion may be inaccurate. Consider using '#align set.subsingleton.intersecting Set.Subsingleton.intersectingₓ'. -/
 protected theorem Subsingleton.intersecting (hs : s.Subsingleton) : s.Intersecting ↔ s ≠ {⊥} :=
   intersecting_iff_pairwise_not_disjoint.trans <| and_iff_right <| hs.Pairwise _
 #align set.subsingleton.intersecting Set.Subsingleton.intersecting
 
-/- warning: set.intersecting_iff_eq_empty_of_subsingleton -> Set.intersecting_iff_eq_empty_of_subsingleton is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] [_inst_3 : Subsingleton.{succ u1} α] (s : Set.{u1} α), Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (Eq.{succ u1} (Set.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] [_inst_3 : Subsingleton.{succ u1} α] (s : Set.{u1} α), Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (Eq.{succ u1} (Set.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)))
-Case conversion may be inaccurate. Consider using '#align set.intersecting_iff_eq_empty_of_subsingleton Set.intersecting_iff_eq_empty_of_subsingletonₓ'. -/
 theorem intersecting_iff_eq_empty_of_subsingleton [Subsingleton α] (s : Set α) :
     s.Intersecting ↔ s = ∅ :=
   by
@@ -181,12 +115,6 @@ theorem intersecting_iff_eq_empty_of_subsingleton [Subsingleton α] (s : Set α)
     exact (Set.singleton_nonempty _).ne_empty.symm
 #align set.intersecting_iff_eq_empty_of_subsingleton Set.intersecting_iff_eq_empty_of_subsingleton
 
-/- warning: set.intersecting.is_upper_set -> Set.Intersecting.isUpperSet is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (forall (t : Set.{u1} α), (Set.Intersecting.{u1} α _inst_1 _inst_2 t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s t) -> (Eq.{succ u1} (Set.{u1} α) s t)) -> (IsUpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) s)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (forall (t : Set.{u1} α), (Set.Intersecting.{u1} α _inst_1 _inst_2 t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s t) -> (Eq.{succ u1} (Set.{u1} α) s t)) -> (IsUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) s)
-Case conversion may be inaccurate. Consider using '#align set.intersecting.is_upper_set Set.Intersecting.isUpperSetₓ'. -/
 /-- Maximal intersecting families are upper sets. -/
 protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
     (h : ∀ t : Set α, t.Intersecting → s ⊆ t → s = t) : IsUpperSet s := by
@@ -198,12 +126,6 @@ protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
       hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
 #align set.intersecting.is_upper_set Set.Intersecting.isUpperSet
 
-/- warning: set.intersecting.is_upper_set' -> Set.Intersecting.isUpperSet' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Finset.{u1} α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) -> (forall (t : Finset.{u1} α), (Set.Intersecting.{u1} α _inst_1 _inst_2 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) t)) -> (HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.hasSubset.{u1} α) s t) -> (Eq.{succ u1} (Finset.{u1} α) s t)) -> (IsUpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Finset.{u1} α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 (Finset.toSet.{u1} α s)) -> (forall (t : Finset.{u1} α), (Set.Intersecting.{u1} α _inst_1 _inst_2 (Finset.toSet.{u1} α t)) -> (HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.instHasSubsetFinset.{u1} α) s t) -> (Eq.{succ u1} (Finset.{u1} α) s t)) -> (IsUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) (Finset.toSet.{u1} α s))
-Case conversion may be inaccurate. Consider using '#align set.intersecting.is_upper_set' Set.Intersecting.isUpperSet'ₓ'. -/
 /-- Maximal intersecting families are upper sets. Finset version. -/
 theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting)
     (h : ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) : IsUpperSet (s : Set α) := by
@@ -218,23 +140,11 @@ theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting
 
 end SemilatticeInf
 
-/- warning: set.intersecting.exists_mem_set -> Set.Intersecting.exists_mem_set is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {𝒜 : Set.{u1} (Set.{u1} α)}, (Set.Intersecting.{u1} (Set.{u1} α) (Lattice.toSemilatticeInf.{u1} (Set.{u1} α) (CompleteLattice.toLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.completeBooleanAlgebra.{u1} α)))))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} (Set.{u1} α) (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} (Set.{u1} α) (Set.booleanAlgebra.{u1} α))) 𝒜) -> (forall {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) s 𝒜) -> (Membership.Mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.hasMem.{u1} (Set.{u1} α)) t 𝒜) -> (Exists.{succ u1} α (fun (a : α) => And (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a t))))
-but is expected to have type
-  forall {α : Type.{u1}} {𝒜 : Set.{u1} (Set.{u1} α)}, (Set.Intersecting.{u1} (Set.{u1} α) (Lattice.toSemilatticeInf.{u1} (Set.{u1} α) (CompleteLattice.toLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{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} α) (CompleteLattice.toLattice.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α))))))))) (CompleteLattice.toBoundedOrder.{u1} (Set.{u1} α) (Order.Coframe.toCompleteLattice.{u1} (Set.{u1} α) (CompleteDistribLattice.toCoframe.{u1} (Set.{u1} α) (CompleteBooleanAlgebra.toCompleteDistribLattice.{u1} (Set.{u1} α) (Set.instCompleteBooleanAlgebraSet.{u1} α)))))) 𝒜) -> (forall {s : Set.{u1} α} {t : Set.{u1} α}, (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) s 𝒜) -> (Membership.mem.{u1, u1} (Set.{u1} α) (Set.{u1} (Set.{u1} α)) (Set.instMembershipSet.{u1} (Set.{u1} α)) t 𝒜) -> (Exists.{succ u1} α (fun (a : α) => And (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a t))))
-Case conversion may be inaccurate. Consider using '#align set.intersecting.exists_mem_set Set.Intersecting.exists_mem_setₓ'. -/
 theorem Intersecting.exists_mem_set {𝒜 : Set (Set α)} (h𝒜 : 𝒜.Intersecting) {s t : Set α}
     (hs : s ∈ 𝒜) (ht : t ∈ 𝒜) : ∃ a, a ∈ s ∧ a ∈ t :=
   not_disjoint_iff.1 <| h𝒜 hs ht
 #align set.intersecting.exists_mem_set Set.Intersecting.exists_mem_set
 
-/- warning: set.intersecting.exists_mem_finset -> Set.Intersecting.exists_mem_finset is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] {𝒜 : Set.{u1} (Finset.{u1} α)}, (Set.Intersecting.{u1} (Finset.{u1} α) (Lattice.toSemilatticeInf.{u1} (Finset.{u1} α) (Finset.lattice.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Finset.orderBot.{u1} α) 𝒜) -> (forall {s : Finset.{u1} α} {t : Finset.{u1} α}, (Membership.Mem.{u1, u1} (Finset.{u1} α) (Set.{u1} (Finset.{u1} α)) (Set.hasMem.{u1} (Finset.{u1} α)) s 𝒜) -> (Membership.Mem.{u1, u1} (Finset.{u1} α) (Set.{u1} (Finset.{u1} α)) (Set.hasMem.{u1} (Finset.{u1} α)) t 𝒜) -> (Exists.{succ u1} α (fun (a : α) => And (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a s) (Membership.Mem.{u1, u1} α (Finset.{u1} α) (Finset.hasMem.{u1} α) a t))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] {𝒜 : Set.{u1} (Finset.{u1} α)}, (Set.Intersecting.{u1} (Finset.{u1} α) (Lattice.toSemilatticeInf.{u1} (Finset.{u1} α) (Finset.instLatticeFinset.{u1} α (fun (a : α) (b : α) => _inst_1 a b))) (Finset.instOrderBotFinsetToLEToPreorderPartialOrder.{u1} α) 𝒜) -> (forall {s : Finset.{u1} α} {t : Finset.{u1} α}, (Membership.mem.{u1, u1} (Finset.{u1} α) (Set.{u1} (Finset.{u1} α)) (Set.instMembershipSet.{u1} (Finset.{u1} α)) s 𝒜) -> (Membership.mem.{u1, u1} (Finset.{u1} α) (Set.{u1} (Finset.{u1} α)) (Set.instMembershipSet.{u1} (Finset.{u1} α)) t 𝒜) -> (Exists.{succ u1} α (fun (a : α) => And (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a s) (Membership.mem.{u1, u1} α (Finset.{u1} α) (Finset.instMembershipFinset.{u1} α) a t))))
-Case conversion may be inaccurate. Consider using '#align set.intersecting.exists_mem_finset Set.Intersecting.exists_mem_finsetₓ'. -/
 theorem Intersecting.exists_mem_finset [DecidableEq α] {𝒜 : Set (Finset α)} (h𝒜 : 𝒜.Intersecting)
     {s t : Finset α} (hs : s ∈ 𝒜) (ht : t ∈ 𝒜) : ∃ a, a ∈ s ∧ a ∈ t :=
   not_disjoint_iff.1 <| disjoint_coe.Not.2 <| h𝒜 hs ht
@@ -254,12 +164,6 @@ theorem Intersecting.not_mem {s : Set α} (hs : s.Intersecting) {a : α} (ha : a
 #align set.intersecting.not_mem Set.Intersecting.not_mem
 -/
 
-/- warning: set.intersecting.disjoint_map_compl -> Set.Intersecting.disjoint_map_compl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} α] {s : Finset.{u1} α}, (Set.Intersecting.{u1} α (Lattice.toSemilatticeInf.{u1} α (GeneralizedCoheytingAlgebra.toLattice.{u1} α (GeneralizedBooleanAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} α _inst_1)))) (GeneralizedBooleanAlgebra.toOrderBot.{u1} α (BooleanAlgebra.toGeneralizedBooleanAlgebra.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) -> (Disjoint.{u1} (Finset.{u1} α) (Finset.partialOrder.{u1} α) (Finset.orderBot.{u1} α) s (Finset.map.{u1, u1} α α (Function.Embedding.mk.{succ u1, succ u1} α α (HasCompl.compl.{u1} α (BooleanAlgebra.toHasCompl.{u1} α _inst_1)) (compl_injective.{u1} α _inst_1)) s))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : BooleanAlgebra.{u1} α] {s : Finset.{u1} α}, (Set.Intersecting.{u1} α (Lattice.toSemilatticeInf.{u1} α (GeneralizedCoheytingAlgebra.toLattice.{u1} α (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BiheytingAlgebra.toCoheytingAlgebra.{u1} α (BooleanAlgebra.toBiheytingAlgebra.{u1} α _inst_1))))) (BoundedOrder.toOrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (GeneralizedCoheytingAlgebra.toLattice.{u1} α (CoheytingAlgebra.toGeneralizedCoheytingAlgebra.{u1} α (BiheytingAlgebra.toCoheytingAlgebra.{u1} α (BooleanAlgebra.toBiheytingAlgebra.{u1} α _inst_1)))))))) (BooleanAlgebra.toBoundedOrder.{u1} α _inst_1)) (Finset.toSet.{u1} α s)) -> (Disjoint.{u1} (Finset.{u1} α) (Finset.partialOrder.{u1} α) (Finset.instOrderBotFinsetToLEToPreorderPartialOrder.{u1} α) s (Finset.map.{u1, u1} α α (Function.Embedding.mk.{succ u1, succ u1} α α (HasCompl.compl.{u1} α (BooleanAlgebra.toHasCompl.{u1} α _inst_1)) (compl_injective.{u1} α _inst_1)) s))
-Case conversion may be inaccurate. Consider using '#align set.intersecting.disjoint_map_compl Set.Intersecting.disjoint_map_complₓ'. -/
 theorem Intersecting.disjoint_map_compl {s : Finset α} (hs : (s : Set α).Intersecting) :
     Disjoint s (s.map ⟨compl, compl_injective⟩) :=
   by

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

@@ -300,11 +300,7 @@ theorem Intersecting.is_max_iff_card_eq (hs : (s : Set α).Intersecting) :
     rw [coe_insert]
     refine' hs.insert _ fun b hb hab => ha.2 <| (hs.is_upper_set' h) hab.le_compl_left hb
     rintro rfl
-    have :=
-      h {⊤}
-        (by
-          rw [coe_singleton]
-          exact intersecting_singleton.2 top_ne_bot)
+    have := h {⊤} (by rw [coe_singleton]; exact intersecting_singleton.2 top_ne_bot)
     rw [compl_bot] at ha
     rw [coe_eq_empty.1 ((hs.is_upper_set' h).not_top_mem.1 ha.2)] at this
     exact Finset.singleton_ne_empty _ (this <| empty_subset _).symm

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

@@ -43,23 +43,31 @@ section SemilatticeInf
 
 variable [SemilatticeInf α] [OrderBot α] {s t : Set α} {a b c : α}
 
-#print Set.Intersecting /-
+/- warning: set.intersecting -> Set.Intersecting is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))], (Set.{u1} α) -> Prop
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))], (Set.{u1} α) -> Prop
+Case conversion may be inaccurate. Consider using '#align set.intersecting Set.Intersectingₓ'. -/
 /-- A set family is intersecting if every pair of elements is non-disjoint. -/
 def Intersecting (s : Set α) : Prop :=
   ∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ s → ¬Disjoint a b
 #align set.intersecting Set.Intersecting
--/
 
-#print Set.Intersecting.mono /-
+/- warning: set.intersecting.mono -> Set.Intersecting.mono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {t : Set.{u1} α}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) t s) -> (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Set.Intersecting.{u1} α _inst_1 _inst_2 t)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {t : Set.{u1} α}, (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) t s) -> (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Set.Intersecting.{u1} α _inst_1 _inst_2 t)
+Case conversion may be inaccurate. Consider using '#align set.intersecting.mono Set.Intersecting.monoₓ'. -/
 @[mono]
 theorem Intersecting.mono (h : t ⊆ s) (hs : s.Intersecting) : t.Intersecting := fun a ha b hb =>
   hs (h ha) (h hb)
 #align set.intersecting.mono Set.Intersecting.mono
--/
 
 /- warning: set.intersecting.not_bot_mem -> Set.Intersecting.not_bot_mem is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)) s))
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Not (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)) s))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Not (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)) s))
 Case conversion may be inaccurate. Consider using '#align set.intersecting.not_bot_mem Set.Intersecting.not_bot_memₓ'. -/
@@ -68,7 +76,7 @@ theorem Intersecting.not_bot_mem (hs : s.Intersecting) : ⊥ ∉ s := fun h => h
 
 /- warning: set.intersecting.ne_bot -> Set.Intersecting.ne_bot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a s) -> (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a s) -> (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align set.intersecting.ne_bot Set.Intersecting.ne_botₓ'. -/
@@ -76,14 +84,18 @@ theorem Intersecting.ne_bot (hs : s.Intersecting) (ha : a ∈ s) : a ≠ ⊥ :=
   ne_of_mem_of_not_mem ha hs.not_bot_mem
 #align set.intersecting.ne_bot Set.Intersecting.ne_bot
 
-#print Set.intersecting_empty /-
+/- warning: set.intersecting_empty -> Set.intersecting_empty is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))], Set.Intersecting.{u1} α _inst_1 _inst_2 (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))], Set.Intersecting.{u1} α _inst_1 _inst_2 (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α))
+Case conversion may be inaccurate. Consider using '#align set.intersecting_empty Set.intersecting_emptyₓ'. -/
 theorem intersecting_empty : (∅ : Set α).Intersecting := fun _ => False.elim
 #align set.intersecting_empty Set.intersecting_empty
--/
 
 /- warning: set.intersecting_singleton -> Set.intersecting_singleton is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {a : α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a)) (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {a : α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) a)) (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {a : α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) a)) (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align set.intersecting_singleton Set.intersecting_singletonₓ'. -/
@@ -93,7 +105,7 @@ theorem intersecting_singleton : ({a} : Set α).Intersecting ↔ a ≠ ⊥ := by
 
 /- warning: set.intersecting.insert -> Set.Intersecting.insert is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2))) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b))) -> (Set.Intersecting.{u1} α _inst_1 _inst_2 (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a s))
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2))) -> (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b))) -> (Set.Intersecting.{u1} α _inst_1 _inst_2 (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a s))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2))) -> (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b))) -> (Set.Intersecting.{u1} α _inst_1 _inst_2 (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a s))
 Case conversion may be inaccurate. Consider using '#align set.intersecting.insert Set.Intersecting.insertₓ'. -/
@@ -108,7 +120,7 @@ theorem Intersecting.insert (hs : s.Intersecting) (ha : a ≠ ⊥) (h : ∀ b 
 
 /- warning: set.intersecting_insert -> Set.intersecting_insert is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a s)) (And (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (And (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2))) (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b)))))
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a s)) (And (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (And (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2))) (forall (b : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) b s) -> (Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b)))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α} {a : α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a s)) (And (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (And (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2))) (forall (b : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) b s) -> (Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b)))))
 Case conversion may be inaccurate. Consider using '#align set.intersecting_insert Set.intersecting_insertₓ'. -/
@@ -122,7 +134,7 @@ theorem intersecting_insert :
 
 /- warning: set.intersecting_iff_pairwise_not_disjoint -> Set.intersecting_iff_pairwise_not_disjoint is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (And (Set.Pairwise.{u1} α s (fun (a : α) (b : α) => Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b))) (Ne.{succ u1} (Set.{u1} α) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))))
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (And (Set.Pairwise.{u1} α s (fun (a : α) (b : α) => Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b))) (Ne.{succ u1} (Set.{u1} α) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (And (Set.Pairwise.{u1} α s (fun (a : α) (b : α) => Not (Disjoint.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1) _inst_2 a b))) (Ne.{succ u1} (Set.{u1} α) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))))
 Case conversion may be inaccurate. Consider using '#align set.intersecting_iff_pairwise_not_disjoint Set.intersecting_iff_pairwise_not_disjointₓ'. -/
@@ -143,7 +155,7 @@ theorem intersecting_iff_pairwise_not_disjoint :
 
 /- warning: set.subsingleton.intersecting -> Set.Subsingleton.intersecting is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Subsingleton.{u1} α s) -> (Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (Ne.{succ u1} (Set.{u1} α) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))))
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Subsingleton.{u1} α s) -> (Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (Ne.{succ u1} (Set.{u1} α) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.hasSingleton.{u1} α) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Subsingleton.{u1} α s) -> (Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (Ne.{succ u1} (Set.{u1} α) s (Singleton.singleton.{u1, u1} α (Set.{u1} α) (Set.instSingletonSet.{u1} α) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) _inst_2)))))
 Case conversion may be inaccurate. Consider using '#align set.subsingleton.intersecting Set.Subsingleton.intersectingₓ'. -/
@@ -151,7 +163,12 @@ protected theorem Subsingleton.intersecting (hs : s.Subsingleton) : s.Intersecti
   intersecting_iff_pairwise_not_disjoint.trans <| and_iff_right <| hs.Pairwise _
 #align set.subsingleton.intersecting Set.Subsingleton.intersecting
 
-#print Set.intersecting_iff_eq_empty_of_subsingleton /-
+/- warning: set.intersecting_iff_eq_empty_of_subsingleton -> Set.intersecting_iff_eq_empty_of_subsingleton is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] [_inst_3 : Subsingleton.{succ u1} α] (s : Set.{u1} α), Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (Eq.{succ u1} (Set.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.hasEmptyc.{u1} α)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] [_inst_3 : Subsingleton.{succ u1} α] (s : Set.{u1} α), Iff (Set.Intersecting.{u1} α _inst_1 _inst_2 s) (Eq.{succ u1} (Set.{u1} α) s (EmptyCollection.emptyCollection.{u1} (Set.{u1} α) (Set.instEmptyCollectionSet.{u1} α)))
+Case conversion may be inaccurate. Consider using '#align set.intersecting_iff_eq_empty_of_subsingleton Set.intersecting_iff_eq_empty_of_subsingletonₓ'. -/
 theorem intersecting_iff_eq_empty_of_subsingleton [Subsingleton α] (s : Set α) :
     s.Intersecting ↔ s = ∅ :=
   by
@@ -163,9 +180,13 @@ theorem intersecting_iff_eq_empty_of_subsingleton [Subsingleton α] (s : Set α)
   · rintro rfl
     exact (Set.singleton_nonempty _).ne_empty.symm
 #align set.intersecting_iff_eq_empty_of_subsingleton Set.intersecting_iff_eq_empty_of_subsingleton
--/
 
-#print Set.Intersecting.isUpperSet /-
+/- warning: set.intersecting.is_upper_set -> Set.Intersecting.isUpperSet is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (forall (t : Set.{u1} α), (Set.Intersecting.{u1} α _inst_1 _inst_2 t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.hasSubset.{u1} α) s t) -> (Eq.{succ u1} (Set.{u1} α) s t)) -> (IsUpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) s)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Set.{u1} α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 s) -> (forall (t : Set.{u1} α), (Set.Intersecting.{u1} α _inst_1 _inst_2 t) -> (HasSubset.Subset.{u1} (Set.{u1} α) (Set.instHasSubsetSet.{u1} α) s t) -> (Eq.{succ u1} (Set.{u1} α) s t)) -> (IsUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) s)
+Case conversion may be inaccurate. Consider using '#align set.intersecting.is_upper_set Set.Intersecting.isUpperSetₓ'. -/
 /-- Maximal intersecting families are upper sets. -/
 protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
     (h : ∀ t : Set α, t.Intersecting → s ⊆ t → s = t) : IsUpperSet s := by
@@ -176,9 +197,13 @@ protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
     exact
       hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
 #align set.intersecting.is_upper_set Set.Intersecting.isUpperSet
--/
 
-#print Set.Intersecting.isUpperSet' /-
+/- warning: set.intersecting.is_upper_set' -> Set.Intersecting.isUpperSet' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Finset.{u1} α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s)) -> (forall (t : Finset.{u1} α), (Set.Intersecting.{u1} α _inst_1 _inst_2 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) t)) -> (HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.hasSubset.{u1} α) s t) -> (Eq.{succ u1} (Finset.{u1} α) s t)) -> (IsUpperSet.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} α) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} α) (Set.{u1} α) (Finset.Set.hasCoeT.{u1} α))) s))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : SemilatticeInf.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1)))] {s : Finset.{u1} α}, (Set.Intersecting.{u1} α _inst_1 _inst_2 (Finset.toSet.{u1} α s)) -> (forall (t : Finset.{u1} α), (Set.Intersecting.{u1} α _inst_1 _inst_2 (Finset.toSet.{u1} α t)) -> (HasSubset.Subset.{u1} (Finset.{u1} α) (Finset.instHasSubsetFinset.{u1} α) s t) -> (Eq.{succ u1} (Finset.{u1} α) s t)) -> (IsUpperSet.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α _inst_1))) (Finset.toSet.{u1} α s))
+Case conversion may be inaccurate. Consider using '#align set.intersecting.is_upper_set' Set.Intersecting.isUpperSet'ₓ'. -/
 /-- Maximal intersecting families are upper sets. Finset version. -/
 theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting)
     (h : ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) : IsUpperSet (s : Set α) := by
@@ -190,7 +215,6 @@ theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting
     exact
       hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
 #align set.intersecting.is_upper_set' Set.Intersecting.isUpperSet'
--/
 
 end SemilatticeInf
 

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

To fit with the "please try harder" convention of ! tactics.

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

@@ -183,7 +183,7 @@ theorem Intersecting.is_max_iff_card_eq (hs : (s : Set α).Intersecting) :
       image_eq_preimage_of_inverse compl_compl compl_compl]
     refine' eq_univ_of_forall fun a => _
     simp_rw [mem_union, mem_preimage]
-    by_contra' ha
+    by_contra! ha
     refine' s.ne_insert_of_not_mem _ ha.1 (h _ _ <| s.subset_insert _)
     rw [coe_insert]
     refine' hs.insert _ fun b hb hab => ha.2 <| (hs.isUpperSet' h) hab.le_compl_left hb

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

This has nice performance benefits.

@@ -29,7 +29,7 @@ This file defines intersecting families and proves their basic properties.
 
 open Finset
 
-variable {α : Type _}
+variable {α : Type*}
 
 namespace Set
 

Otherwise code like

theorem ContMDiffWithinAt.mythm (h : x ∈ insert y s) : _ = _

interprets insert as ContMDiffWithinAt.insert, not Insert.insert.

@@ -61,8 +61,8 @@ theorem intersecting_empty : (∅ : Set α).Intersecting := fun _ => False.elim
 theorem intersecting_singleton : ({a} : Set α).Intersecting ↔ a ≠ ⊥ := by simp [Intersecting]
 #align set.intersecting_singleton Set.intersecting_singleton
 
-theorem Intersecting.insert (hs : s.Intersecting) (ha : a ≠ ⊥) (h : ∀ b ∈ s, ¬Disjoint a b) :
-    (insert a s).Intersecting := by
+protected theorem Intersecting.insert (hs : s.Intersecting) (ha : a ≠ ⊥)
+    (h : ∀ b ∈ s, ¬Disjoint a b) : (insert a s).Intersecting := by
   rintro b (rfl | hb) c (rfl | hc)
   · rwa [disjoint_self]
   · exact h _ hc

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module combinatorics.set_family.intersecting
-! leanprover-community/mathlib commit d90e4e186f1d18e375dcd4e5b5f6364b01cb3e46
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Fintype.Card
 import Mathlib.Order.UpperLower.Basic
 
+#align_import combinatorics.set_family.intersecting from "leanprover-community/mathlib"@"d90e4e186f1d18e375dcd4e5b5f6364b01cb3e46"
+
 /-!
 # Intersecting families
 

Changes are of the form

• some_tactic at h⊢ -> some_tactic at h ⊢
• some_tactic at h -> some_tactic at h

@@ -206,7 +206,7 @@ theorem Intersecting.exists_card_eq (hs : (s : Set α).Intersecting) :
   rintro s ih _hcard hs
   by_cases h : ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t
   · exact ⟨s, Subset.rfl, hs.is_max_iff_card_eq.1 h, hs⟩
-  push_neg  at h
+  push_neg at h
   obtain ⟨t, ht, hst⟩ := h
   refine' (ih _ (_root_.ssubset_iff_subset_ne.2 hst) ht).imp fun u => And.imp_left hst.1.trans
   rw [Nat.le_div_iff_mul_le' two_pos, mul_comm]

@@ -204,7 +204,7 @@ theorem Intersecting.exists_card_eq (hs : (s : Set α).Intersecting) :
   revert hs
   refine' s.strongDownwardInductionOn _ this
   rintro s ih _hcard hs
-  by_cases ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t
+  by_cases h : ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t
   · exact ⟨s, Subset.rfl, hs.is_max_iff_card_eq.1 h, hs⟩
   push_neg  at h
   obtain ⟨t, ht, hst⟩ := h

Restore most of the mono attribute now that #1740 is merged.

I think I got all of the monos.

@@ -45,7 +45,7 @@ def Intersecting (s : Set α) : Prop :=
   ∀ ⦃a⦄, a ∈ s → ∀ ⦃b⦄, b ∈ s → ¬Disjoint a b
 #align set.intersecting Set.Intersecting
 
--- porting note: todo: restore @[mono]
+@[mono]
 theorem Intersecting.mono (h : t ⊆ s) (hs : s.Intersecting) : t.Intersecting := fun _a ha _b hb =>
   hs (h ha) (h hb)
 #align set.intersecting.mono Set.Intersecting.mono

@@ -81,28 +81,18 @@ theorem intersecting_insert :
     fun h => h.1.insert h.2.1 h.2.2⟩
 #align set.intersecting_insert Set.intersecting_insert
 
--- Porting note: I can't make the old proof work.
 theorem intersecting_iff_pairwise_not_disjoint :
     s.Intersecting ↔ (s.Pairwise fun a b => ¬Disjoint a b) ∧ s ≠ {⊥} := by
   refine' ⟨fun h => ⟨fun a ha b hb _ => h ha hb, _⟩, fun h a ha b hb hab => _⟩
   · rintro rfl
     exact intersecting_singleton.1 h rfl
---  old proof:
---  · have := h.1.Eq ha hb (Classical.not_not.2 hab)
---    rw [this, disjoint_self] at hab
---    rw [hab] at hb
---    exact
---      h.2
---        (eq_singleton_iff_unique_mem.2
---          ⟨hb, fun c hc => not_ne_iff.1 fun H => h.1 hb hc H.symm disjoint_bot_left⟩)
-  · suffices : ⊥ ∈ s
-    · refine' h.2 (eq_singleton_iff_unique_mem.2 ⟨this, _⟩)
-      exact fun c hc => not_not.1 fun not => h.1 hc this not disjoint_bot_right
-    · apply (Or.elim (eq_bot_or_bot_lt a))
-      · exact fun h => h ▸ ha
-      · intro a_lt_bot
-        have a_ne_b := hab.ne (bot_lt_iff_ne_bot.1 a_lt_bot)
-        exact (False.elim (h.1 ha hb a_ne_b hab))
+  have := h.1.eq ha hb (Classical.not_not.2 hab)
+  rw [this, disjoint_self] at hab
+  rw [hab] at hb
+  exact
+    h.2
+      (eq_singleton_iff_unique_mem.2
+        ⟨hb, fun c hc => not_ne_iff.1 fun H => h.1 hb hc H.symm disjoint_bot_left⟩)
 #align set.intersecting_iff_pairwise_not_disjoint Set.intersecting_iff_pairwise_not_disjoint
 
 protected theorem Subsingleton.intersecting (hs : s.Subsingleton) : s.Intersecting ↔ s ≠ {⊥} :=
@@ -132,7 +122,7 @@ protected theorem Intersecting.isUpperSet (hs : s.Intersecting)
 #align set.intersecting.is_upper_set Set.Intersecting.isUpperSet
 
 /-- Maximal intersecting families are upper sets. Finset version. -/
-theorem Intersecting.is_upper_set' {s : Finset α} (hs : (s : Set α).Intersecting)
+theorem Intersecting.isUpperSet' {s : Finset α} (hs : (s : Set α).Intersecting)
     (h : ∀ t : Finset α, (t : Set α).Intersecting → s ⊆ t → s = t) : IsUpperSet (s : Set α) := by
   classical
     rintro a b hab ha
@@ -141,7 +131,7 @@ theorem Intersecting.is_upper_set' {s : Finset α} (hs : (s : Set α).Intersecti
     rw [coe_insert]
     exact
       hs.insert (mt (eq_bot_mono hab) <| hs.ne_bot ha) fun c hc hbc => hs ha hc <| hbc.mono_left hab
-#align set.intersecting.is_upper_set' Set.Intersecting.is_upper_set'
+#align set.intersecting.is_upper_set' Set.Intersecting.isUpperSet'
 
 end SemilatticeInf
 
@@ -199,15 +189,11 @@ theorem Intersecting.is_max_iff_card_eq (hs : (s : Set α).Intersecting) :
     by_contra' ha
     refine' s.ne_insert_of_not_mem _ ha.1 (h _ _ <| s.subset_insert _)
     rw [coe_insert]
-    refine' hs.insert _ fun b hb hab => ha.2 <| (hs.is_upper_set' h) hab.le_compl_left hb
+    refine' hs.insert _ fun b hb hab => ha.2 <| (hs.isUpperSet' h) hab.le_compl_left hb
     rintro rfl
-    have :=
-      h {⊤}
-        (by
-          rw [coe_singleton]
-          exact intersecting_singleton.2 top_ne_bot)
+    have := h {⊤} (by rw [coe_singleton]; exact intersecting_singleton.2 top_ne_bot)
     rw [compl_bot] at ha
-    rw [coe_eq_empty.1 ((hs.is_upper_set' h).not_top_mem.1 ha.2)] at this
+    rw [coe_eq_empty.1 ((hs.isUpperSet' h).not_top_mem.1 ha.2)] at this
     exact Finset.singleton_ne_empty _ (this <| Finset.empty_subset _).symm
 #align set.intersecting.is_max_iff_card_eq Set.Intersecting.is_max_iff_card_eq
 
@@ -228,4 +214,3 @@ theorem Intersecting.exists_card_eq (hs : (s : Set α).Intersecting) :
 #align set.intersecting.exists_card_eq Set.Intersecting.exists_card_eq
 
 end Set
-

Mostly renaming. Re-write a proof where I can't make the old one work.