l3lab/ntp-mathlib huggingface dataset:
/-- **Kleitman's theorem**. An intersecting family on `n` elements contains at most `2ⁿ⁻¹` sets, and
each further intersecting family takes at most half of the sets that are in no previous family. -/
theorem Finset.card_biUnion_le_of_intersecting (s : Finset ι) (f : ι → Finset (Finset α))
    (hf : ∀ i ∈ s, (f i : Set (Finset α)).Intersecting) :
    (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card) := by
  have : DecidableEq ι := by
    classical
    infer_instance
  obtain hs | hs := le_total (Fintype.card α) s.card
  · rw [tsub_eq_zero_of_le hs, pow_zero]
    refine' (card_le_of_subset <| biUnion_subset.2 fun i hi a ha ↦
      mem_compl.2 <| not_mem_singleton.2 <| (hf _ hi).ne_bot ha).trans_eq _
    rw [card_compl, Fintype.card_finset, card_singleton]
  induction' s using Finset.cons_induction with i s hi ih generalizing f
  · simp
  set f' : ι → Finset (Finset α) :=
    fun j ↦ if hj : j ∈ cons i s hi then (hf j hj).exists_card_eq.choose else ∅
  have hf₁ : ∀ j, j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * (f' j).card =
      2 ^ Fintype.card α ∧ (f' j : Set (Finset α)).Intersecting := by
    rintro j hj
    

Proof state:
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
this : DecidableEq ι
i : ι
s : Finset ι
hi : i ∉ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ i ∈ s, Set.Intersecting ↑(f i)) →
      card s ≤ Fintype.card α → card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
f : ι → Finset (Finset α)
hf : ∀ i_1 ∈ cons i s hi, Set.Intersecting ↑(f i_1)
hs : card (cons i s hi) ≤ Fintype.card α
f' : ι → Finset (Finset α) :=
  fun j =>
    if hj : j ∈ cons i s hi then
      Exists.choose (_ : ∃ t, f j ⊆ t ∧ 2 * card t = Fintype.card (Finset α) ∧ Set.Intersecting ↑t)
    else ∅
j : ι
hj : j ∈ cons i s hi
⊢ f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)

Next tactic:
simp_rw [dif_pos hj, ← Fintype.card_finset]
/-- **Kleitman's theorem**. An intersecting family on `n` elements contains at most `2ⁿ⁻¹` sets, and
each further intersecting family takes at most half of the sets that are in no previous family. -/
theorem Finset.card_biUnion_le_of_intersecting (s : Finset ι) (f : ι → Finset (Finset α))
    (hf : ∀ i ∈ s, (f i : Set (Finset α)).Intersecting) :
    (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card) := by
  have : DecidableEq ι := by
    classical
    infer_instance
  obtain hs | hs := le_total (Fintype.card α) s.card
  · rw [tsub_eq_zero_of_le hs, pow_zero]
    refine' (card_le_of_subset <| biUnion_subset.2 fun i hi a ha ↦
      mem_compl.2 <| not_mem_singleton.2 <| (hf _ hi).ne_bot ha).trans_eq _
    rw [card_compl, Fintype.card_finset, card_singleton]
  induction' s using Finset.cons_induction with i s hi ih generalizing f
  · simp
  set f' : ι → Finset (Finset α) :=
    fun j ↦ if hj : j ∈ cons i s hi then (hf j hj).exists_card_eq.choose else ∅
  have hf₁ : ∀ j, j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * (f' j).card =
      2 ^ Fintype.card α ∧ (f' j : Set (Finset α)).Intersecting := by
    rintro j hj
    simp_rw [dif_pos hj, ← Fintype.card_finset]
    

Proof state:
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
this : DecidableEq ι
i : ι
s : Finset ι
hi : i ∉ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ i ∈ s, Set.Intersecting ↑(f i)) →
      card s ≤ Fintype.card α → card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
f : ι → Finset (Finset α)
hf : ∀ i_1 ∈ cons i s hi, Set.Intersecting ↑(f i_1)
hs : card (cons i s hi) ≤ Fintype.card α
f' : ι → Finset (Finset α) :=
  fun j =>
    if hj : j ∈ cons i s hi then
      Exists.choose (_ : ∃ t, f j ⊆ t ∧ 2 * card t = Fintype.card (Finset α) ∧ Set.Intersecting ↑t)
    else ∅
j : ι
hj : j ∈ cons i s hi
⊢ f j ⊆ Exists.choose (_ : ∃ t, f j ⊆ t ∧ 2 * card t = Fintype.card (Finset α) ∧ Set.Intersecting ↑t) ∧
    2 * card (Exists.choose (_ : ∃ t, f j ⊆ t ∧ 2 * card t = Fintype.card (Finset α) ∧ Set.Intersecting ↑t)) =
        Fintype.card (Finset α) ∧
      Set.Intersecting ↑(Exists.choose (_ : ∃ t, f j ⊆ t ∧ 2 * card t = Fintype.card (Finset α) ∧ Set.Intersecting ↑t))

Next tactic:
exact Classical.choose_spec (hf j hj).exists_card_eq
/-- **Kleitman's theorem**. An intersecting family on `n` elements contains at most `2ⁿ⁻¹` sets, and
each further intersecting family takes at most half of the sets that are in no previous family. -/
theorem Finset.card_biUnion_le_of_intersecting (s : Finset ι) (f : ι → Finset (Finset α))
    (hf : ∀ i ∈ s, (f i : Set (Finset α)).Intersecting) :
    (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card) := by
  have : DecidableEq ι := by
    classical
    infer_instance
  obtain hs | hs := le_total (Fintype.card α) s.card
  · rw [tsub_eq_zero_of_le hs, pow_zero]
    refine' (card_le_of_subset <| biUnion_subset.2 fun i hi a ha ↦
      mem_compl.2 <| not_mem_singleton.2 <| (hf _ hi).ne_bot ha).trans_eq _
    rw [card_compl, Fintype.card_finset, card_singleton]
  induction' s using Finset.cons_induction with i s hi ih generalizing f
  · simp
  set f' : ι → Finset (Finset α) :=
    fun j ↦ if hj : j ∈ cons i s hi then (hf j hj).exists_card_eq.choose else ∅
  have hf₁ : ∀ j, j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * (f' j).card =
      2 ^ Fintype.card α ∧ (f' j : Set (Finset α)).Intersecting := by
    rintro j hj
    simp_rw [dif_pos hj, ← Fintype.card_finset]
    exact Classical.choose_spec (hf j hj).exists_card_eq
  

Proof state:
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
this : DecidableEq ι
i : ι
s : Finset ι
hi : i ∉ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ i ∈ s, Set.Intersecting ↑(f i)) →
      card s ≤ Fintype.card α → card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
f : ι → Finset (Finset α)
hf : ∀ i_1 ∈ cons i s hi, Set.Intersecting ↑(f i_1)
hs : card (cons i s hi) ≤ Fintype.card α
f' : ι → Finset (Finset α) :=
  fun j =>
    if hj : j ∈ cons i s hi then
      Exists.choose (_ : ∃ t, f j ⊆ t ∧ 2 * card t = Fintype.card (Finset α) ∧ Set.Intersecting ↑t)
    else ∅
hf₁ : ∀ j ∈ cons i s hi, f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
⊢ card (Finset.biUnion (cons i s hi) f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi))

Next tactic:
have hf₂ : ∀ j, j ∈ cons i s hi → IsUpperSet (f' j : Set (Finset α)) := by
    refine' fun j hj ↦ (hf₁ _ hj).2.2.isUpperSet' ((hf₁ _ hj).2.2.is_max_iff_card_eq.2 _)
    rw [Fintype.card_finset]
    exact (hf₁ _ hj).2.1
/-- **Kleitman's theorem**. An intersecting family on `n` elements contains at most `2ⁿ⁻¹` sets, and
each further intersecting family takes at most half of the sets that are in no previous family. -/
theorem Finset.card_biUnion_le_of_intersecting (s : Finset ι) (f : ι → Finset (Finset α))
    (hf : ∀ i ∈ s, (f i : Set (Finset α)).Intersecting) :
    (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card) := by
  have : DecidableEq ι := by
    classical
    infer_instance
  obtain hs | hs := le_total (Fintype.card α) s.card
  · rw [tsub_eq_zero_of_le hs, pow_zero]
    refine' (card_le_of_subset <| biUnion_subset.2 fun i hi a ha ↦
      mem_compl.2 <| not_mem_singleton.2 <| (hf _ hi).ne_bot ha).trans_eq _
    rw [card_compl, Fintype.card_finset, card_singleton]
  induction' s using Finset.cons_induction with i s hi ih generalizing f
  · simp
  set f' : ι → Finset (Finset α) :=
    fun j ↦ if hj : j ∈ cons i s hi then (hf j hj).exists_card_eq.choose else ∅
  have hf₁ : ∀ j, j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * (f' j).card =
      2 ^ Fintype.card α ∧ (f' j : Set (Finset α)).Intersecting := by
    rintro j hj
    simp_rw [dif_pos hj, ← Fintype.card_finset]
    exact Classical.choose_spec (hf j hj).exists_card_eq
  have hf₂ : ∀ j, j ∈ cons i s hi → IsUpperSet (f' j : Set (Finset α)) := by
    

Proof state:
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
this : DecidableEq ι
i : ι
s : Finset ι
hi : i ∉ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ i ∈ s, Set.Intersecting ↑(f i)) →
      card s ≤ Fintype.card α → card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
f : ι → Finset (Finset α)
hf : ∀ i_1 ∈ cons i s hi, Set.Intersecting ↑(f i_1)
hs : card (cons i s hi) ≤ Fintype.card α
f' : ι → Finset (Finset α) :=
  fun j =>
    if hj : j ∈ cons i s hi then
      Exists.choose (_ : ∃ t, f j ⊆ t ∧ 2 * card t = Fintype.card (Finset α) ∧ Set.Intersecting ↑t)
    else ∅
hf₁ : ∀ j ∈ cons i s hi, f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
⊢ ∀ j ∈ cons i s hi, IsUpperSet ↑(f' j)

Next tactic:
refine' fun j hj ↦ (hf₁ _ hj).2.2.isUpperSet' ((hf₁ _ hj).2.2.is_max_iff_card_eq.2 _)
/-- **Kleitman's theorem**. An intersecting family on `n` elements contains at most `2ⁿ⁻¹` sets, and
each further intersecting family takes at most half of the sets that are in no previous family. -/
theorem Finset.card_biUnion_le_of_intersecting (s : Finset ι) (f : ι → Finset (Finset α))
    (hf : ∀ i ∈ s, (f i : Set (Finset α)).Intersecting) :
    (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card) := by
  have : DecidableEq ι := by
    classical
    infer_instance
  obtain hs | hs := le_total (Fintype.card α) s.card
  · rw [tsub_eq_zero_of_le hs, pow_zero]
    refine' (card_le_of_subset <| biUnion_subset.2 fun i hi a ha ↦
      mem_compl.2 <| not_mem_singleton.2 <| (hf _ hi).ne_bot ha).trans_eq _
    rw [card_compl, Fintype.card_finset, card_singleton]
  induction' s using Finset.cons_induction with i s hi ih generalizing f
  · simp
  set f' : ι → Finset (Finset α) :=
    fun j ↦ if hj : j ∈ cons i s hi then (hf j hj).exists_card_eq.choose else ∅
  have hf₁ : ∀ j, j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * (f' j).card =
      2 ^ Fintype.card α ∧ (f' j : Set (Finset α)).Intersecting := by
    rintro j hj
    simp_rw [dif_pos hj, ← Fintype.card_finset]
    exact Classical.choose_spec (hf j hj).exists_card_eq
  have hf₂ : ∀ j, j ∈ cons i s hi → IsUpperSet (f' j : Set (Finset α)) := by
    refine' fun j hj ↦ (hf₁ _ hj).2.2.isUpperSet' ((hf₁ _ hj).2.2.is_max_iff_card_eq.2 _)
    

Proof state:
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
this : DecidableEq ι
i : ι
s : Finset ι
hi : i ∉ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ i ∈ s, Set.Intersecting ↑(f i)) →
      card s ≤ Fintype.card α → card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
f : ι → Finset (Finset α)
hf : ∀ i_1 ∈ cons i s hi, Set.Intersecting ↑(f i_1)
hs : card (cons i s hi) ≤ Fintype.card α
f' : ι → Finset (Finset α) :=
  fun j =>
    if hj : j ∈ cons i s hi then
      Exists.choose (_ : ∃ t, f j ⊆ t ∧ 2 * card t = Fintype.card (Finset α) ∧ Set.Intersecting ↑t)
    else ∅
hf₁ : ∀ j ∈ cons i s hi, f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
j : ι
hj : j ∈ cons i s hi
⊢ 2 * card (f' j) = Fintype.card (Finset α)

Next tactic:
rw [Fintype.card_finset]
/-- **Kleitman's theorem**. An intersecting family on `n` elements contains at most `2ⁿ⁻¹` sets, and
each further intersecting family takes at most half of the sets that are in no previous family. -/
theorem Finset.card_biUnion_le_of_intersecting (s : Finset ι) (f : ι → Finset (Finset α))
    (hf : ∀ i ∈ s, (f i : Set (Finset α)).Intersecting) :
    (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card) := by
  have : DecidableEq ι := by
    classical
    infer_instance
  obtain hs | hs := le_total (Fintype.card α) s.card
  · rw [tsub_eq_zero_of_le hs, pow_zero]
    refine' (card_le_of_subset <| biUnion_subset.2 fun i hi a ha ↦
      mem_compl.2 <| not_mem_singleton.2 <| (hf _ hi).ne_bot ha).trans_eq _
    rw [card_compl, Fintype.card_finset, card_singleton]
  induction' s using Finset.cons_induction with i s hi ih generalizing f
  · simp
  set f' : ι → Finset (Finset α) :=
    fun j ↦ if hj : j ∈ cons i s hi then (hf j hj).exists_card_eq.choose else ∅
  have hf₁ : ∀ j, j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * (f' j).card =
      2 ^ Fintype.card α ∧ (f' j : Set (Finset α)).Intersecting := by
    rintro j hj
    simp_rw [dif_pos hj, ← Fintype.card_finset]
    exact Classical.choose_spec (hf j hj).exists_card_eq
  have hf₂ : ∀ j, j ∈ cons i s hi → IsUpperSet (f' j : Set (Finset α)) := by
    refine' fun j hj ↦ (hf₁ _ hj).2.2.isUpperSet' ((hf₁ _ hj).2.2.is_max_iff_card_eq.2 _)
    rw [Fintype.card_finset]
    

Proof state:
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
this : DecidableEq ι
i : ι
s : Finset ι
hi : i ∉ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ i ∈ s, Set.Intersecting ↑(f i)) →
      card s ≤ Fintype.card α → card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
f : ι → Finset (Finset α)
hf : ∀ i_1 ∈ cons i s hi, Set.Intersecting ↑(f i_1)
hs : card (cons i s hi) ≤ Fintype.card α
f' : ι → Finset (Finset α) :=
  fun j =>
    if hj : j ∈ cons i s hi then
      Exists.choose (_ : ∃ t, f j ⊆ t ∧ 2 * card t = Fintype.card (Finset α) ∧ Set.Intersecting ↑t)
    else ∅
hf₁ : ∀ j ∈ cons i s hi, f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
j : ι
hj : j ∈ cons i s hi
⊢ 2 * card (f' j) = 2 ^ Fintype.card α

Next tactic:
exact (hf₁ _ hj).2.1
/-- **Kleitman's theorem**. An intersecting family on `n` elements contains at most `2ⁿ⁻¹` sets, and
each further intersecting family takes at most half of the sets that are in no previous family. -/
theorem Finset.card_biUnion_le_of_intersecting (s : Finset ι) (f : ι → Finset (Finset α))
    (hf : ∀ i ∈ s, (f i : Set (Finset α)).Intersecting) :
    (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card) := by
  have : DecidableEq ι := by
    classical
    infer_instance
  obtain hs | hs := le_total (Fintype.card α) s.card
  · rw [tsub_eq_zero_of_le hs, pow_zero]
    refine' (card_le_of_subset <| biUnion_subset.2 fun i hi a ha ↦
      mem_compl.2 <| not_mem_singleton.2 <| (hf _ hi).ne_bot ha).trans_eq _
    rw [card_compl, Fintype.card_finset, card_singleton]
  induction' s using Finset.cons_induction with i s hi ih generalizing f
  · simp
  set f' : ι → Finset (Finset α) :=
    fun j ↦ if hj : j ∈ cons i s hi then (hf j hj).exists_card_eq.choose else ∅
  have hf₁ : ∀ j, j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * (f' j).card =
      2 ^ Fintype.card α ∧ (f' j : Set (Finset α)).Intersecting := by
    rintro j hj
    simp_rw [dif_pos hj, ← Fintype.card_finset]
    exact Classical.choose_spec (hf j hj).exists_card_eq
  have hf₂ : ∀ j, j ∈ cons i s hi → IsUpperSet (f' j : Set (Finset α)) := by
    refine' fun j hj ↦ (hf₁ _ hj).2.2.isUpperSet' ((hf₁ _ hj).2.2.is_max_iff_card_eq.2 _)
    rw [Fintype.card_finset]
    exact (hf₁ _ hj).2.1
  

Proof state:
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
this : DecidableEq ι
i : ι
s : Finset ι
hi : i ∉ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ i ∈ s, Set.Intersecting ↑(f i)) →
      card s ≤ Fintype.card α → card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
f : ι → Finset (Finset α)
hf : ∀ i_1 ∈ cons i s hi, Set.Intersecting ↑(f i_1)
hs : card (cons i s hi) ≤ Fintype.card α
f' : ι → Finset (Finset α) :=
  fun j =>
    if hj : j ∈ cons i s hi then
      Exists.choose (_ : ∃ t, f j ⊆ t ∧ 2 * card t = Fintype.card (Finset α) ∧ Set.Intersecting ↑t)
    else ∅
hf₁ : ∀ j ∈ cons i s hi, f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ j ∈ cons i s hi, IsUpperSet ↑(f' j)
⊢ card (Finset.biUnion (cons i s hi) f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi))

Next tactic:
refine' (card_le_of_subset <| biUnion_mono fun j hj ↦ (hf₁ _ hj).1).trans _
/-- **Kleitman's theorem**. An intersecting family on `n` elements contains at most `2ⁿ⁻¹` sets, and
each further intersecting family takes at most half of the sets that are in no previous family. -/
theorem Finset.card_biUnion_le_of_intersecting (s : Finset ι) (f : ι → Finset (Finset α))
    (hf : ∀ i ∈ s, (f i : Set (Finset α)).Intersecting) :
    (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card) := by
  have : DecidableEq ι := by
    classical
    infer_instance
  obtain hs | hs := le_total (Fintype.card α) s.card
  · rw [tsub_eq_zero_of_le hs, pow_zero]
    refine' (card_le_of_subset <| biUnion_subset.2 fun i hi a ha ↦
      mem_compl.2 <| not_mem_singleton.2 <| (hf _ hi).ne_bot ha).trans_eq _
    rw [card_compl, Fintype.card_finset, card_singleton]
  induction' s using Finset.cons_induction with i s hi ih generalizing f
  · simp
  set f' : ι → Finset (Finset α) :=
    fun j ↦ if hj : j ∈ cons i s hi then (hf j hj).exists_card_eq.choose else ∅
  have hf₁ : ∀ j, j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * (f' j).card =
      2 ^ Fintype.card α ∧ (f' j : Set (Finset α)).Intersecting := by
    rintro j hj
    simp_rw [dif_pos hj, ← Fintype.card_finset]
    exact Classical.choose_spec (hf j hj).exists_card_eq
  have hf₂ : ∀ j, j ∈ cons i s hi → IsUpperSet (f' j : Set (Finset α)) := by
    refine' fun j hj ↦ (hf₁ _ hj).2.2.isUpperSet' ((hf₁ _ hj).2.2.is_max_iff_card_eq.2 _)
    rw [Fintype.card_finset]
    exact (hf₁ _ hj).2.1
  refine' (card_le_of_subset <| biUnion_mono fun j hj ↦ (hf₁ _ hj).1).trans _
  

Proof state:
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
this : DecidableEq ι
i : ι
s : Finset ι
hi : i ∉ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ i ∈ s, Set.Intersecting ↑(f i)) →
      card s ≤ Fintype.card α → card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
f : ι → Finset (Finset α)
hf : ∀ i_1 ∈ cons i s hi, Set.Intersecting ↑(f i_1)
hs : card (cons i s hi) ≤ Fintype.card α
f' : ι → Finset (Finset α) :=
  fun j =>
    if hj : j ∈ cons i s hi then
      Exists.choose (_ : ∃ t, f j ⊆ t ∧ 2 * card t = Fintype.card (Finset α) ∧ Set.Intersecting ↑t)
    else ∅
hf₁ : ∀ j ∈ cons i s hi, f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ j ∈ cons i s hi, IsUpperSet ↑(f' j)
⊢ card (Finset.biUnion (cons i s hi) fun j => f' j) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi))

Next tactic:
nth_rw 1 [cons_eq_insert i]
/-- **Kleitman's theorem**. An intersecting family on `n` elements contains at most `2ⁿ⁻¹` sets, and
each further intersecting family takes at most half of the sets that are in no previous family. -/
theorem Finset.card_biUnion_le_of_intersecting (s : Finset ι) (f : ι → Finset (Finset α))
    (hf : ∀ i ∈ s, (f i : Set (Finset α)).Intersecting) :
    (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card) := by
  have : DecidableEq ι := by
    classical
    infer_instance
  obtain hs | hs := le_total (Fintype.card α) s.card
  · rw [tsub_eq_zero_of_le hs, pow_zero]
    refine' (card_le_of_subset <| biUnion_subset.2 fun i hi a ha ↦
      mem_compl.2 <| not_mem_singleton.2 <| (hf _ hi).ne_bot ha).trans_eq _
    rw [card_compl, Fintype.card_finset, card_singleton]
  induction' s using Finset.cons_induction with i s hi ih generalizing f
  · simp
  set f' : ι → Finset (Finset α) :=
    fun j ↦ if hj : j ∈ cons i s hi then (hf j hj).exists_card_eq.choose else ∅
  have hf₁ : ∀ j, j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * (f' j).card =
      2 ^ Fintype.card α ∧ (f' j : Set (Finset α)).Intersecting := by
    rintro j hj
    simp_rw [dif_pos hj, ← Fintype.card_finset]
    exact Classical.choose_spec (hf j hj).exists_card_eq
  have hf₂ : ∀ j, j ∈ cons i s hi → IsUpperSet (f' j : Set (Finset α)) := by
    refine' fun j hj ↦ (hf₁ _ hj).2.2.isUpperSet' ((hf₁ _ hj).2.2.is_max_iff_card_eq.2 _)
    rw [Fintype.card_finset]
    exact (hf₁ _ hj).2.1
  refine' (card_le_of_subset <| biUnion_mono fun j hj ↦ (hf₁ _ hj).1).trans _
  nth_rw 1 [cons_eq_insert i]
  

Proof state:
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
this : DecidableEq ι
i : ι
s : Finset ι
hi : i ∉ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ i ∈ s, Set.Intersecting ↑(f i)) →
      card s ≤ Fintype.card α → card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
f : ι → Finset (Finset α)
hf : ∀ i_1 ∈ cons i s hi, Set.Intersecting ↑(f i_1)
hs : card (cons i s hi) ≤ Fintype.card α
f' : ι → Finset (Finset α) :=
  fun j =>
    if hj : j ∈ cons i s hi then
      Exists.choose (_ : ∃ t, f j ⊆ t ∧ 2 * card t = Fintype.card (Finset α) ∧ Set.Intersecting ↑t)
    else ∅
hf₁ : ∀ j ∈ cons i s hi, f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ j ∈ cons i s hi, IsUpperSet ↑(f' j)
⊢ card (Finset.biUnion (insert i s) fun j => f' j) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi))

Next tactic:
rw [biUnion_insert]
/-- **Kleitman's theorem**. An intersecting family on `n` elements contains at most `2ⁿ⁻¹` sets, and
each further intersecting family takes at most half of the sets that are in no previous family. -/
theorem Finset.card_biUnion_le_of_intersecting (s : Finset ι) (f : ι → Finset (Finset α))
    (hf : ∀ i ∈ s, (f i : Set (Finset α)).Intersecting) :
    (s.biUnion f).card ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - s.card) := by
  have : DecidableEq ι := by
    classical
    infer_instance
  obtain hs | hs := le_total (Fintype.card α) s.card
  · rw [tsub_eq_zero_of_le hs, pow_zero]
    refine' (card_le_of_subset <| biUnion_subset.2 fun i hi a ha ↦
      mem_compl.2 <| not_mem_singleton.2 <| (hf _ hi).ne_bot ha).trans_eq _
    rw [card_compl, Fintype.card_finset, card_singleton]
  induction' s using Finset.cons_induction with i s hi ih generalizing f
  · simp
  set f' : ι → Finset (Finset α) :=
    fun j ↦ if hj : j ∈ cons i s hi then (hf j hj).exists_card_eq.choose else ∅
  have hf₁ : ∀ j, j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * (f' j).card =
      2 ^ Fintype.card α ∧ (f' j : Set (Finset α)).Intersecting := by
    rintro j hj
    simp_rw [dif_pos hj, ← Fintype.card_finset]
    exact Classical.choose_spec (hf j hj).exists_card_eq
  have hf₂ : ∀ j, j ∈ cons i s hi → IsUpperSet (f' j : Set (Finset α)) := by
    refine' fun j hj ↦ (hf₁ _ hj).2.2.isUpperSet' ((hf₁ _ hj).2.2.is_max_iff_card_eq.2 _)
    rw [Fintype.card_finset]
    exact (hf₁ _ hj).2.1
  refine' (card_le_of_subset <| biUnion_mono fun j hj ↦ (hf₁ _ hj).1).trans _
  nth_rw 1 [cons_eq_insert i]
  rw [biUnion_insert]
  

Proof state:
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
this : DecidableEq ι
i : ι
s : Finset ι
hi : i ∉ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ i ∈ s, Set.Intersecting ↑(f i)) →
      card s ≤ Fintype.card α → card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
f : ι → Finset (Finset α)
hf : ∀ i_1 ∈ cons i s hi, Set.Intersecting ↑(f i_1)
hs : card (cons i s hi) ≤ Fintype.card α
f' : ι → Finset (Finset α) :=
  fun j =>
    if hj : j ∈ cons i s hi then
      Exists.choose (_ : ∃ t, f j ⊆ t ∧ 2 * card t = Fintype.card (Finset α) ∧ Set.Intersecting ↑t)
    else ∅
hf₁ : ∀ j ∈ cons i s hi, f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ j ∈ cons i s hi, IsUpperSet ↑(f' j)
⊢ card (f' i ∪ Finset.biUnion s fun j => f' j) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi))

Next tactic:
refine' (card_mono <| @le_sup_sdiff _ _ _ <| f' i).trans ((card_union_le _ _).trans _)