File: Mathlib/Data/Set/Prod.lean

full_name: Set.Subsingleton.prod
code: theorem Subsingleton.prod (hs : s.Subsingleton) (ht : t.Subsingleton) :
    (s ×ˢ t).Subsingleton 
goal: (s ×ˢ t).Subsingleton

full_name: Set.decidableMemProd
code: noncomputable instance decidableMemProd [DecidablePred (· ∈ s)] [DecidablePred (· ∈ t)] :
    DecidablePred (· ∈ s ×ˢ t) 
goal: DecidablePred fun x => x ∈ s ×ˢ t

full_name: Set.prod_mono
code: @[gcongr]
theorem prod_mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : s₁ ×ˢ t₁ ⊆ s₂ ×ˢ t₂ 
goal: s₁ ×ˢ t₁ ⊆ s₂ ×ˢ t₂

full_name: Set.prod_mono_left
code: @[gcongr]
theorem prod_mono_left (hs : s₁ ⊆ s₂) : s₁ ×ˢ t ⊆ s₂ ×ˢ t 
goal: s₁ ×ˢ t ⊆ s₂ ×ˢ t

full_name: Set.prod_mono_right
code: @[gcongr]
theorem prod_mono_right (ht : t₁ ⊆ t₂) : s ×ˢ t₁ ⊆ s ×ˢ t₂ 
goal: s ×ˢ t₁ ⊆ s ×ˢ t₂

full_name: Set.prod_self_subset_prod_self
code: @[simp]
theorem prod_self_subset_prod_self : s₁ ×ˢ s₁ ⊆ s₂ ×ˢ s₂ ↔ s₁ ⊆ s₂ 
goal: s₁ ×ˢ s₁ ⊆ s₂ ×ˢ s₂ ↔ s₁ ⊆ s₂

full_name: Set.prod_self_ssubset_prod_self
code: @[simp]
theorem prod_self_ssubset_prod_self : s₁ ×ˢ s₁ ⊂ s₂ ×ˢ s₂ ↔ s₁ ⊂ s₂ 
goal: s₁ ×ˢ s₁ ⊂ s₂ ×ˢ s₂ ↔ s₁ ⊂ s₂

full_name: Set.prod_subset_iff
code: theorem prod_subset_iff {P : Set (α × β)} : s ×ˢ t ⊆ P ↔ ∀ x ∈ s, ∀ y ∈ t, (x, y) ∈ P 
goal: s ×ˢ t ⊆ P ↔ ∀ x ∈ s, ∀ y ∈ t, (x, y) ∈ P

full_name: Set.forall_prod_set
code: theorem forall_prod_set {p : α × β → Prop} : (∀ x ∈ s ×ˢ t, p x) ↔ ∀ x ∈ s, ∀ y ∈ t, p (x, y) 
goal: (∀ x ∈ s ×ˢ t, p x) ↔ ∀ x ∈ s, ∀ y ∈ t, p (x, y)

full_name: Set.exists_prod_set
code: theorem exists_prod_set {p : α × β → Prop} : (∃ x ∈ s ×ˢ t, p x) ↔ ∃ x ∈ s, ∃ y ∈ t, p (x, y) 
goal: (∃ x ∈ s ×ˢ t, p x) ↔ ∃ x ∈ s, ∃ y ∈ t, p (x, y)

full_name: Set.prod_empty
code: @[simp]
theorem prod_empty : s ×ˢ (∅ : Set β) = ∅ 
goal: s ×ˢ ∅ = ∅

full_name: Set.empty_prod
code: @[simp]
theorem empty_prod : (∅ : Set α) ×ˢ t = ∅ 
goal: ∅ ×ˢ t = ∅

full_name: Set.univ_prod_univ
code: @[simp, mfld_simps]
theorem univ_prod_univ : @univ α ×ˢ @univ β = univ 
goal: Set.univ ×ˢ Set.univ = Set.univ

full_name: Set.univ_prod
code: theorem univ_prod {t : Set β} : (univ : Set α) ×ˢ t = Prod.snd ⁻¹' t 
goal: Set.univ ×ˢ t = Prod.snd ⁻¹' t

full_name: Set.prod_univ
code: theorem prod_univ {s : Set α} : s ×ˢ (univ : Set β) = Prod.fst ⁻¹' s 
goal: s ×ˢ Set.univ = Prod.fst ⁻¹' s

full_name: Set.prod_eq_univ
code: @[simp] lemma prod_eq_univ [Nonempty α] [Nonempty β] : s ×ˢ t = univ ↔ s = univ ∧ t = univ 
goal: s ×ˢ t = Set.univ ↔ s = Set.univ ∧ t = Set.univ

full_name: Set.singleton_prod
code: @[simp]
theorem singleton_prod : ({a} : Set α) ×ˢ t = Prod.mk a '' t 
goal: {a} ×ˢ t = Prod.mk a '' t

full_name: Set.prod_singleton
code: @[simp]
theorem prod_singleton : s ×ˢ ({b} : Set β) = (fun a => (a, b)) '' s 
goal: s ×ˢ {b} = (fun a => (a, b)) '' s

full_name: Set.singleton_prod_singleton
code: theorem singleton_prod_singleton : ({a} : Set α) ×ˢ ({b} : Set β) = {(a, b)} 
goal: {a} ×ˢ {b} = {(a, b)}

full_name: Set.union_prod
code: @[simp]
theorem union_prod : (s₁ ∪ s₂) ×ˢ t = s₁ ×ˢ t ∪ s₂ ×ˢ t 
goal: (s₁ ∪ s₂) ×ˢ t = s₁ ×ˢ t ∪ s₂ ×ˢ t

full_name: Set.prod_union
code: @[simp]
theorem prod_union : s ×ˢ (t₁ ∪ t₂) = s ×ˢ t₁ ∪ s ×ˢ t₂ 
goal: s ×ˢ (t₁ ∪ t₂) = s ×ˢ t₁ ∪ s ×ˢ t₂

full_name: Set.inter_prod
code: theorem inter_prod : (s₁ ∩ s₂) ×ˢ t = s₁ ×ˢ t ∩ s₂ ×ˢ t 
goal: (s₁ ∩ s₂) ×ˢ t = s₁ ×ˢ t ∩ s₂ ×ˢ t

full_name: Set.prod_inter
code: theorem prod_inter : s ×ˢ (t₁ ∩ t₂) = s ×ˢ t₁ ∩ s ×ˢ t₂ 
goal: s ×ˢ (t₁ ∩ t₂) = s ×ˢ t₁ ∩ s ×ˢ t₂

full_name: Set.prod_inter_prod
code: @[mfld_simps]
theorem prod_inter_prod : s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂) 
goal: s₁ ×ˢ t₁ ∩ s₂ ×ˢ t₂ = (s₁ ∩ s₂) ×ˢ (t₁ ∩ t₂)

full_name: Set.compl_prod_eq_union
code: lemma compl_prod_eq_union {α β : Type*} (s : Set α) (t : Set β) :
    (s ×ˢ t)ᶜ = (sᶜ ×ˢ univ) ∪ (univ ×ˢ tᶜ) 
goal: (s ×ˢ t)ᶜ = sᶜ ×ˢ Set.univ ∪ Set.univ ×ˢ tᶜ

full_name: Set.disjoint_prod
code: @[simp]
theorem disjoint_prod : Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂ 
goal: Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) ↔ Disjoint s₁ s₂ ∨ Disjoint t₁ t₂

full_name: Set.Disjoint.set_prod_left
code: theorem Disjoint.set_prod_left (hs : Disjoint s₁ s₂) (t₁ t₂ : Set β) :
    Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) 
goal: Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂)

full_name: Set.Disjoint.set_prod_right
code: theorem Disjoint.set_prod_right (ht : Disjoint t₁ t₂) (s₁ s₂ : Set α) :
    Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂) 
goal: Disjoint (s₁ ×ˢ t₁) (s₂ ×ˢ t₂)

full_name: Set.insert_prod
code: theorem insert_prod : insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t 
goal: insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t

full_name: Set.prod_insert
code: theorem prod_insert : s ×ˢ insert b t = (fun a => (a, b)) '' s ∪ s ×ˢ t 
goal: s ×ˢ insert b t = (fun a => (a, b)) '' s ∪ s ×ˢ t

full_name: Set.prod_preimage_eq
code: theorem prod_preimage_eq {f : γ → α} {g : δ → β} :
    (f ⁻¹' s) ×ˢ (g ⁻¹' t) = (fun p : γ × δ => (f p.1, g p.2)) ⁻¹' s ×ˢ t 
goal: (f ⁻¹' s) ×ˢ (g ⁻¹' t) = (fun p => (f p.1, g p.2)) ⁻¹' s ×ˢ t

full_name: Set.prod_preimage_left
code: theorem prod_preimage_left {f : γ → α} :
    (f ⁻¹' s) ×ˢ t = (fun p : γ × β => (f p.1, p.2)) ⁻¹' s ×ˢ t 
goal: (f ⁻¹' s) ×ˢ t = (fun p => (f p.1, p.2)) ⁻¹' s ×ˢ t

full_name: Set.prod_preimage_right
code: theorem prod_preimage_right {g : δ → β} :
    s ×ˢ (g ⁻¹' t) = (fun p : α × δ => (p.1, g p.2)) ⁻¹' s ×ˢ t 
goal: s ×ˢ (g ⁻¹' t) = (fun p => (p.1, g p.2)) ⁻¹' s ×ˢ t

full_name: Set.preimage_prod_map_prod
code: theorem preimage_prod_map_prod (f : α → β) (g : γ → δ) (s : Set β) (t : Set δ) :
    Prod.map f g ⁻¹' s ×ˢ t = (f ⁻¹' s) ×ˢ (g ⁻¹' t) 
goal: Prod.map f g ⁻¹' s ×ˢ t = (f ⁻¹' s) ×ˢ (g ⁻¹' t)

full_name: Set.mk_preimage_prod
code: theorem mk_preimage_prod (f : γ → α) (g : γ → β) :
    (fun x => (f x, g x)) ⁻¹' s ×ˢ t = f ⁻¹' s ∩ g ⁻¹' t 
goal: (fun x => (f x, g x)) ⁻¹' s ×ˢ t = f ⁻¹' s ∩ g ⁻¹' t

full_name: Set.mk_preimage_prod_left
code: @[simp]
theorem mk_preimage_prod_left (hb : b ∈ t) : (fun a => (a, b)) ⁻¹' s ×ˢ t = s 
goal: (fun a => (a, b)) ⁻¹' s ×ˢ t = s

full_name: Set.mk_preimage_prod_right
code: @[simp]
theorem mk_preimage_prod_right (ha : a ∈ s) : Prod.mk a ⁻¹' s ×ˢ t = t 
goal: Prod.mk a ⁻¹' s ×ˢ t = t

full_name: Set.mk_preimage_prod_left_eq_empty
code: @[simp]
theorem mk_preimage_prod_left_eq_empty (hb : b ∉ t) : (fun a => (a, b)) ⁻¹' s ×ˢ t = ∅ 
goal: (fun a => (a, b)) ⁻¹' s ×ˢ t = ∅

full_name: Set.mk_preimage_prod_right_eq_empty
code: @[simp]
theorem mk_preimage_prod_right_eq_empty (ha : a ∉ s) : Prod.mk a ⁻¹' s ×ˢ t = ∅ 
goal: Prod.mk a ⁻¹' s ×ˢ t = ∅

full_name: Set.mk_preimage_prod_left_eq_if
code: theorem mk_preimage_prod_left_eq_if [DecidablePred (· ∈ t)] :
    (fun a => (a, b)) ⁻¹' s ×ˢ t = if b ∈ t then s else ∅ 
goal: (fun a => (a, b)) ⁻¹' s ×ˢ t = if b ∈ t then s else ∅

full_name: Set.mk_preimage_prod_right_eq_if
code: theorem mk_preimage_prod_right_eq_if [DecidablePred (· ∈ s)] :
    Prod.mk a ⁻¹' s ×ˢ t = if a ∈ s then t else ∅ 
goal: Prod.mk a ⁻¹' s ×ˢ t = if a ∈ s then t else ∅

full_name: Set.mk_preimage_prod_left_fn_eq_if
code: theorem mk_preimage_prod_left_fn_eq_if [DecidablePred (· ∈ t)] (f : γ → α) :
    (fun a => (f a, b)) ⁻¹' s ×ˢ t = if b ∈ t then f ⁻¹' s else ∅ 
goal: (fun a => (f a, b)) ⁻¹' s ×ˢ t = if b ∈ t then f ⁻¹' s else ∅

full_name: Set.mk_preimage_prod_right_fn_eq_if
code: theorem mk_preimage_prod_right_fn_eq_if [DecidablePred (· ∈ s)] (g : δ → β) :
    (fun b => (a, g b)) ⁻¹' s ×ˢ t = if a ∈ s then g ⁻¹' t else ∅ 
goal: (fun b => (a, g b)) ⁻¹' s ×ˢ t = if a ∈ s then g ⁻¹' t else ∅

full_name: Set.preimage_swap_prod
code: @[simp]
theorem preimage_swap_prod (s : Set α) (t : Set β) : Prod.swap ⁻¹' s ×ˢ t = t ×ˢ s 
goal: Prod.swap ⁻¹' s ×ˢ t = t ×ˢ s

full_name: Set.image_swap_prod
code: @[simp]
theorem image_swap_prod (s : Set α) (t : Set β) : Prod.swap '' s ×ˢ t = t ×ˢ s 
goal: Prod.swap '' s ×ˢ t = t ×ˢ s

full_name: Set.prod_image_image_eq
code: theorem prod_image_image_eq {m₁ : α → γ} {m₂ : β → δ} :
    (m₁ '' s) ×ˢ (m₂ '' t) = (fun p : α × β => (m₁ p.1, m₂ p.2)) '' s ×ˢ t 
goal: (m₁ '' s) ×ˢ (m₂ '' t) = (fun p => (m₁ p.1, m₂ p.2)) '' s ×ˢ t

full_name: Set.prod_range_range_eq
code: theorem prod_range_range_eq {m₁ : α → γ} {m₂ : β → δ} :
    range m₁ ×ˢ range m₂ = range fun p : α × β => (m₁ p.1, m₂ p.2) 
goal: Set.range m₁ ×ˢ Set.range m₂ = Set.range fun p => (m₁ p.1, m₂ p.2)

full_name: Set.range_prod_map
code: @[simp, mfld_simps]
theorem range_prod_map {m₁ : α → γ} {m₂ : β → δ} : range (Prod.map m₁ m₂) = range m₁ ×ˢ range m₂ 
goal: Set.range (Prod.map m₁ m₂) = Set.range m₁ ×ˢ Set.range m₂

full_name: Set.prod_range_univ_eq
code: theorem prod_range_univ_eq {m₁ : α → γ} :
    range m₁ ×ˢ (univ : Set β) = range fun p : α × β => (m₁ p.1, p.2) 
goal: Set.range m₁ ×ˢ Set.univ = Set.range fun p => (m₁ p.1, p.2)

full_name: Set.prod_univ_range_eq
code: theorem prod_univ_range_eq {m₂ : β → δ} :
    (univ : Set α) ×ˢ range m₂ = range fun p : α × β => (p.1, m₂ p.2) 
goal: Set.univ ×ˢ Set.range m₂ = Set.range fun p => (p.1, m₂ p.2)

full_name: Set.range_pair_subset
code: theorem range_pair_subset (f : α → β) (g : α → γ) :
    (range fun x => (f x, g x)) ⊆ range f ×ˢ range g 
goal: (Set.range fun x => (f x, g x)) ⊆ Set.range f ×ˢ Set.range g

full_name: Set.Nonempty.prod
code: theorem Nonempty.prod : s.Nonempty → t.Nonempty → (s ×ˢ t).Nonempty 
goal: s.Nonempty → t.Nonempty → (s ×ˢ t).Nonempty

full_name: Set.Nonempty.fst
code: theorem Nonempty.fst : (s ×ˢ t).Nonempty → s.Nonempty 
goal: (s ×ˢ t).Nonempty → s.Nonempty

full_name: Set.Nonempty.snd
code: theorem Nonempty.snd : (s ×ˢ t).Nonempty → t.Nonempty 
goal: (s ×ˢ t).Nonempty → t.Nonempty

full_name: Set.prod_nonempty_iff
code: @[simp]
theorem prod_nonempty_iff : (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
goal: (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty

full_name: Set.prod_eq_empty_iff
code: @[simp]
theorem prod_eq_empty_iff : s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅ 
goal: s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅

full_name: Set.prod_sub_preimage_iff
code: theorem prod_sub_preimage_iff {W : Set γ} {f : α × β → γ} :
    s ×ˢ t ⊆ f ⁻¹' W ↔ ∀ a b, a ∈ s → b ∈ t → f (a, b) ∈ W 
goal: s ×ˢ t ⊆ f ⁻¹' W ↔ ∀ (a : α) (b : β), a ∈ s → b ∈ t → f (a, b) ∈ W

full_name: Set.image_prod_mk_subset_prod
code: theorem image_prod_mk_subset_prod {f : α → β} {g : α → γ} {s : Set α} :
    (fun x => (f x, g x)) '' s ⊆ (f '' s) ×ˢ (g '' s) 
goal: (fun x => (f x, g x)) '' s ⊆ (f '' s) ×ˢ (g '' s)

full_name: Set.image_prod_mk_subset_prod_left
code: theorem image_prod_mk_subset_prod_left (hb : b ∈ t) : (fun a => (a, b)) '' s ⊆ s ×ˢ t 
goal: (fun a => (a, b)) '' s ⊆ s ×ˢ t

full_name: Set.image_prod_mk_subset_prod_right
code: theorem image_prod_mk_subset_prod_right (ha : a ∈ s) : Prod.mk a '' t ⊆ s ×ˢ t 
goal: Prod.mk a '' t ⊆ s ×ˢ t

full_name: Set.prod_subset_preimage_fst
code: theorem prod_subset_preimage_fst (s : Set α) (t : Set β) : s ×ˢ t ⊆ Prod.fst ⁻¹' s 
goal: s ×ˢ t ⊆ Prod.fst ⁻¹' s

full_name: Set.fst_image_prod_subset
code: theorem fst_image_prod_subset (s : Set α) (t : Set β) : Prod.fst '' s ×ˢ t ⊆ s 
goal: Prod.fst '' s ×ˢ t ⊆ s

full_name: Set.fst_image_prod
code: theorem fst_image_prod (s : Set β) {t : Set α} (ht : t.Nonempty) : Prod.fst '' s ×ˢ t = s 
goal: Prod.fst '' s ×ˢ t = s

full_name: Set.prod_subset_preimage_snd
code: theorem prod_subset_preimage_snd (s : Set α) (t : Set β) : s ×ˢ t ⊆ Prod.snd ⁻¹' t 
goal: s ×ˢ t ⊆ Prod.snd ⁻¹' t

full_name: Set.snd_image_prod_subset
code: theorem snd_image_prod_subset (s : Set α) (t : Set β) : Prod.snd '' s ×ˢ t ⊆ t 
goal: Prod.snd '' s ×ˢ t ⊆ t

full_name: Set.snd_image_prod
code: theorem snd_image_prod {s : Set α} (hs : s.Nonempty) (t : Set β) : Prod.snd '' s ×ˢ t = t 
goal: Prod.snd '' s ×ˢ t = t

full_name: Set.prod_diff_prod
code: theorem prod_diff_prod : s ×ˢ t \ s₁ ×ˢ t₁ = s ×ˢ (t \ t₁) ∪ (s \ s₁) ×ˢ t 
goal: s ×ˢ t \ s₁ ×ˢ t₁ = s ×ˢ (t \ t₁) ∪ (s \ s₁) ×ˢ t

full_name: Set.prod_subset_prod_iff
code: /-- A product set is included in a product set if and only factors are included, or a factor of the
first set is empty. -/
theorem prod_subset_prod_iff : s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t ⊆ t₁ ∨ s = ∅ ∨ t = ∅ 
goal: s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t ⊆ t₁ ∨ s = ∅ ∨ t = ∅

full_name: Set.prod_eq_prod_iff_of_nonempty
code: theorem prod_eq_prod_iff_of_nonempty (h : (s ×ˢ t).Nonempty) :
    s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁ 
goal: s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁

full_name: Set.prod_eq_prod_iff
code: theorem prod_eq_prod_iff :
    s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁ ∨ (s = ∅ ∨ t = ∅) ∧ (s₁ = ∅ ∨ t₁ = ∅) 
goal: s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁ ∨ (s = ∅ ∨ t = ∅) ∧ (s₁ = ∅ ∨ t₁ = ∅)

full_name: Set.prod_eq_iff_eq
code: @[simp]
theorem prod_eq_iff_eq (ht : t.Nonempty) : s ×ˢ t = s₁ ×ˢ t ↔ s = s₁ 
goal: s ×ˢ t = s₁ ×ˢ t ↔ s = s₁

full_name: Monotone.set_prod
code: theorem _root_.Monotone.set_prod (hf : Monotone f) (hg : Monotone g) :
    Monotone fun x => f x ×ˢ g x 
goal: Monotone fun x => f x ×ˢ g x

full_name: Antitone.set_prod
code: theorem _root_.Antitone.set_prod (hf : Antitone f) (hg : Antitone g) :
    Antitone fun x => f x ×ˢ g x 
goal: Antitone fun x => f x ×ˢ g x

full_name: MonotoneOn.set_prod
code: theorem _root_.MonotoneOn.set_prod (hf : MonotoneOn f s) (hg : MonotoneOn g s) :
    MonotoneOn (fun x => f x ×ˢ g x) s 
goal: MonotoneOn (fun x => f x ×ˢ g x) s

full_name: AntitoneOn.set_prod
code: theorem _root_.AntitoneOn.set_prod (hf : AntitoneOn f s) (hg : AntitoneOn g s) :
    AntitoneOn (fun x => f x ×ˢ g x) s 
goal: AntitoneOn (fun x => f x ×ˢ g x) s

full_name: Set.diagonal_nonempty
code: lemma diagonal_nonempty [Nonempty α] : (diagonal α).Nonempty 
goal: (Set.diagonal α).Nonempty

full_name: Set.decidableMemDiagonal
code: instance decidableMemDiagonal [h : DecidableEq α] (x : α × α) : Decidable (x ∈ diagonal α) 
goal: Decidable (x ∈ Set.diagonal α)

full_name: Set.preimage_coe_coe_diagonal
code: theorem preimage_coe_coe_diagonal (s : Set α) :
    Prod.map (fun x : s => (x : α)) (fun x : s => (x : α)) ⁻¹' diagonal α = diagonal s 
goal: (Prod.map (fun x => ↑x) fun x => ↑x) ⁻¹' Set.diagonal α = Set.diagonal ↑s

full_name: Set.range_diag
code: @[simp]
theorem range_diag : (range fun x => (x, x)) = diagonal α 
goal: (Set.range fun x => (x, x)) = Set.diagonal α

full_name: Set.diagonal_subset_iff
code: theorem diagonal_subset_iff {s} : diagonal α ⊆ s ↔ ∀ x, (x, x) ∈ s 
goal: Set.diagonal α ⊆ s ↔ ∀ (x : α), (x, x) ∈ s

full_name: Set.prod_subset_compl_diagonal_iff_disjoint
code: @[simp]
theorem prod_subset_compl_diagonal_iff_disjoint : s ×ˢ t ⊆ (diagonal α)ᶜ ↔ Disjoint s t 
goal: s ×ˢ t ⊆ (Set.diagonal α)ᶜ ↔ Disjoint s t

full_name: Set.diag_preimage_prod
code: @[simp]
theorem diag_preimage_prod (s t : Set α) : (fun x => (x, x)) ⁻¹' s ×ˢ t = s ∩ t 
goal: (fun x => (x, x)) ⁻¹' s ×ˢ t = s ∩ t

full_name: Set.diag_preimage_prod_self
code: theorem diag_preimage_prod_self (s : Set α) : (fun x => (x, x)) ⁻¹' s ×ˢ s = s 
goal: (fun x => (x, x)) ⁻¹' s ×ˢ s = s

full_name: Set.diag_image
code: theorem diag_image (s : Set α) : (fun x => (x, x)) '' s = diagonal α ∩ s ×ˢ s 
goal: (fun x => (x, x)) '' s = Set.diagonal α ∩ s ×ˢ s

full_name: Set.diagonal_eq_univ_iff
code: theorem diagonal_eq_univ_iff : diagonal α = univ ↔ Subsingleton α 
goal: Set.diagonal α = Set.univ ↔ Subsingleton α

full_name: Set.diagonal_eq_univ
code: theorem diagonal_eq_univ [Subsingleton α] : diagonal α = univ 
goal: Set.diagonal α = Set.univ

full_name: Set.range_const_eq_diagonal
code: /-- A function is `Function.const α a` for some `a` if and only if `∀ x y, f x = f y`. -/
theorem range_const_eq_diagonal {α β : Type*} [hβ : Nonempty β] :
    range (const α) = {f : α → β | ∀ x y, f x = f y} 
goal: Set.range (Function.const α) = {f | ∀ (x y : α), f x = f y}

full_name: Function.Pullback
code: /-- The fiber product $X \times_Y Z$. -/
abbrev Function.Pullback (f : X → Y) (g : Z → Y) 
goal: Type (max 0 u_3 u_1)

full_name: Function.PullbackSelf
code: /-- The fiber product $X \times_Y X$. -/
abbrev Function.PullbackSelf (f : X → Y) 
goal: Type u_1

full_name: Function.Pullback.fst
code: /-- The projection from the fiber product to the first factor. -/
def Function.Pullback.fst {f : X → Y} {g : Z → Y} (p : f.Pullback g) : X 
goal: X

full_name: Function.Pullback.snd
code: /-- The projection from the fiber product to the second factor. -/
def Function.Pullback.snd {f : X → Y} {g : Z → Y} (p : f.Pullback g) : Z 
goal: Z

full_name: Function.pullback_comm_sq
code: lemma Function.pullback_comm_sq (f : X → Y) (g : Z → Y) :
    f ∘ @fst X Y Z f g = g ∘ @snd X Y Z f g 
goal: f ∘ Function.Pullback.fst = g ∘ Function.Pullback.snd

full_name: toPullbackDiag
code: /-- The diagonal map $\Delta: X \to X \times_Y X$. -/
def toPullbackDiag (f : X → Y) (x : X) : f.Pullback f 
goal: Function.Pullback f f

full_name: Function.pullbackDiagonal
code: /-- The diagonal $\Delta(X) \subseteq X \times_Y X$. -/
def Function.pullbackDiagonal (f : X → Y) : Set (f.Pullback f) 
goal: Set (Function.Pullback f f)

full_name: Function.mapPullback
code: /-- Three functions between the three pairs of spaces $X_i, Y_i, Z_i$ that are compatible
  induce a function $X_1 \times_{Y_1} Z_1 \to X_2 \times_{Y_2} Z_2$. -/
def Function.mapPullback {X₁ X₂ Y₁ Y₂ Z₁ Z₂}
    {f₁ : X₁ → Y₁} {g₁ : Z₁ → Y₁} {f₂ : X₂ → Y₂} {g₂ : Z₂ → Y₂}
    (mapX : X₁ → X₂) (mapY : Y₁ → Y₂) (mapZ : Z₁ → Z₂)
    (commX : f₂ ∘ mapX = mapY ∘ f₁) (commZ : g₂ ∘ mapZ = mapY ∘ g₁)
    (p : f₁.Pullback g₁) : f₂.Pullback g₂ 
goal: Function.Pullback f₂ g₂

full_name: Function.PullbackSelf.map_fst
code: /-- The projection $(X \times_Y Z) \times_Z (X \times_Y Z) \to X \times_Y X$. -/
def Function.PullbackSelf.map_fst {f : X → Y} {g : Z → Y} :
    (@snd X Y Z f g).PullbackSelf → f.PullbackSelf 
goal: Function.PullbackSelf Function.Pullback.snd → Function.PullbackSelf f

full_name: Function.PullbackSelf.map_snd
code: /-- The projection $(X \times_Y Z) \times_X (X \times_Y Z) \to Z \times_Y Z$. -/
def Function.PullbackSelf.map_snd {f : X → Y} {g : Z → Y} :
    (@fst X Y Z f g).PullbackSelf → g.PullbackSelf 
goal: Function.PullbackSelf Function.Pullback.fst → Function.PullbackSelf g

full_name: preimage_map_fst_pullbackDiagonal
code: theorem preimage_map_fst_pullbackDiagonal {f : X → Y} {g : Z → Y} :
    @map_fst X Y Z f g ⁻¹' pullbackDiagonal f = pullbackDiagonal (@snd X Y Z f g) 
goal: Function.PullbackSelf.map_fst ⁻¹' Function.pullbackDiagonal f = Function.pullbackDiagonal Function.Pullback.snd

full_name: Function.Injective.preimage_pullbackDiagonal
code: theorem Function.Injective.preimage_pullbackDiagonal {f : X → Y} {g : Z → X} (inj : g.Injective) :
    mapPullback g id g (by rfl) (by rfl) ⁻¹' pullbackDiagonal f = pullbackDiagonal (f ∘ g) 
goal: Function.mapPullback g id g ⋯ ⋯ ⁻¹' Function.pullbackDiagonal f = Function.pullbackDiagonal (f ∘ g)

full_name: image_toPullbackDiag
code: theorem image_toPullbackDiag (f : X → Y) (s : Set X) :
    toPullbackDiag f '' s = pullbackDiagonal f ∩ Subtype.val ⁻¹' s ×ˢ s 
goal: toPullbackDiag f '' s = Function.pullbackDiagonal f ∩ Subtype.val ⁻¹' s ×ˢ s

full_name: range_toPullbackDiag
code: theorem range_toPullbackDiag (f : X → Y) : range (toPullbackDiag f) = pullbackDiagonal f 
goal: Set.range (toPullbackDiag f) = Function.pullbackDiagonal f

full_name: injective_toPullbackDiag
code: theorem injective_toPullbackDiag (f : X → Y) : (toPullbackDiag f).Injective 
goal: Function.Injective (toPullbackDiag f)

full_name: Set.offDiag_mono
code: theorem offDiag_mono : Monotone (offDiag : Set α → Set (α × α)) 
goal: Monotone Set.offDiag

full_name: Set.offDiag_nonempty
code: @[simp]
theorem offDiag_nonempty : s.offDiag.Nonempty ↔ s.Nontrivial 
goal: s.offDiag.Nonempty ↔ s.Nontrivial

full_name: Set.offDiag_eq_empty
code: @[simp]
theorem offDiag_eq_empty : s.offDiag = ∅ ↔ s.Subsingleton 
goal: s.offDiag = ∅ ↔ s.Subsingleton

full_name: Set.offDiag_subset_prod
code: theorem offDiag_subset_prod : s.offDiag ⊆ s ×ˢ s 
goal: s.offDiag ⊆ s ×ˢ s

full_name: Set.offDiag_eq_sep_prod
code: theorem offDiag_eq_sep_prod : s.offDiag = { x ∈ s ×ˢ s | x.1 ≠ x.2 } 
goal: s.offDiag = {x | x ∈ s ×ˢ s ∧ x.1 ≠ x.2}

full_name: Set.offDiag_empty
code: @[simp]
theorem offDiag_empty : (∅ : Set α).offDiag = ∅ 
goal: ∅.offDiag = ∅

full_name: Set.offDiag_singleton
code: @[simp]
theorem offDiag_singleton (a : α) : ({a} : Set α).offDiag = ∅ 
goal: {a}.offDiag = ∅

full_name: Set.offDiag_univ
code: @[simp]
theorem offDiag_univ : (univ : Set α).offDiag = (diagonal α)ᶜ 
goal: Set.univ.offDiag = (Set.diagonal α)ᶜ

full_name: Set.prod_sdiff_diagonal
code: @[simp]
theorem prod_sdiff_diagonal : s ×ˢ s \ diagonal α = s.offDiag 
goal: s ×ˢ s \ Set.diagonal α = s.offDiag

full_name: Set.disjoint_diagonal_offDiag
code: @[simp]
theorem disjoint_diagonal_offDiag : Disjoint (diagonal α) s.offDiag 
goal: Disjoint (Set.diagonal α) s.offDiag

full_name: Set.offDiag_inter
code: theorem offDiag_inter : (s ∩ t).offDiag = s.offDiag ∩ t.offDiag 
goal: (s ∩ t).offDiag = s.offDiag ∩ t.offDiag

full_name: Set.offDiag_union
code: theorem offDiag_union (h : Disjoint s t) :
    (s ∪ t).offDiag = s.offDiag ∪ t.offDiag ∪ s ×ˢ t ∪ t ×ˢ s 
goal: (s ∪ t).offDiag = s.offDiag ∪ t.offDiag ∪ s ×ˢ t ∪ t ×ˢ s

full_name: Set.offDiag_insert
code: theorem offDiag_insert (ha : a ∉ s) : (insert a s).offDiag = s.offDiag ∪ {a} ×ˢ s ∪ s ×ˢ {a} 
goal: (insert a s).offDiag = s.offDiag ∪ {a} ×ˢ s ∪ s ×ˢ {a}

full_name: Set.empty_pi
code: @[simp]
theorem empty_pi (s : ∀ i, Set (α i)) : pi ∅ s = univ 
goal: ∅.pi s = Set.univ

full_name: Set.subsingleton_univ_pi
code: theorem subsingleton_univ_pi (ht : ∀ i, (t i).Subsingleton) :
    (univ.pi t).Subsingleton 
goal: (Set.univ.pi t).Subsingleton

full_name: Set.pi_univ
code: @[simp]
theorem pi_univ (s : Set ι) : (pi s fun i => (univ : Set (α i))) = univ 
goal: (s.pi fun i => Set.univ) = Set.univ

full_name: Set.pi_univ_ite
code: @[simp]
theorem pi_univ_ite (s : Set ι) [DecidablePred (· ∈ s)] (t : ∀ i, Set (α i)) :
    (pi univ fun i => if i ∈ s then t i else univ) = s.pi t 
goal: (Set.univ.pi fun i => if i ∈ s then t i else Set.univ) = s.pi t

full_name: Set.pi_mono
code: theorem pi_mono (h : ∀ i ∈ s, t₁ i ⊆ t₂ i) : pi s t₁ ⊆ pi s t₂ 
goal: s.pi t₁ ⊆ s.pi t₂

full_name: Set.pi_inter_distrib
code: theorem pi_inter_distrib : (s.pi fun i => t i ∩ t₁ i) = s.pi t ∩ s.pi t₁ 
goal: (s.pi fun i => t i ∩ t₁ i) = s.pi t ∩ s.pi t₁

full_name: Set.pi_congr
code: theorem pi_congr (h : s₁ = s₂) (h' : ∀ i ∈ s₁, t₁ i = t₂ i) : s₁.pi t₁ = s₂.pi t₂ 
goal: s₁.pi t₁ = s₂.pi t₂

full_name: Set.pi_eq_empty
code: theorem pi_eq_empty (hs : i ∈ s) (ht : t i = ∅) : s.pi t = ∅ 
goal: s.pi t = ∅

full_name: Set.univ_pi_eq_empty
code: theorem univ_pi_eq_empty (ht : t i = ∅) : pi univ t = ∅ 
goal: Set.univ.pi t = ∅

full_name: Set.pi_nonempty_iff
code: theorem pi_nonempty_iff : (s.pi t).Nonempty ↔ ∀ i, ∃ x, i ∈ s → x ∈ t i 
goal: (s.pi t).Nonempty ↔ ∀ (i : ι), ∃ x, i ∈ s → x ∈ t i

full_name: Set.univ_pi_nonempty_iff
code: theorem univ_pi_nonempty_iff : (pi univ t).Nonempty ↔ ∀ i, (t i).Nonempty 
goal: (Set.univ.pi t).Nonempty ↔ ∀ (i : ι), (t i).Nonempty

full_name: Set.pi_eq_empty_iff
code: theorem pi_eq_empty_iff : s.pi t = ∅ ↔ ∃ i, IsEmpty (α i) ∨ i ∈ s ∧ t i = ∅ 
goal: s.pi t = ∅ ↔ ∃ i, IsEmpty (α i) ∨ i ∈ s ∧ t i = ∅

full_name: Set.univ_pi_eq_empty_iff
code: @[simp]
theorem univ_pi_eq_empty_iff : pi univ t = ∅ ↔ ∃ i, t i = ∅ 
goal: Set.univ.pi t = ∅ ↔ ∃ i, t i = ∅

full_name: Set.univ_pi_empty
code: @[simp]
theorem univ_pi_empty [h : Nonempty ι] : pi univ (fun _ => ∅ : ∀ i, Set (α i)) = ∅ 
goal: (Set.univ.pi fun x => ∅) = ∅

full_name: Set.disjoint_univ_pi
code: @[simp]
theorem disjoint_univ_pi : Disjoint (pi univ t₁) (pi univ t₂) ↔ ∃ i, Disjoint (t₁ i) (t₂ i) 
goal: Disjoint (Set.univ.pi t₁) (Set.univ.pi t₂) ↔ ∃ i, Disjoint (t₁ i) (t₂ i)

full_name: Set.Disjoint.set_pi
code: theorem Disjoint.set_pi (hi : i ∈ s) (ht : Disjoint (t₁ i) (t₂ i)) : Disjoint (s.pi t₁) (s.pi t₂) 
goal: Disjoint (s.pi t₁) (s.pi t₂)

full_name: Set.uniqueElim_preimage
code: theorem uniqueElim_preimage [Unique ι] (t : ∀ i, Set (α i)) :
    uniqueElim ⁻¹' pi univ t = t (default : ι) 
goal: uniqueElim ⁻¹' Set.univ.pi t = t default

full_name: Set.pi_eq_empty_iff'
code: theorem pi_eq_empty_iff' : s.pi t = ∅ ↔ ∃ i ∈ s, t i = ∅ 
goal: s.pi t = ∅ ↔ ∃ i ∈ s, t i = ∅

full_name: Set.disjoint_pi
code: @[simp]
theorem disjoint_pi : Disjoint (s.pi t₁) (s.pi t₂) ↔ ∃ i ∈ s, Disjoint (t₁ i) (t₂ i) 
goal: Disjoint (s.pi t₁) (s.pi t₂) ↔ ∃ i ∈ s, Disjoint (t₁ i) (t₂ i)

full_name: Set.range_dcomp
code: theorem range_dcomp (f : ∀ i, α i → β i) :
    (range fun g : ∀ i, α i => fun i => f i (g i)) = pi univ fun i => range (f i) 
goal: (Set.range fun g i => f i (g i)) = Set.univ.pi fun i => Set.range (f i)

full_name: Set.insert_pi
code: @[simp]
theorem insert_pi (i : ι) (s : Set ι) (t : ∀ i, Set (α i)) :
    pi (insert i s) t = eval i ⁻¹' t i ∩ pi s t 
goal: (insert i s).pi t = Function.eval i ⁻¹' t i ∩ s.pi t

full_name: Set.singleton_pi
code: @[simp]
theorem singleton_pi (i : ι) (t : ∀ i, Set (α i)) : pi {i} t = eval i ⁻¹' t i 
goal: {i}.pi t = Function.eval i ⁻¹' t i

full_name: Set.singleton_pi'
code: theorem singleton_pi' (i : ι) (t : ∀ i, Set (α i)) : pi {i} t = { x | x i ∈ t i } 
goal: {i}.pi t = {x | x i ∈ t i}

full_name: Set.univ_pi_singleton
code: theorem univ_pi_singleton (f : ∀ i, α i) : (pi univ fun i => {f i}) = ({f} : Set (∀ i, α i)) 
goal: (Set.univ.pi fun i => {f i}) = {f}

full_name: Set.preimage_pi
code: theorem preimage_pi (s : Set ι) (t : ∀ i, Set (β i)) (f : ∀ i, α i → β i) :
    (fun (g : ∀ i, α i) i => f _ (g i)) ⁻¹' s.pi t = s.pi fun i => f i ⁻¹' t i 
goal: (fun g i => f i (g i)) ⁻¹' s.pi t = s.pi fun i => f i ⁻¹' t i

full_name: Set.pi_if
code: theorem pi_if {p : ι → Prop} [h : DecidablePred p] (s : Set ι) (t₁ t₂ : ∀ i, Set (α i)) :
    (pi s fun i => if p i then t₁ i else t₂ i) =
      pi ({ i ∈ s | p i }) t₁ ∩ pi ({ i ∈ s | ¬p i }) t₂ 
goal: (s.pi fun i => if p i then t₁ i else t₂ i) = {i | i ∈ s ∧ p i}.pi t₁ ∩ {i | i ∈ s ∧ ¬p i}.pi t₂

full_name: Set.union_pi
code: theorem union_pi : (s₁ ∪ s₂).pi t = s₁.pi t ∩ s₂.pi t 
goal: (s₁ ∪ s₂).pi t = s₁.pi t ∩ s₂.pi t

full_name: Set.union_pi_inter
code: theorem union_pi_inter
    (ht₁ : ∀ i ∉ s₁, t₁ i = univ) (ht₂ : ∀ i ∉ s₂, t₂ i = univ) :
    (s₁ ∪ s₂).pi (fun i ↦ t₁ i ∩ t₂ i) = s₁.pi t₁ ∩ s₂.pi t₂ 
goal: ((s₁ ∪ s₂).pi fun i => t₁ i ∩ t₂ i) = s₁.pi t₁ ∩ s₂.pi t₂

full_name: Set.pi_inter_compl
code: @[simp]
theorem pi_inter_compl (s : Set ι) : pi s t ∩ pi sᶜ t = pi univ t 
goal: s.pi t ∩ sᶜ.pi t = Set.univ.pi t

full_name: Set.pi_update_of_not_mem
code: theorem pi_update_of_not_mem [DecidableEq ι] (hi : i ∉ s) (f : ∀ j, α j) (a : α i)
    (t : ∀ j, α j → Set (β j)) : (s.pi fun j => t j (update f i a j)) = s.pi fun j => t j (f j) 
goal: (s.pi fun j => t j (Function.update f i a j)) = s.pi fun j => t j (f j)

full_name: Set.pi_update_of_mem
code: theorem pi_update_of_mem [DecidableEq ι] (hi : i ∈ s) (f : ∀ j, α j) (a : α i)
    (t : ∀ j, α j → Set (β j)) :
    (s.pi fun j => t j (update f i a j)) = { x | x i ∈ t i a } ∩ (s \ {i}).pi fun j => t j (f j) 
goal: (s.pi fun j => t j (Function.update f i a j)) = {x | x i ∈ t i a} ∩ (s \ {i}).pi fun j => t j (f j)

full_name: Set.univ_pi_update
code: theorem univ_pi_update [DecidableEq ι] {β : ι → Type*} (i : ι) (f : ∀ j, α j) (a : α i)
    (t : ∀ j, α j → Set (β j)) :
    (pi univ fun j => t j (update f i a j)) = { x | x i ∈ t i a } ∩ pi {i}ᶜ fun j => t j (f j) 
goal: (Set.univ.pi fun j => t j (Function.update f i a j)) = {x | x i ∈ t i a} ∩ {i}ᶜ.pi fun j => t j (f j)

full_name: Set.univ_pi_update_univ
code: theorem univ_pi_update_univ [DecidableEq ι] (i : ι) (s : Set (α i)) :
    pi univ (update (fun j : ι => (univ : Set (α j))) i s) = eval i ⁻¹' s 
goal: Set.univ.pi (Function.update (fun j => Set.univ) i s) = Function.eval i ⁻¹' s

full_name: Set.eval_image_pi_subset
code: theorem eval_image_pi_subset (hs : i ∈ s) : eval i '' s.pi t ⊆ t i 
goal: Function.eval i '' s.pi t ⊆ t i

full_name: Set.eval_image_univ_pi_subset
code: theorem eval_image_univ_pi_subset : eval i '' pi univ t ⊆ t i 
goal: Function.eval i '' Set.univ.pi t ⊆ t i

full_name: Set.subset_eval_image_pi
code: theorem subset_eval_image_pi (ht : (s.pi t).Nonempty) (i : ι) : t i ⊆ eval i '' s.pi t 
goal: t i ⊆ Function.eval i '' s.pi t

full_name: Set.eval_image_pi
code: theorem eval_image_pi (hs : i ∈ s) (ht : (s.pi t).Nonempty) : eval i '' s.pi t = t i 
goal: Function.eval i '' s.pi t = t i

full_name: Set.eval_image_pi_of_not_mem
code: lemma eval_image_pi_of_not_mem [Decidable (s.pi t).Nonempty] (hi : i ∉ s) :
    eval i '' s.pi t = if (s.pi t).Nonempty then univ else ∅ 
goal: Function.eval i '' s.pi t = if (s.pi t).Nonempty then Set.univ else ∅

full_name: Set.eval_image_univ_pi
code: @[simp]
theorem eval_image_univ_pi (ht : (pi univ t).Nonempty) :
    (fun f : ∀ i, α i => f i) '' pi univ t = t i 
goal: (fun f => f i) '' Set.univ.pi t = t i

full_name: Set.pi_subset_pi_iff
code: theorem pi_subset_pi_iff : pi s t₁ ⊆ pi s t₂ ↔ (∀ i ∈ s, t₁ i ⊆ t₂ i) ∨ pi s t₁ = ∅ 
goal: s.pi t₁ ⊆ s.pi t₂ ↔ (∀ i ∈ s, t₁ i ⊆ t₂ i) ∨ s.pi t₁ = ∅

full_name: Set.univ_pi_subset_univ_pi_iff
code: theorem univ_pi_subset_univ_pi_iff :
    pi univ t₁ ⊆ pi univ t₂ ↔ (∀ i, t₁ i ⊆ t₂ i) ∨ ∃ i, t₁ i = ∅ 
goal: Set.univ.pi t₁ ⊆ Set.univ.pi t₂ ↔ (∀ (i : ι), t₁ i ⊆ t₂ i) ∨ ∃ i, t₁ i = ∅

full_name: Set.eval_preimage
code: theorem eval_preimage [DecidableEq ι] {s : Set (α i)} :
    eval i ⁻¹' s = pi univ (update (fun i => univ) i s) 
goal: Function.eval i ⁻¹' s = Set.univ.pi (Function.update (fun i => Set.univ) i s)

full_name: Set.eval_preimage'
code: theorem eval_preimage' [DecidableEq ι] {s : Set (α i)} :
    eval i ⁻¹' s = pi {i} (update (fun i => univ) i s) 
goal: Function.eval i ⁻¹' s = {i}.pi (Function.update (fun i => Set.univ) i s)

full_name: Set.update_preimage_pi
code: theorem update_preimage_pi [DecidableEq ι] {f : ∀ i, α i} (hi : i ∈ s)
    (hf : ∀ j ∈ s, j ≠ i → f j ∈ t j) : update f i ⁻¹' s.pi t = t i 
goal: Function.update f i ⁻¹' s.pi t = t i

full_name: Set.update_image
code: theorem update_image [DecidableEq ι] (x : (i : ι) → β i) (i : ι) (s : Set (β i)) :
    update x i '' s = Set.univ.pi (update (fun j ↦ {x j}) i s) 
goal: Function.update x i '' s = Set.univ.pi (Function.update (fun j => {x j}) i s)

full_name: Set.update_preimage_univ_pi
code: theorem update_preimage_univ_pi [DecidableEq ι] {f : ∀ i, α i} (hf : ∀ j ≠ i, f j ∈ t j) :
    update f i ⁻¹' pi univ t = t i 
goal: Function.update f i ⁻¹' Set.univ.pi t = t i

full_name: Set.subset_pi_eval_image
code: theorem subset_pi_eval_image (s : Set ι) (u : Set (∀ i, α i)) : u ⊆ pi s fun i => eval i '' u 
goal: u ⊆ s.pi fun i => Function.eval i '' u

full_name: Set.univ_pi_ite
code: theorem univ_pi_ite (s : Set ι) [DecidablePred (· ∈ s)] (t : ∀ i, Set (α i)) :
    (pi univ fun i => if i ∈ s then t i else univ) = s.pi t 
goal: (Set.univ.pi fun i => if i ∈ s then t i else Set.univ) = s.pi t

full_name: Equiv.piCongrLeft_symm_preimage_pi
code: theorem piCongrLeft_symm_preimage_pi (f : ι' ≃ ι) (s : Set ι') (t : ∀ i, Set (α i)) :
    (f.piCongrLeft α).symm ⁻¹' s.pi (fun i' => t <| f i') = (f '' s).pi t 
goal: (⇑(Equiv.piCongrLeft α f).symm ⁻¹' s.pi fun i' => t (f i')) = (⇑f '' s).pi t

full_name: Equiv.piCongrLeft_symm_preimage_univ_pi
code: theorem piCongrLeft_symm_preimage_univ_pi (f : ι' ≃ ι) (t : ∀ i, Set (α i)) :
    (f.piCongrLeft α).symm ⁻¹' univ.pi (fun i' => t <| f i') = univ.pi t 
goal: (⇑(Equiv.piCongrLeft α f).symm ⁻¹' Set.univ.pi fun i' => t (f i')) = Set.univ.pi t

full_name: Equiv.piCongrLeft_preimage_pi
code: theorem piCongrLeft_preimage_pi (f : ι' ≃ ι) (s : Set ι') (t : ∀ i, Set (α i)) :
    f.piCongrLeft α ⁻¹' (f '' s).pi t = s.pi fun i => t (f i) 
goal: ⇑(Equiv.piCongrLeft α f) ⁻¹' (⇑f '' s).pi t = s.pi fun i => t (f i)

full_name: Equiv.piCongrLeft_preimage_univ_pi
code: theorem piCongrLeft_preimage_univ_pi (f : ι' ≃ ι) (t : ∀ i, Set (α i)) :
    f.piCongrLeft α ⁻¹' univ.pi t = univ.pi fun i => t (f i) 
goal: ⇑(Equiv.piCongrLeft α f) ⁻¹' Set.univ.pi t = Set.univ.pi fun i => t (f i)

full_name: Equiv.sumPiEquivProdPi_symm_preimage_univ_pi
code: theorem sumPiEquivProdPi_symm_preimage_univ_pi (π : ι ⊕ ι' → Type*) (t : ∀ i, Set (π i)) :
    (sumPiEquivProdPi π).symm ⁻¹' univ.pi t =
    univ.pi (fun i => t (.inl i)) ×ˢ univ.pi fun i => t (.inr i) 
goal: ⇑(Equiv.sumPiEquivProdPi π).symm ⁻¹' Set.univ.pi t =
  (Set.univ.pi fun i => t (Sum.inl i)) ×ˢ Set.univ.pi fun i => t (Sum.inr i)