[GOAL]
α : Type u_1
β : Type u_2
inst✝⁷ : Preorder α
inst✝⁶ : Add α
inst✝⁵ : Sub α
inst✝⁴ : OrderedSub α
a✝ b✝ c d : α
inst✝³ : Preorder β
inst✝² : Add β
inst✝¹ : Sub β
inst✝ : OrderedSub β
f : AddHom α β
hf : Monotone ↑f
a b : α
⊢ ↑f a - ↑f b ≤ ↑f (a - b)
[PROOFSTEP]
rw [tsub_le_iff_right, ← f.map_add]
[GOAL]
α : Type u_1
β : Type u_2
inst✝⁷ : Preorder α
inst✝⁶ : Add α
inst✝⁵ : Sub α
inst✝⁴ : OrderedSub α
a✝ b✝ c d : α
inst✝³ : Preorder β
inst✝² : Add β
inst✝¹ : Sub β
inst✝ : OrderedSub β
f : AddHom α β
hf : Monotone ↑f
a b : α
⊢ ↑f a ≤ ↑f (a - b + b)
[PROOFSTEP]
exact hf le_tsub_add
[GOAL]
α : Type u_1
β : Type u_2
inst✝⁸ : Preorder α
inst✝⁷ : Add α
inst✝⁶ : Sub α
inst✝⁵ : OrderedSub α
a✝ b✝ c✝ d : α
R : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Preorder R
inst✝² : Sub R
inst✝¹ : OrderedSub R
inst✝ : CovariantClass R R (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : R
⊢ a * c - b * c ≤ (a - b) * c
[PROOFSTEP]
simpa only [mul_comm _ c] using le_mul_tsub
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
inst✝⁷ : Preorder M
inst✝⁶ : Add M
inst✝⁵ : Sub M
inst✝⁴ : OrderedSub M
inst✝³ : PartialOrder N
inst✝² : Add N
inst✝¹ : Sub N
inst✝ : OrderedSub N
e : M ≃o N
h_add : ∀ (a b : M), ↑e (a + b) = ↑e a + ↑e b
a b : M
⊢ ↑e (a - b) = ↑e a - ↑e b
[PROOFSTEP]
let e_add : M ≃+ N := { e with map_add' := h_add }
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
inst✝⁷ : Preorder M
inst✝⁶ : Add M
inst✝⁵ : Sub M
inst✝⁴ : OrderedSub M
inst✝³ : PartialOrder N
inst✝² : Add N
inst✝¹ : Sub N
inst✝ : OrderedSub N
e : M ≃o N
h_add : ∀ (a b : M), ↑e (a + b) = ↑e a + ↑e b
a b : M
e_add : M ≃+ N := { toEquiv := e.toEquiv, map_add' := h_add }
⊢ ↑e (a - b) = ↑e a - ↑e b
[PROOFSTEP]
refine' le_antisymm _ (e_add.toAddHom.le_map_tsub e.monotone a b)
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
inst✝⁷ : Preorder M
inst✝⁶ : Add M
inst✝⁵ : Sub M
inst✝⁴ : OrderedSub M
inst✝³ : PartialOrder N
inst✝² : Add N
inst✝¹ : Sub N
inst✝ : OrderedSub N
e : M ≃o N
h_add : ∀ (a b : M), ↑e (a + b) = ↑e a + ↑e b
a b : M
e_add : M ≃+ N := { toEquiv := e.toEquiv, map_add' := h_add }
⊢ ↑e (a - b) ≤ ↑e a - ↑e b
[PROOFSTEP]
suffices e (e.symm (e a) - e.symm (e b)) ≤ e (e.symm (e a - e b)) by simpa
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
inst✝⁷ : Preorder M
inst✝⁶ : Add M
inst✝⁵ : Sub M
inst✝⁴ : OrderedSub M
inst✝³ : PartialOrder N
inst✝² : Add N
inst✝¹ : Sub N
inst✝ : OrderedSub N
e : M ≃o N
h_add : ∀ (a b : M), ↑e (a + b) = ↑e a + ↑e b
a b : M
e_add : M ≃+ N := { toEquiv := e.toEquiv, map_add' := h_add }
this : ↑e (↑(symm e) (↑e a) - ↑(symm e) (↑e b)) ≤ ↑e (↑(symm e) (↑e a - ↑e b))
⊢ ↑e (a - b) ≤ ↑e a - ↑e b
[PROOFSTEP]
simpa
[GOAL]
α : Type u_1
β : Type u_2
M : Type u_3
N : Type u_4
inst✝⁷ : Preorder M
inst✝⁶ : Add M
inst✝⁵ : Sub M
inst✝⁴ : OrderedSub M
inst✝³ : PartialOrder N
inst✝² : Add N
inst✝¹ : Sub N
inst✝ : OrderedSub N
e : M ≃o N
h_add : ∀ (a b : M), ↑e (a + b) = ↑e a + ↑e b
a b : M
e_add : M ≃+ N := { toEquiv := e.toEquiv, map_add' := h_add }
⊢ ↑e (↑(symm e) (↑e a) - ↑(symm e) (↑e b)) ≤ ↑e (↑(symm e) (↑e a - ↑e b))
[PROOFSTEP]
exact e.monotone (e_add.symm.toAddHom.le_map_tsub e.symm.monotone _ _)


[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s : Finset ι
f : ι → Finset (Finset α)
hf : ∀ (i : ι), i ∈ s → Set.Intersecting ↑(f i)
⊢ card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
[PROOFSTEP]
have : DecidableEq ι := by classical infer_instance
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s : Finset ι
f : ι → Finset (Finset α)
hf : ∀ (i : ι), i ∈ s → Set.Intersecting ↑(f i)
⊢ DecidableEq ι
[PROOFSTEP]
classical infer_instance
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s : Finset ι
f : ι → Finset (Finset α)
hf : ∀ (i : ι), i ∈ s → Set.Intersecting ↑(f i)
⊢ DecidableEq ι
[PROOFSTEP]
infer_instance
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s : Finset ι
f : ι → Finset (Finset α)
hf : ∀ (i : ι), i ∈ s → Set.Intersecting ↑(f i)
this : DecidableEq ι
⊢ card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
[PROOFSTEP]
obtain hs | hs := le_total (Fintype.card α) s.card
[GOAL]
case inl
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s : Finset ι
f : ι → Finset (Finset α)
hf : ∀ (i : ι), i ∈ s → Set.Intersecting ↑(f i)
this : DecidableEq ι
hs : Fintype.card α ≤ card s
⊢ card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
[PROOFSTEP]
rw [tsub_eq_zero_of_le hs, pow_zero]
[GOAL]
case inl
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s : Finset ι
f : ι → Finset (Finset α)
hf : ∀ (i : ι), i ∈ s → Set.Intersecting ↑(f i)
this : DecidableEq ι
hs : Fintype.card α ≤ card s
⊢ card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 1
[PROOFSTEP]
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
    _
[GOAL]
case inl
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s : Finset ι
f : ι → Finset (Finset α)
hf : ∀ (i : ι), i ∈ s → Set.Intersecting ↑(f i)
this : DecidableEq ι
hs : Fintype.card α ≤ card s
⊢ card {⊥}ᶜ = 2 ^ Fintype.card α - 1
[PROOFSTEP]
rw [card_compl, Fintype.card_finset, card_singleton]
[GOAL]
case inr
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s : Finset ι
f : ι → Finset (Finset α)
hf : ∀ (i : ι), i ∈ s → Set.Intersecting ↑(f i)
this : DecidableEq ι
hs : card s ≤ Fintype.card α
⊢ card (Finset.biUnion s f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)
[PROOFSTEP]
induction' s using Finset.cons_induction with i s hi ih generalizing f
[GOAL]
case inr.empty
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s ≤ Fintype.card α
f : ι → Finset (Finset α)
hf : ∀ (i : ι), i ∈ ∅ → Set.Intersecting ↑(f i)
hs : card ∅ ≤ Fintype.card α
⊢ card (Finset.biUnion ∅ f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card ∅)
[PROOFSTEP]
simp
[GOAL]
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), i_1 ∈ cons i s hi → Set.Intersecting ↑(f i_1)
hs : card (cons i s hi) ≤ Fintype.card α
⊢ card (Finset.biUnion (cons i s hi) f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi))
[PROOFSTEP]
set f' : ι → Finset (Finset α) := fun j ↦ if hj : j ∈ cons i s hi then (hf j hj).exists_card_eq.choose else ∅
[GOAL]
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 ∅
⊢ card (Finset.biUnion (cons i s hi) f) ≤ 2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi))
[PROOFSTEP]
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
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
[PROOFSTEP]
rintro j hj
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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)
[PROOFSTEP]
simp_rw [dif_pos hj, ← Fintype.card_finset]
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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))
[PROOFSTEP]
exact Classical.choose_spec (hf j hj).exists_card_eq
[GOAL]
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), 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))
[PROOFSTEP]
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
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
⊢ ∀ (j : ι), j ∈ cons i s hi → IsUpperSet ↑(f' j)
[PROOFSTEP]
refine' fun j hj ↦ (hf₁ _ hj).2.2.isUpperSet' ((hf₁ _ hj).2.2.is_max_iff_card_eq.2 _)
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), 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 α)
[PROOFSTEP]
rw [Fintype.card_finset]
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), 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 α
[PROOFSTEP]
exact (hf₁ _ hj).2.1
[GOAL]
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), 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))
[PROOFSTEP]
refine' (card_le_of_subset <| biUnion_mono fun j hj ↦ (hf₁ _ hj).1).trans _
[GOAL]
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), 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))
[PROOFSTEP]
nth_rw 1 [cons_eq_insert i]
[GOAL]
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), 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))
[PROOFSTEP]
rw [biUnion_insert]
[GOAL]
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), 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))
[PROOFSTEP]
refine' (card_mono <| @le_sup_sdiff _ _ _ <| f' i).trans ((card_union_le _ _).trans _)
[GOAL]
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), j ∈ cons i s hi → IsUpperSet ↑(f' j)
⊢ card (f' i) + card ((f' i ∪ Finset.biUnion s fun j => f' j) \ f' i) ≤
    2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi))
[PROOFSTEP]
rw [union_sdiff_left, sdiff_eq_inter_compl]
[GOAL]
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), j ∈ cons i s hi → IsUpperSet ↑(f' j)
⊢ card (f' i) + card ((Finset.biUnion s fun j => f' j) ∩ (f' i)ᶜ) ≤
    2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi))
[PROOFSTEP]
refine' le_of_mul_le_mul_left _ (pow_pos (zero_lt_two' ℕ) <| Fintype.card α + 1)
[GOAL]
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), j ∈ cons i s hi → IsUpperSet ↑(f' j)
⊢ 2 ^ (Fintype.card α + 1) * (card (f' i) + card ((Finset.biUnion s fun j => f' j) ∩ (f' i)ᶜ)) ≤
    2 ^ (Fintype.card α + 1) * (2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi)))
[PROOFSTEP]
rw [pow_succ', mul_add, mul_assoc, mul_comm _ 2, mul_assoc]
[GOAL]
case inr.cons
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), j ∈ cons i s hi → IsUpperSet ↑(f' j)
⊢ 2 ^ Fintype.card α * (2 * card (f' i)) +
      2 * (2 ^ Fintype.card α * card ((Finset.biUnion s fun j => f' j) ∩ (f' i)ᶜ)) ≤
    2 * 2 ^ Fintype.card α * (2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi)))
[PROOFSTEP]
refine'
  (add_le_add ((mul_le_mul_left <| pow_pos (zero_lt_two' ℕ) _).2 (hf₁ _ <| mem_cons_self _ _).2.2.card_le) <|
        (mul_le_mul_left <| zero_lt_two' ℕ).2 <| IsUpperSet.card_inter_le_finset _ _).trans
    _
[GOAL]
case inr.cons.refine'_1
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), j ∈ cons i s hi → IsUpperSet ↑(f' j)
⊢ IsUpperSet ↑(Finset.biUnion s fun j => f' j)
[PROOFSTEP]
rw [coe_biUnion]
[GOAL]
case inr.cons.refine'_1
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), j ∈ cons i s hi → IsUpperSet ↑(f' j)
⊢ IsUpperSet (⋃ (x : ι) (_ : x ∈ ↑s), ↑(f' x))
[PROOFSTEP]
exact isUpperSet_iUnion₂ fun i hi ↦ hf₂ _ <| subset_cons _ hi
[GOAL]
case inr.cons.refine'_2
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), j ∈ cons i s hi → IsUpperSet ↑(f' j)
⊢ IsLowerSet ↑(f' i)ᶜ
[PROOFSTEP]
rw [coe_compl]
[GOAL]
case inr.cons.refine'_2
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), j ∈ cons i s hi → IsUpperSet ↑(f' j)
⊢ IsLowerSet (↑(f' i))ᶜ
[PROOFSTEP]
exact (hf₂ _ <| mem_cons_self _ _).compl
[GOAL]
case inr.cons.refine'_3
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), j ∈ cons i s hi → IsUpperSet ↑(f' j)
⊢ 2 ^ Fintype.card α * Fintype.card (Finset α) + 2 * (card (Finset.biUnion s fun j => f' j) * card (f' i)ᶜ) ≤
    2 * 2 ^ Fintype.card α * (2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi)))
[PROOFSTEP]
rw [mul_tsub, card_compl, Fintype.card_finset, mul_left_comm, mul_tsub, (hf₁ _ <| mem_cons_self _ _).2.1, two_mul,
  add_tsub_cancel_left, ← mul_tsub, ← mul_two, mul_assoc, ← add_mul, mul_comm]
[GOAL]
case inr.cons.refine'_3
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), j ∈ cons i s hi → IsUpperSet ↑(f' j)
⊢ 2 ^ Fintype.card α * (2 ^ Fintype.card α + card (Finset.biUnion s fun j => f' j)) ≤
    2 ^ Fintype.card α * (2 * (2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi))))
[PROOFSTEP]
refine' mul_le_mul_left' _ _
[GOAL]
case inr.cons.refine'_3
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), j ∈ cons i s hi → IsUpperSet ↑(f' j)
⊢ 2 ^ Fintype.card α + card (Finset.biUnion s fun j => f' j) ≤
    2 * (2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi)))
[PROOFSTEP]
refine'
  (add_le_add_left (ih _ (fun i hi ↦ (hf₁ _ <| subset_cons _ hi).2.2) ((card_le_of_subset <| subset_cons _).trans hs))
        _).trans
    _
[GOAL]
case inr.cons.refine'_3
ι : Type u_1
α : Type u_2
inst✝² : Fintype α
inst✝¹ : DecidableEq α
inst✝ : Nonempty α
s✝ : Finset ι
f✝ : ι → Finset (Finset α)
hf✝ : ∀ (i : ι), i ∈ s✝ → Set.Intersecting ↑(f✝ i)
this : DecidableEq ι
hs✝ : card s✝ ≤ Fintype.card α
i : ι
s : Finset ι
hi : ¬i ∈ s
ih :
  ∀ (f : ι → Finset (Finset α)),
    (∀ (i : ι), 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 : ι), 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 : ι), j ∈ cons i s hi → f j ⊆ f' j ∧ 2 * card (f' j) = 2 ^ Fintype.card α ∧ Set.Intersecting ↑(f' j)
hf₂ : ∀ (j : ι), j ∈ cons i s hi → IsUpperSet ↑(f' j)
⊢ 2 ^ Fintype.card α + (2 ^ Fintype.card α - 2 ^ (Fintype.card α - card s)) ≤
    2 * (2 ^ Fintype.card α - 2 ^ (Fintype.card α - card (cons i s hi)))
[PROOFSTEP]
rw [mul_tsub, two_mul, ← pow_succ, ← add_tsub_assoc_of_le (pow_le_pow' (one_le_two : (1 : ℕ) ≤ 2) tsub_le_self),
  tsub_add_eq_add_tsub hs, card_cons, add_tsub_add_eq_tsub_right]


[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S x : Submonoid M
⊢ (fun S =>
        {
          toSubsemigroup :=
            { carrier := ↑Additive.ofMul ⁻¹' ↑S,
              mul_mem' :=
                (_ : ∀ {a b : M}, a ∈ ↑Additive.ofMul ⁻¹' ↑S → b ∈ ↑Additive.ofMul ⁻¹' ↑S → a + b ∈ S.carrier) },
          one_mem' := (_ : 0 ∈ S.carrier) })
      ((fun S =>
          {
            toAddSubsemigroup :=
              { carrier := ↑Additive.toMul ⁻¹' ↑S,
                add_mem' :=
                  (_ :
                    ∀ {a b : Additive M},
                      a ∈ ↑Additive.toMul ⁻¹' ↑S →
                        b ∈ ↑Additive.toMul ⁻¹' ↑S → ↑Additive.toMul a * ↑Additive.toMul b ∈ S.carrier) },
            zero_mem' := (_ : 1 ∈ S.carrier) })
        x) =
    x
[PROOFSTEP]
cases x
[GOAL]
case mk
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S : Submonoid M
toSubsemigroup✝ : Subsemigroup M
one_mem'✝ : 1 ∈ toSubsemigroup✝.carrier
⊢ (fun S =>
        {
          toSubsemigroup :=
            { carrier := ↑Additive.ofMul ⁻¹' ↑S,
              mul_mem' :=
                (_ : ∀ {a b : M}, a ∈ ↑Additive.ofMul ⁻¹' ↑S → b ∈ ↑Additive.ofMul ⁻¹' ↑S → a + b ∈ S.carrier) },
          one_mem' := (_ : 0 ∈ S.carrier) })
      ((fun S =>
          {
            toAddSubsemigroup :=
              { carrier := ↑Additive.toMul ⁻¹' ↑S,
                add_mem' :=
                  (_ :
                    ∀ {a b : Additive M},
                      a ∈ ↑Additive.toMul ⁻¹' ↑S →
                        b ∈ ↑Additive.toMul ⁻¹' ↑S → ↑Additive.toMul a * ↑Additive.toMul b ∈ S.carrier) },
            zero_mem' := (_ : 1 ∈ S.carrier) })
        { toSubsemigroup := toSubsemigroup✝, one_mem' := one_mem'✝ }) =
    { toSubsemigroup := toSubsemigroup✝, one_mem' := one_mem'✝ }
[PROOFSTEP]
rfl
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S : Submonoid M
x : AddSubmonoid (Additive M)
⊢ (fun S =>
        {
          toAddSubsemigroup :=
            { carrier := ↑Additive.toMul ⁻¹' ↑S,
              add_mem' :=
                (_ :
                  ∀ {a b : Additive M},
                    a ∈ ↑Additive.toMul ⁻¹' ↑S →
                      b ∈ ↑Additive.toMul ⁻¹' ↑S → ↑Additive.toMul a * ↑Additive.toMul b ∈ S.carrier) },
          zero_mem' := (_ : 1 ∈ S.carrier) })
      ((fun S =>
          {
            toSubsemigroup :=
              { carrier := ↑Additive.ofMul ⁻¹' ↑S,
                mul_mem' :=
                  (_ : ∀ {a b : M}, a ∈ ↑Additive.ofMul ⁻¹' ↑S → b ∈ ↑Additive.ofMul ⁻¹' ↑S → a + b ∈ S.carrier) },
            one_mem' := (_ : 0 ∈ S.carrier) })
        x) =
    x
[PROOFSTEP]
cases x
[GOAL]
case mk
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S : Submonoid M
toAddSubsemigroup✝ : AddSubsemigroup (Additive M)
zero_mem'✝ : 0 ∈ toAddSubsemigroup✝.carrier
⊢ (fun S =>
        {
          toAddSubsemigroup :=
            { carrier := ↑Additive.toMul ⁻¹' ↑S,
              add_mem' :=
                (_ :
                  ∀ {a b : Additive M},
                    a ∈ ↑Additive.toMul ⁻¹' ↑S →
                      b ∈ ↑Additive.toMul ⁻¹' ↑S → ↑Additive.toMul a * ↑Additive.toMul b ∈ S.carrier) },
          zero_mem' := (_ : 1 ∈ S.carrier) })
      ((fun S =>
          {
            toSubsemigroup :=
              { carrier := ↑Additive.ofMul ⁻¹' ↑S,
                mul_mem' :=
                  (_ : ∀ {a b : M}, a ∈ ↑Additive.ofMul ⁻¹' ↑S → b ∈ ↑Additive.ofMul ⁻¹' ↑S → a + b ∈ S.carrier) },
            one_mem' := (_ : 0 ∈ S.carrier) })
        { toAddSubsemigroup := toAddSubsemigroup✝, zero_mem' := zero_mem'✝ }) =
    { toAddSubsemigroup := toAddSubsemigroup✝, zero_mem' := zero_mem'✝ }
[PROOFSTEP]
rfl
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : AddZeroClass A
x : AddSubmonoid A
⊢ (fun S =>
        {
          toAddSubsemigroup :=
            { carrier := ↑Multiplicative.ofAdd ⁻¹' ↑S,
              add_mem' :=
                (_ :
                  ∀ {a b : A},
                    a ∈ ↑Multiplicative.ofAdd ⁻¹' ↑S → b ∈ ↑Multiplicative.ofAdd ⁻¹' ↑S → a * b ∈ S.carrier) },
          zero_mem' := (_ : 1 ∈ S.carrier) })
      ((fun S =>
          {
            toSubsemigroup :=
              { carrier := ↑Multiplicative.toAdd ⁻¹' ↑S,
                mul_mem' :=
                  (_ :
                    ∀ {a b : Multiplicative A},
                      a ∈ ↑Multiplicative.toAdd ⁻¹' ↑S →
                        b ∈ ↑Multiplicative.toAdd ⁻¹' ↑S →
                          ↑Multiplicative.toAdd a + ↑Multiplicative.toAdd b ∈ S.carrier) },
            one_mem' := (_ : 0 ∈ S.carrier) })
        x) =
    x
[PROOFSTEP]
cases x
[GOAL]
case mk
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : AddZeroClass A
toAddSubsemigroup✝ : AddSubsemigroup A
zero_mem'✝ : 0 ∈ toAddSubsemigroup✝.carrier
⊢ (fun S =>
        {
          toAddSubsemigroup :=
            { carrier := ↑Multiplicative.ofAdd ⁻¹' ↑S,
              add_mem' :=
                (_ :
                  ∀ {a b : A},
                    a ∈ ↑Multiplicative.ofAdd ⁻¹' ↑S → b ∈ ↑Multiplicative.ofAdd ⁻¹' ↑S → a * b ∈ S.carrier) },
          zero_mem' := (_ : 1 ∈ S.carrier) })
      ((fun S =>
          {
            toSubsemigroup :=
              { carrier := ↑Multiplicative.toAdd ⁻¹' ↑S,
                mul_mem' :=
                  (_ :
                    ∀ {a b : Multiplicative A},
                      a ∈ ↑Multiplicative.toAdd ⁻¹' ↑S →
                        b ∈ ↑Multiplicative.toAdd ⁻¹' ↑S →
                          ↑Multiplicative.toAdd a + ↑Multiplicative.toAdd b ∈ S.carrier) },
            one_mem' := (_ : 0 ∈ S.carrier) })
        { toAddSubsemigroup := toAddSubsemigroup✝, zero_mem' := zero_mem'✝ }) =
    { toAddSubsemigroup := toAddSubsemigroup✝, zero_mem' := zero_mem'✝ }
[PROOFSTEP]
rfl
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : AddZeroClass A
x : Submonoid (Multiplicative A)
⊢ (fun S =>
        {
          toSubsemigroup :=
            { carrier := ↑Multiplicative.toAdd ⁻¹' ↑S,
              mul_mem' :=
                (_ :
                  ∀ {a b : Multiplicative A},
                    a ∈ ↑Multiplicative.toAdd ⁻¹' ↑S →
                      b ∈ ↑Multiplicative.toAdd ⁻¹' ↑S →
                        ↑Multiplicative.toAdd a + ↑Multiplicative.toAdd b ∈ S.carrier) },
          one_mem' := (_ : 0 ∈ S.carrier) })
      ((fun S =>
          {
            toAddSubsemigroup :=
              { carrier := ↑Multiplicative.ofAdd ⁻¹' ↑S,
                add_mem' :=
                  (_ :
                    ∀ {a b : A},
                      a ∈ ↑Multiplicative.ofAdd ⁻¹' ↑S → b ∈ ↑Multiplicative.ofAdd ⁻¹' ↑S → a * b ∈ S.carrier) },
            zero_mem' := (_ : 1 ∈ S.carrier) })
        x) =
    x
[PROOFSTEP]
cases x
[GOAL]
case mk
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : AddZeroClass A
toSubsemigroup✝ : Subsemigroup (Multiplicative A)
one_mem'✝ : 1 ∈ toSubsemigroup✝.carrier
⊢ (fun S =>
        {
          toSubsemigroup :=
            { carrier := ↑Multiplicative.toAdd ⁻¹' ↑S,
              mul_mem' :=
                (_ :
                  ∀ {a b : Multiplicative A},
                    a ∈ ↑Multiplicative.toAdd ⁻¹' ↑S →
                      b ∈ ↑Multiplicative.toAdd ⁻¹' ↑S →
                        ↑Multiplicative.toAdd a + ↑Multiplicative.toAdd b ∈ S.carrier) },
          one_mem' := (_ : 0 ∈ S.carrier) })
      ((fun S =>
          {
            toAddSubsemigroup :=
              { carrier := ↑Multiplicative.ofAdd ⁻¹' ↑S,
                add_mem' :=
                  (_ :
                    ∀ {a b : A},
                      a ∈ ↑Multiplicative.ofAdd ⁻¹' ↑S → b ∈ ↑Multiplicative.ofAdd ⁻¹' ↑S → a * b ∈ S.carrier) },
            zero_mem' := (_ : 1 ∈ S.carrier) })
        { toSubsemigroup := toSubsemigroup✝, one_mem' := one_mem'✝ }) =
    { toSubsemigroup := toSubsemigroup✝, one_mem' := one_mem'✝ }
[PROOFSTEP]
rfl
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_4
mc : MonoidHomClass F M N
f : F
S : Submonoid N
a✝ b✝ : M
ha : a✝ ∈ ↑f ⁻¹' ↑S
hb : b✝ ∈ ↑f ⁻¹' ↑S
⊢ ↑f (a✝ * b✝) ∈ S
[PROOFSTEP]
rw [map_mul]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_4
mc : MonoidHomClass F M N
f : F
S : Submonoid N
a✝ b✝ : M
ha : a✝ ∈ ↑f ⁻¹' ↑S
hb : b✝ ∈ ↑f ⁻¹' ↑S
⊢ ↑f a✝ * ↑f b✝ ∈ S
[PROOFSTEP]
exact S.mul_mem ha hb
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_4
mc : MonoidHomClass F M N
f : F
S : Submonoid N
⊢ ↑f 1 ∈ S
[PROOFSTEP]
rw [map_one]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_4
mc : MonoidHomClass F M N
f : F
S : Submonoid N
⊢ 1 ∈ S
[PROOFSTEP]
exact S.one_mem
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_4
mc : MonoidHomClass F M N
S : Submonoid P
⊢ ∀ (x : P), x ∈ comap (MonoidHom.id P) S ↔ x ∈ S
[PROOFSTEP]
simp
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_4
mc : MonoidHomClass F M N
f : F
S : Submonoid M
⊢ ∀ {a b : N}, a ∈ ↑f '' ↑S → b ∈ ↑f '' ↑S → a * b ∈ ↑f '' ↑S
[PROOFSTEP]
rintro _ _ ⟨x, hx, rfl⟩ ⟨y, hy, rfl⟩
[GOAL]
case intro.intro.intro.intro
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_4
mc : MonoidHomClass F M N
f : F
S : Submonoid M
x : M
hx : x ∈ ↑S
y : M
hy : y ∈ ↑S
⊢ ↑f x * ↑f y ∈ ↑f '' ↑S
[PROOFSTEP]
exact ⟨x * y, S.mul_mem hx hy, by rw [map_mul]⟩
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_4
mc : MonoidHomClass F M N
f : F
S : Submonoid M
x : M
hx : x ∈ ↑S
y : M
hy : y ∈ ↑S
⊢ ↑f (x * y) = ↑f x * ↑f y
[PROOFSTEP]
rw [map_mul]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_4
mc : MonoidHomClass F M N
f : F
S : Submonoid M
y : N
⊢ y ∈ map f S ↔ ∃ x, x ∈ S ∧ ↑f x = y
[PROOFSTEP]
rw [← bex_def]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_4
mc : MonoidHomClass F M N
f : F
S : Submonoid M
y : N
⊢ y ∈ map f S ↔ ∃ x x_1, ↑f x = y
[PROOFSTEP]
exact mem_image_iff_bex
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_4
mc : MonoidHomClass F M N
ι : Type u_5
f : F
hf : Function.Injective ↑f
S : Submonoid M
x : M
⊢ x ∈ comap f (map f S) → x ∈ S
[PROOFSTEP]
simp [mem_comap, mem_map, hf.eq_iff]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : MulOneClass P
S✝ : Submonoid M
F : Type u_4
mc : MonoidHomClass F M N
ι : Type u_5
f : F
hf : Function.Surjective ↑f
S : Submonoid N
x : N
h : x ∈ S
y : M
hy : ↑f y = x
⊢ y ∈ comap f S ∧ ↑f y = x
[PROOFSTEP]
simp [hy, h]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ ∀ (x y : { x // x ∈ S' }),
    OneHom.toFun { toFun := Subtype.val, map_one' := (_ : ↑1 = ↑1) } (x * y) =
      OneHom.toFun { toFun := Subtype.val, map_one' := (_ : ↑1 = ↑1) } x *
        OneHom.toFun { toFun := Subtype.val, map_one' := (_ : ↑1 = ↑1) } y
[PROOFSTEP]
simp
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ ∀ (x y : { x // x ∈ S }),
    OneHom.toFun { toFun := Subtype.val, map_one' := (_ : ↑1 = ↑1) } (x * y) =
      OneHom.toFun { toFun := Subtype.val, map_one' := (_ : ↑1 = ↑1) } x *
        OneHom.toFun { toFun := Subtype.val, map_one' := (_ : ↑1 = ↑1) } y
[PROOFSTEP]
simp
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Set M
x✝¹ : { x // x ∈ ↑(closure s) }
x : M
hx : x ∈ ↑(closure s)
x✝ : { val := x, property := hx } ∈ ⊤
⊢ { val := x, property := hx } ∈ closure (Subtype.val ⁻¹' s)
[PROOFSTEP]
refine' closure_induction' _ (fun g hg => subset_closure hg) _ (fun g₁ g₂ hg₁ hg₂ => _) hx
[GOAL]
case refine'_1
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Set M
x✝¹ : { x // x ∈ ↑(closure s) }
x : M
hx : x ∈ ↑(closure s)
x✝ : { val := x, property := hx } ∈ ⊤
⊢ { val := 1, property := (_ : 1 ∈ closure s) } ∈ closure (Subtype.val ⁻¹' s)
[PROOFSTEP]
exact Submonoid.one_mem _
[GOAL]
case refine'_2
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Set M
x✝¹ : { x // x ∈ ↑(closure s) }
x : M
hx : x ∈ ↑(closure s)
x✝ : { val := x, property := hx } ∈ ⊤
g₁ : M
g₂ : g₁ ∈ closure s
hg₁ : M
hg₂ : hg₁ ∈ closure s
⊢ { val := g₁, property := g₂ } ∈ closure (Subtype.val ⁻¹' s) →
    { val := hg₁, property := hg₂ } ∈ closure (Subtype.val ⁻¹' s) →
      { val := g₁ * hg₁, property := (_ : g₁ * hg₁ ∈ closure s) } ∈ closure (Subtype.val ⁻¹' s)
[PROOFSTEP]
exact Submonoid.mul_mem _
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
x : M × N
⊢ x ∈ prod s ⊤ ↔ x ∈ comap (MonoidHom.fst M N) s
[PROOFSTEP]
simp [mem_prod, MonoidHom.coe_fst]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid N
x : M × N
⊢ x ∈ prod ⊤ s ↔ x ∈ comap (MonoidHom.snd M N) s
[PROOFSTEP]
simp [mem_prod, MonoidHom.coe_snd]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ ↑(prod ⊥ ⊥) = ↑⊥
[PROOFSTEP]
simp [coe_prod, Prod.one_eq_mk]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
⊢ u ≤ prod s t ↔ map (fst M N) u ≤ s ∧ map (snd M N) u ≤ t
[PROOFSTEP]
constructor
[GOAL]
case mp
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
⊢ u ≤ prod s t → map (fst M N) u ≤ s ∧ map (snd M N) u ≤ t
[PROOFSTEP]
intro h
[GOAL]
case mp
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
h : u ≤ prod s t
⊢ map (fst M N) u ≤ s ∧ map (snd M N) u ≤ t
[PROOFSTEP]
constructor
[GOAL]
case mp.left
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
h : u ≤ prod s t
⊢ map (fst M N) u ≤ s
[PROOFSTEP]
rintro x ⟨⟨y1, y2⟩, ⟨hy1, rfl⟩⟩
[GOAL]
case mp.left.intro.mk.intro
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
h : u ≤ prod s t
y1 : M
y2 : N
hy1 : (y1, y2) ∈ ↑u
⊢ ↑(fst M N) (y1, y2) ∈ s
[PROOFSTEP]
exact (h hy1).1
[GOAL]
case mp.right
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
h : u ≤ prod s t
⊢ map (snd M N) u ≤ t
[PROOFSTEP]
rintro x ⟨⟨y1, y2⟩, ⟨hy1, rfl⟩⟩
[GOAL]
case mp.right.intro.mk.intro
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
h : u ≤ prod s t
y1 : M
y2 : N
hy1 : (y1, y2) ∈ ↑u
⊢ ↑(snd M N) (y1, y2) ∈ t
[PROOFSTEP]
exact (h hy1).2
[GOAL]
case mpr
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
⊢ map (fst M N) u ≤ s ∧ map (snd M N) u ≤ t → u ≤ prod s t
[PROOFSTEP]
rintro ⟨hH, hK⟩ ⟨x1, x2⟩ h
[GOAL]
case mpr.intro.mk
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
hH : map (fst M N) u ≤ s
hK : map (snd M N) u ≤ t
x1 : M
x2 : N
h : (x1, x2) ∈ u
⊢ (x1, x2) ∈ prod s t
[PROOFSTEP]
exact ⟨hH ⟨_, h, rfl⟩, hK ⟨_, h, rfl⟩⟩
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
⊢ prod s t ≤ u ↔ map (inl M N) s ≤ u ∧ map (inr M N) t ≤ u
[PROOFSTEP]
constructor
[GOAL]
case mp
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
⊢ prod s t ≤ u → map (inl M N) s ≤ u ∧ map (inr M N) t ≤ u
[PROOFSTEP]
intro h
[GOAL]
case mp
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
h : prod s t ≤ u
⊢ map (inl M N) s ≤ u ∧ map (inr M N) t ≤ u
[PROOFSTEP]
constructor
[GOAL]
case mp.left
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
h : prod s t ≤ u
⊢ map (inl M N) s ≤ u
[PROOFSTEP]
rintro _ ⟨x, hx, rfl⟩
[GOAL]
case mp.left.intro.intro
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
h : prod s t ≤ u
x : M
hx : x ∈ ↑s
⊢ ↑(inl M N) x ∈ u
[PROOFSTEP]
apply h
[GOAL]
case mp.left.intro.intro.a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
h : prod s t ≤ u
x : M
hx : x ∈ ↑s
⊢ ↑(inl M N) x ∈ prod s t
[PROOFSTEP]
exact ⟨hx, Submonoid.one_mem _⟩
[GOAL]
case mp.right
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
h : prod s t ≤ u
⊢ map (inr M N) t ≤ u
[PROOFSTEP]
rintro _ ⟨x, hx, rfl⟩
[GOAL]
case mp.right.intro.intro
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
h : prod s t ≤ u
x : N
hx : x ∈ ↑t
⊢ ↑(inr M N) x ∈ u
[PROOFSTEP]
apply h
[GOAL]
case mp.right.intro.intro.a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
h : prod s t ≤ u
x : N
hx : x ∈ ↑t
⊢ ↑(inr M N) x ∈ prod s t
[PROOFSTEP]
exact ⟨Submonoid.one_mem _, hx⟩
[GOAL]
case mpr
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
⊢ map (inl M N) s ≤ u ∧ map (inr M N) t ≤ u → prod s t ≤ u
[PROOFSTEP]
rintro ⟨hH, hK⟩ ⟨x1, x2⟩ ⟨h1, h2⟩
[GOAL]
case mpr.intro.mk.intro
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
hH : map (inl M N) s ≤ u
hK : map (inr M N) t ≤ u
x1 : M
x2 : N
h1 : (x1, x2).fst ∈ ↑s
h2 : (x1, x2).snd ∈ ↑t
⊢ (x1, x2) ∈ u
[PROOFSTEP]
have h1' : inl M N x1 ∈ u := by
  apply hH
  simpa using h1
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
hH : map (inl M N) s ≤ u
hK : map (inr M N) t ≤ u
x1 : M
x2 : N
h1 : (x1, x2).fst ∈ ↑s
h2 : (x1, x2).snd ∈ ↑t
⊢ ↑(inl M N) x1 ∈ u
[PROOFSTEP]
apply hH
[GOAL]
case a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
hH : map (inl M N) s ≤ u
hK : map (inr M N) t ≤ u
x1 : M
x2 : N
h1 : (x1, x2).fst ∈ ↑s
h2 : (x1, x2).snd ∈ ↑t
⊢ ↑(inl M N) x1 ∈ map (inl M N) s
[PROOFSTEP]
simpa using h1
[GOAL]
case mpr.intro.mk.intro
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
hH : map (inl M N) s ≤ u
hK : map (inr M N) t ≤ u
x1 : M
x2 : N
h1 : (x1, x2).fst ∈ ↑s
h2 : (x1, x2).snd ∈ ↑t
h1' : ↑(inl M N) x1 ∈ u
⊢ (x1, x2) ∈ u
[PROOFSTEP]
have h2' : inr M N x2 ∈ u := by
  apply hK
  simpa using h2
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
hH : map (inl M N) s ≤ u
hK : map (inr M N) t ≤ u
x1 : M
x2 : N
h1 : (x1, x2).fst ∈ ↑s
h2 : (x1, x2).snd ∈ ↑t
h1' : ↑(inl M N) x1 ∈ u
⊢ ↑(inr M N) x2 ∈ u
[PROOFSTEP]
apply hK
[GOAL]
case a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
hH : map (inl M N) s ≤ u
hK : map (inr M N) t ≤ u
x1 : M
x2 : N
h1 : (x1, x2).fst ∈ ↑s
h2 : (x1, x2).snd ∈ ↑t
h1' : ↑(inl M N) x1 ∈ u
⊢ ↑(inr M N) x2 ∈ map (inr M N) t
[PROOFSTEP]
simpa using h2
[GOAL]
case mpr.intro.mk.intro
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
u : Submonoid (M × N)
hH : map (inl M N) s ≤ u
hK : map (inr M N) t ≤ u
x1 : M
x2 : N
h1 : (x1, x2).fst ∈ ↑s
h2 : (x1, x2).snd ∈ ↑t
h1' : ↑(inl M N) x1 ∈ u
h2' : ↑(inr M N) x2 ∈ u
⊢ (x1, x2) ∈ u
[PROOFSTEP]
simpa using Submonoid.mul_mem _ h1' h2'
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
g : N →* P
f : M →* N
⊢ map g (mrange f) = mrange (comp g f)
[PROOFSTEP]
simpa only [mrange_eq_map] using (⊤ : Submonoid M).map_map g f
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
f : F
⊢ ↑(mrange f) = ↑⊤ ↔ Set.range ↑f = Set.univ
[PROOFSTEP]
rw [coe_mrange, coe_top]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
f : M →* N
⊢ mrange (restrict f S) = map f S
[PROOFSTEP]
simp [SetLike.ext_iff]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
f : M →* N
⊢ mker (mrangeRestrict f) = mker f
[PROOFSTEP]
ext x
[GOAL]
case h
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
f : M →* N
x : M
⊢ x ∈ mker (mrangeRestrict f) ↔ x ∈ mker f
[PROOFSTEP]
change (⟨f x, _⟩ : mrange f) = ⟨1, _⟩ ↔ f x = 1
[GOAL]
case h
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
f : M →* N
x : M
⊢ { val := ↑f x, property := (_ : ∃ y, ↑f y = ↑f x) } = { val := 1, property := (_ : 1 ∈ mrange f) } ↔ ↑f x = 1
[PROOFSTEP]
simp
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
⊢ mker 1 = ⊤
[PROOFSTEP]
ext
[GOAL]
case h
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
x✝ : M
⊢ x✝ ∈ mker 1 ↔ x✝ ∈ ⊤
[PROOFSTEP]
simp [mem_mker]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁵ : MulOneClass M
inst✝⁴ : MulOneClass N
inst✝³ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝² : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
M' : Type u_6
N' : Type u_7
inst✝¹ : MulOneClass M'
inst✝ : MulOneClass N'
f : M →* N
g : M' →* N'
⊢ mker (prodMap f g) = prod (mker f) (mker g)
[PROOFSTEP]
rw [← comap_bot', ← comap_bot', ← comap_bot', ← prod_map_comap_prod', bot_prod_bot]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
⊢ mker (inl M N) = ⊥
[PROOFSTEP]
ext x
[GOAL]
case h
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
x : M
⊢ x ∈ mker (inl M N) ↔ x ∈ ⊥
[PROOFSTEP]
simp [mem_mker]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
⊢ mker (inr M N) = ⊥
[PROOFSTEP]
ext x
[GOAL]
case h
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
x : N
⊢ x ∈ mker (inr M N) ↔ x ∈ ⊥
[PROOFSTEP]
simp [mem_mker]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
f : M →* N
M' : Submonoid M
⊢ Function.Surjective ↑(submonoidMap f M')
[PROOFSTEP]
rintro ⟨_, x, hx, rfl⟩
[GOAL]
case mk.intro.intro
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
F : Type u_5
mc : MonoidHomClass F M N
f : M →* N
M' : Submonoid M
x : M
hx : x ∈ ↑M'
⊢ ∃ a, ↑(submonoidMap f M') a = { val := ↑f x, property := (_ : ∃ a, a ∈ ↑M' ∧ ↑f a = ↑f x) }
[PROOFSTEP]
exact ⟨⟨x, hx⟩, rfl⟩
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ mrange (inl M N) = prod ⊤ ⊥
[PROOFSTEP]
simpa only [mrange_eq_map] using map_inl ⊤
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ mrange (inr M N) = prod ⊥ ⊤
[PROOFSTEP]
simpa only [mrange_eq_map] using map_inr ⊤
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
⊢ prod s t = ⊥ ↔ s = ⊥ ∧ t = ⊥
[PROOFSTEP]
simp only [eq_bot_iff, prod_le_iff, (gc_map_comap _).le_iff_le, comap_bot', mker_inl, mker_inr]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
s : Submonoid M
t : Submonoid N
⊢ prod s t = ⊤ ↔ s = ⊤ ∧ t = ⊤
[PROOFSTEP]
simp only [eq_top_iff, le_prod_iff, ← (gc_map_comap _).le_iff_le, ← mrange_eq_map, mrange_fst, mrange_snd]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ mrange (inl M N) ⊔ mrange (inr M N) = ⊤
[PROOFSTEP]
simp only [mrange_inl, mrange_inr, prod_bot_sup_bot_prod, top_prod_top]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
⊢ (∀ (x : M), x ∈ S ↔ x ∈ ⊥) ↔ ∀ (x : M), x ∈ S → x = 1
[PROOFSTEP]
simp (config := { contextual := true }) [iff_def, S.one_mem]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S✝ : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
S : Submonoid M
⊢ (∃ x hx, { val := x, property := hx } ≠ { val := 1, property := (_ : 1 ∈ S) }) ↔ ∃ x, x ∈ S ∧ x ≠ 1
[PROOFSTEP]
simp [Ne.def]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S✝ : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
S : Submonoid M
⊢ S = ⊥ ∨ Nontrivial { x // x ∈ S }
[PROOFSTEP]
simp only [eq_bot_iff_forall, nontrivial_iff_exists_ne_one, ← not_forall, ← not_imp, Classical.em]
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
T : Submonoid M
f : M →* N
g : N → M
h : Function.LeftInverse g ↑f
src✝ : M →* { x // x ∈ MonoidHom.mrange f } := MonoidHom.mrangeRestrict f
x : { x // x ∈ MonoidHom.mrange f }
x' : M
hx' : ↑f x' = ↑x
⊢ ↑f (g ↑x) = ↑x
[PROOFSTEP]
rw [← hx', h x']
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
e : M ≃* N
⊢ equivMapOfInjective S ↑e (_ : Function.Injective ↑e) = MulEquiv.submonoidMap e S
[PROOFSTEP]
ext
[GOAL]
case h.a
M : Type u_1
N : Type u_2
P : Type u_3
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝ : SetLike A M
hA : SubmonoidClass A M
S' : A
e : M ≃* N
x✝ : { x // x ∈ S }
⊢ ↑(↑(equivMapOfInjective S ↑e (_ : Function.Injective ↑e)) x✝) = ↑(↑(MulEquiv.submonoidMap e S) x✝)
[PROOFSTEP]
rfl
[GOAL]
M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S✝ : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
M' : Type u_5
α : Type u_6
β : Type u_7
inst✝ : Monoid M'
S : Submonoid M'
⊢ IsScalarTower { x // x ∈ S } M' M'
[PROOFSTEP]
infer_instance


[GOAL]
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
a₁ a₂ : α
b₁ : β a₁
b₂ : β a₂
h : { fst := a₁, snd := b₁ } = { fst := a₂, snd := b₂ }
⊢ a₁ = a₂ ∧ HEq b₁ b₂
[PROOFSTEP]
cases h
[GOAL]
case refl
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
a₁ : α
b₁ : β a₁
⊢ a₁ = a₁ ∧ HEq b₁ b₁
[PROOFSTEP]
exact ⟨rfl, heq_of_eq rfl⟩
[GOAL]
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
a₁ a₂ : α
b₁ : β a₁
b₂ : β a₂
x✝ : a₁ = a₂ ∧ HEq b₁ b₂
h₁ : a₁ = a₂
h₂ : HEq b₁ b₂
⊢ { fst := a₁, snd := b₁ } = { fst := a₂, snd := b₂ }
[PROOFSTEP]
subst h₁
[GOAL]
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
a₁ : α
b₁ b₂ : β a₁
x✝ : a₁ = a₁ ∧ HEq b₁ b₂
h₂ : HEq b₁ b₂
⊢ { fst := a₁, snd := b₁ } = { fst := a₁, snd := b₂ }
[PROOFSTEP]
rw [eq_of_heq h₂]
[GOAL]
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
x₀ x₁ : Sigma β
h₀ : x₀.fst = x₁.fst
h₁ : HEq x₀.snd x₁.snd
⊢ x₀ = x₁
[PROOFSTEP]
cases x₀
[GOAL]
case mk
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
x₁ : Sigma β
fst✝ : α
snd✝ : β fst✝
h₀ : { fst := fst✝, snd := snd✝ }.fst = x₁.fst
h₁ : HEq { fst := fst✝, snd := snd✝ }.snd x₁.snd
⊢ { fst := fst✝, snd := snd✝ } = x₁
[PROOFSTEP]
cases x₁
[GOAL]
case mk.mk
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
fst✝¹ : α
snd✝¹ : β fst✝¹
fst✝ : α
snd✝ : β fst✝
h₀ : { fst := fst✝¹, snd := snd✝¹ }.fst = { fst := fst✝, snd := snd✝ }.fst
h₁ : HEq { fst := fst✝¹, snd := snd✝¹ }.snd { fst := fst✝, snd := snd✝ }.snd
⊢ { fst := fst✝¹, snd := snd✝¹ } = { fst := fst✝, snd := snd✝ }
[PROOFSTEP]
cases h₀
[GOAL]
case mk.mk.refl
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
fst✝ : α
snd✝¹ snd✝ : β fst✝
h₁ : HEq { fst := fst✝, snd := snd✝¹ }.snd { fst := fst✝, snd := snd✝ }.snd
⊢ { fst := fst✝, snd := snd✝¹ } = { fst := fst✝, snd := snd✝ }
[PROOFSTEP]
cases h₁
[GOAL]
case mk.mk.refl.refl
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
fst✝ : α
snd✝ : β fst✝
⊢ { fst := fst✝, snd := snd✝ } = { fst := fst✝, snd := snd✝ }
[PROOFSTEP]
rfl
[GOAL]
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
x₀ x₁ : Sigma β
⊢ x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ HEq x₀.snd x₁.snd
[PROOFSTEP]
cases x₀
[GOAL]
case mk
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
x₁ : Sigma β
fst✝ : α
snd✝ : β fst✝
⊢ { fst := fst✝, snd := snd✝ } = x₁ ↔
    { fst := fst✝, snd := snd✝ }.fst = x₁.fst ∧ HEq { fst := fst✝, snd := snd✝ }.snd x₁.snd
[PROOFSTEP]
cases x₁
[GOAL]
case mk.mk
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
fst✝¹ : α
snd✝¹ : β fst✝¹
fst✝ : α
snd✝ : β fst✝
⊢ { fst := fst✝¹, snd := snd✝¹ } = { fst := fst✝, snd := snd✝ } ↔
    { fst := fst✝¹, snd := snd✝¹ }.fst = { fst := fst✝, snd := snd✝ }.fst ∧
      HEq { fst := fst✝¹, snd := snd✝¹ }.snd { fst := fst✝, snd := snd✝ }.snd
[PROOFSTEP]
exact Sigma.mk.inj_iff
[GOAL]
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
γ : Type u_7
inst✝ : Nonempty γ
a b : α
f : γ → β a
g : γ → β b
h : mk a ∘ f = mk b ∘ g
⊢ a = b ∧ HEq f g
[PROOFSTEP]
rcases‹Nonempty γ› with ⟨i⟩
[GOAL]
case intro
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
γ : Type u_7
inst✝ : Nonempty γ
a b : α
f : γ → β a
g : γ → β b
h : mk a ∘ f = mk b ∘ g
i : γ
⊢ a = b ∧ HEq f g
[PROOFSTEP]
obtain rfl : a = b := congr_arg Sigma.fst (congr_fun h i)
[GOAL]
case intro
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
γ : Type u_7
inst✝ : Nonempty γ
a : α
f : γ → β a
i : γ
g : γ → β a
h : mk a ∘ f = mk a ∘ g
⊢ a = a ∧ HEq f g
[PROOFSTEP]
simpa [Function.funext_iff] using h
[GOAL]
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Injective f₁
h₂ : ∀ (a : α₁), Injective (f₂ a)
i : α₁
x : β₁ i
j : α₁
y : β₁ j
h : Sigma.map f₁ f₂ { fst := i, snd := x } = Sigma.map f₁ f₂ { fst := j, snd := y }
⊢ { fst := i, snd := x } = { fst := j, snd := y }
[PROOFSTEP]
obtain rfl : i = j := h₁ (Sigma.mk.inj_iff.mp h).1
[GOAL]
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Injective f₁
h₂ : ∀ (a : α₁), Injective (f₂ a)
i : α₁
x y : β₁ i
h : Sigma.map f₁ f₂ { fst := i, snd := x } = Sigma.map f₁ f₂ { fst := i, snd := y }
⊢ { fst := i, snd := x } = { fst := i, snd := y }
[PROOFSTEP]
obtain rfl : x = y := h₂ i (sigma_mk_injective h)
[GOAL]
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Injective f₁
h₂ : ∀ (a : α₁), Injective (f₂ a)
i : α₁
x : β₁ i
h : Sigma.map f₁ f₂ { fst := i, snd := x } = Sigma.map f₁ f₂ { fst := i, snd := x }
⊢ { fst := i, snd := x } = { fst := i, snd := x }
[PROOFSTEP]
rfl
[GOAL]
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Surjective f₁
h₂ : ∀ (a : α₁), Surjective (f₂ a)
⊢ Surjective (Sigma.map f₁ f₂)
[PROOFSTEP]
simp only [Function.Surjective, Sigma.forall, h₁.forall]
[GOAL]
α : Type u_1
α₁ : Type u_2
α₂ : Type u_3
β : α → Type u_4
β₁ : α₁ → Type u_5
β₂ : α₂ → Type u_6
f₁ : α₁ → α₂
f₂ : (a : α₁) → β₁ a → β₂ (f₁ a)
h₁ : Surjective f₁
h₂ : ∀ (a : α₁), Surjective (f₂ a)
⊢ ∀ (x : α₁) (b : β₂ (f₁ x)), ∃ a, Sigma.map f₁ f₂ a = { fst := f₁ x, snd := b }
[PROOFSTEP]
exact fun i ↦ (h₂ _).forall.2 fun x ↦ ⟨⟨i, x⟩, rfl⟩
[GOAL]
α : Sort u_1
β : α → Sort u_2
x₀ x₁ : PSigma β
h₀ : x₀.fst = x₁.fst
h₁ : HEq x₀.snd x₁.snd
⊢ x₀ = x₁
[PROOFSTEP]
cases x₀
[GOAL]
case mk
α : Sort u_1
β : α → Sort u_2
x₁ : PSigma β
fst✝ : α
snd✝ : β fst✝
h₀ : { fst := fst✝, snd := snd✝ }.fst = x₁.fst
h₁ : HEq { fst := fst✝, snd := snd✝ }.snd x₁.snd
⊢ { fst := fst✝, snd := snd✝ } = x₁
[PROOFSTEP]
cases x₁
[GOAL]
case mk.mk
α : Sort u_1
β : α → Sort u_2
fst✝¹ : α
snd✝¹ : β fst✝¹
fst✝ : α
snd✝ : β fst✝
h₀ : { fst := fst✝¹, snd := snd✝¹ }.fst = { fst := fst✝, snd := snd✝ }.fst
h₁ : HEq { fst := fst✝¹, snd := snd✝¹ }.snd { fst := fst✝, snd := snd✝ }.snd
⊢ { fst := fst✝¹, snd := snd✝¹ } = { fst := fst✝, snd := snd✝ }
[PROOFSTEP]
cases h₀
[GOAL]
case mk.mk.refl
α : Sort u_1
β : α → Sort u_2
fst✝ : α
snd✝¹ snd✝ : β fst✝
h₁ : HEq { fst := fst✝, snd := snd✝¹ }.snd { fst := fst✝, snd := snd✝ }.snd
⊢ { fst := fst✝, snd := snd✝¹ } = { fst := fst✝, snd := snd✝ }
[PROOFSTEP]
cases h₁
[GOAL]
case mk.mk.refl.refl
α : Sort u_1
β : α → Sort u_2
fst✝ : α
snd✝ : β fst✝
⊢ { fst := fst✝, snd := snd✝ } = { fst := fst✝, snd := snd✝ }
[PROOFSTEP]
rfl
[GOAL]
α : Sort u_1
β : α → Sort u_2
x₀ x₁ : PSigma β
⊢ x₀ = x₁ ↔ x₀.fst = x₁.fst ∧ HEq x₀.snd x₁.snd
[PROOFSTEP]
cases x₀
[GOAL]
case mk
α : Sort u_1
β : α → Sort u_2
x₁ : PSigma β
fst✝ : α
snd✝ : β fst✝
⊢ { fst := fst✝, snd := snd✝ } = x₁ ↔
    { fst := fst✝, snd := snd✝ }.fst = x₁.fst ∧ HEq { fst := fst✝, snd := snd✝ }.snd x₁.snd
[PROOFSTEP]
cases x₁
[GOAL]
case mk.mk
α : Sort u_1
β : α → Sort u_2
fst✝¹ : α
snd✝¹ : β fst✝¹
fst✝ : α
snd✝ : β fst✝
⊢ { fst := fst✝¹, snd := snd✝¹ } = { fst := fst✝, snd := snd✝ } ↔
    { fst := fst✝¹, snd := snd✝¹ }.fst = { fst := fst✝, snd := snd✝ }.fst ∧
      HEq { fst := fst✝¹, snd := snd✝¹ }.snd { fst := fst✝, snd := snd✝ }.snd
[PROOFSTEP]
exact PSigma.mk.inj_iff