ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Set.mk_preimage_prod_left
@[simp]
theorem mk_preimage_prod_left (hb : b ∈ t) : (fun a => (a, b)) ⁻¹' s ×ˢ t = s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {b : β} (hb : b ∈ t)
Goal: (fun a => (a, b)) ⁻¹' s ×ˢ t = s
-- Set.mk_preimage_prod_right
@[simp]
theorem mk_preimage_prod_right (ha : a ∈ s) : Prod.mk a ⁻¹' s ×ˢ t = t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {a : α} (ha : a ∈ s)
Goal: Prod.mk a ⁻¹' s ×ˢ t = t
-- Set.mk_preimage_prod_left_eq_empty
@[simp]
theorem mk_preimage_prod_left_eq_empty (hb : b ∉ t) : (fun a => (a, b)) ⁻¹' s ×ˢ t = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {b : β} (hb : b ∉ t)
Goal: (fun a => (a, b)) ⁻¹' s ×ˢ t = ∅
-- Set.mk_preimage_prod_right_eq_empty
@[simp]
theorem mk_preimage_prod_right_eq_empty (ha : a ∉ s) : Prod.mk a ⁻¹' s ×ˢ t = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {a : α} (ha : a ∉ s)
Goal: Prod.mk a ⁻¹' s ×ˢ t = ∅
-- Set.mk_preimage_prod_left_eq_if
theorem mk_preimage_prod_left_eq_if [DecidablePred (· ∈ t)] :
    (fun a => (a, b)) ⁻¹' s ×ˢ t = if b ∈ t then s else ∅ 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {b : β} [DecidablePred fun x => x ∈ t]
Goal: (fun a => (a, b)) ⁻¹' s ×ˢ t = if b ∈ t then s else ∅
-- Set.mk_preimage_prod_right_eq_if
theorem mk_preimage_prod_right_eq_if [DecidablePred (· ∈ s)] :
    Prod.mk a ⁻¹' s ×ˢ t = if a ∈ s then t else ∅ 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {a : α} [DecidablePred fun x => x ∈ s]
Goal: Prod.mk a ⁻¹' s ×ˢ t = if a ∈ s then t else ∅
-- Set.mk_preimage_prod_left_fn_eq_if
theorem mk_preimage_prod_left_fn_eq_if [DecidablePred (· ∈ t)] (f : γ → α) :
    (fun a => (f a, b)) ⁻¹' s ×ˢ t = if b ∈ t then f ⁻¹' s else ∅ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} {t : Set β} {b : β} [DecidablePred fun x => x ∈ t] (f : γ → α)
Goal: (fun a => (f a, b)) ⁻¹' s ×ˢ t = if b ∈ t then f ⁻¹' s else ∅
-- Set.mk_preimage_prod_right_fn_eq_if
theorem mk_preimage_prod_right_fn_eq_if [DecidablePred (· ∈ s)] (g : δ → β) :
    (fun b => (a, g b)) ⁻¹' s ×ˢ t = if a ∈ s then g ⁻¹' t else ∅ 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_4} {s : Set α} {t : Set β} {a : α} [DecidablePred fun x => x ∈ s] (g : δ → β)
Goal: (fun b => (a, g b)) ⁻¹' s ×ˢ t = if a ∈ s then g ⁻¹' t else ∅
-- Set.preimage_swap_prod
@[simp]
theorem preimage_swap_prod (s : Set α) (t : Set β) : Prod.swap ⁻¹' s ×ˢ t = t ×ˢ s 
Arguments: {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β)
Goal: Prod.swap ⁻¹' s ×ˢ t = t ×ˢ s
-- Set.image_swap_prod
@[simp]
theorem image_swap_prod (s : Set α) (t : Set β) : Prod.swap '' s ×ˢ t = t ×ˢ s 
Arguments: {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β)
Goal: Prod.swap '' s ×ˢ t = t ×ˢ s
-- Set.prod_image_image_eq
theorem prod_image_image_eq {m₁ : α → γ} {m₂ : β → δ} :
    (m₁ '' s) ×ˢ (m₂ '' t) = (fun p : α × β => (m₁ p.1, m₂ p.2)) '' s ×ˢ t 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {s : Set α} {t : Set β} {m₁ : α → γ} {m₂ : β → δ}
Goal: (m₁ '' s) ×ˢ (m₂ '' t) = (fun p => (m₁ p.1, m₂ p.2)) '' s ×ˢ t
-- Set.prod_range_range_eq
theorem prod_range_range_eq {m₁ : α → γ} {m₂ : β → δ} :
    range m₁ ×ˢ range m₂ = range fun p : α × β => (m₁ p.1, m₂ p.2) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {m₁ : α → γ} {m₂ : β → δ}
Goal: Set.range m₁ ×ˢ Set.range m₂ = Set.range fun p => (m₁ p.1, m₂ p.2)
-- Set.range_prod_map
@[simp, mfld_simps]
theorem range_prod_map {m₁ : α → γ} {m₂ : β → δ} : range (Prod.map m₁ m₂) = range m₁ ×ˢ range m₂ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {m₁ : α → γ} {m₂ : β → δ}
Goal: Set.range (Prod.map m₁ m₂) = Set.range m₁ ×ˢ Set.range m₂
-- Set.prod_range_univ_eq
theorem prod_range_univ_eq {m₁ : α → γ} :
    range m₁ ×ˢ (univ : Set β) = range fun p : α × β => (m₁ p.1, p.2) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m₁ : α → γ}
Goal: Set.range m₁ ×ˢ Set.univ = Set.range fun p => (m₁ p.1, p.2)
-- Set.prod_univ_range_eq
theorem prod_univ_range_eq {m₂ : β → δ} :
    (univ : Set α) ×ˢ range m₂ = range fun p : α × β => (p.1, m₂ p.2) 
Arguments: {α : Type u_1} {β : Type u_2} {δ : Type u_4} {m₂ : β → δ}
Goal: Set.univ ×ˢ Set.range m₂ = Set.range fun p => (p.1, m₂ p.2)
-- Set.range_pair_subset
theorem range_pair_subset (f : α → β) (g : α → γ) :
    (range fun x => (f x, g x)) ⊆ range f ×ˢ range g 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α → β) (g : α → γ)
Goal: (Set.range fun x => (f x, g x)) ⊆ Set.range f ×ˢ Set.range g
-- Set.Nonempty.prod
theorem Nonempty.prod : s.Nonempty → t.Nonempty → (s ×ˢ t).Nonempty 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}
Goal: s.Nonempty → t.Nonempty → (s ×ˢ t).Nonempty
-- Set.Nonempty.fst
theorem Nonempty.fst : (s ×ˢ t).Nonempty → s.Nonempty 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}
Goal: (s ×ˢ t).Nonempty → s.Nonempty
-- Set.Nonempty.snd
theorem Nonempty.snd : (s ×ˢ t).Nonempty → t.Nonempty 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}
Goal: (s ×ˢ t).Nonempty → t.Nonempty
-- Set.prod_nonempty_iff
@[simp]
theorem prod_nonempty_iff : (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}
Goal: (s ×ˢ t).Nonempty ↔ s.Nonempty ∧ t.Nonempty
-- Set.prod_eq_empty_iff
@[simp]
theorem prod_eq_empty_iff : s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}
Goal: s ×ˢ t = ∅ ↔ s = ∅ ∨ t = ∅
-- Set.prod_sub_preimage_iff
theorem prod_sub_preimage_iff {W : Set γ} {f : α × β → γ} :
    s ×ˢ t ⊆ f ⁻¹' W ↔ ∀ a b, a ∈ s → b ∈ t → f (a, b) ∈ W 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} {t : Set β} {W : Set γ} {f : α × β → γ}
Goal: s ×ˢ t ⊆ f ⁻¹' W ↔ ∀ (a : α) (b : β), a ∈ s → b ∈ t → f (a, b) ∈ W
-- Set.image_prod_mk_subset_prod
theorem image_prod_mk_subset_prod {f : α → β} {g : α → γ} {s : Set α} :
    (fun x => (f x, g x)) '' s ⊆ (f '' s) ×ˢ (g '' s) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {g : α → γ} {s : Set α}
Goal: (fun x => (f x, g x)) '' s ⊆ (f '' s) ×ˢ (g '' s)
-- Set.image_prod_mk_subset_prod_left
theorem image_prod_mk_subset_prod_left (hb : b ∈ t) : (fun a => (a, b)) '' s ⊆ s ×ˢ t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {b : β} (hb : b ∈ t)
Goal: (fun a => (a, b)) '' s ⊆ s ×ˢ t
-- Set.image_prod_mk_subset_prod_right
theorem image_prod_mk_subset_prod_right (ha : a ∈ s) : Prod.mk a '' t ⊆ s ×ˢ t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {a : α} (ha : a ∈ s)
Goal: Prod.mk a '' t ⊆ s ×ˢ t
-- Set.prod_subset_preimage_fst
theorem prod_subset_preimage_fst (s : Set α) (t : Set β) : s ×ˢ t ⊆ Prod.fst ⁻¹' s 
Arguments: {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β)
Goal: s ×ˢ t ⊆ Prod.fst ⁻¹' s
-- Set.fst_image_prod_subset
theorem fst_image_prod_subset (s : Set α) (t : Set β) : Prod.fst '' s ×ˢ t ⊆ s 
Arguments: {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β)
Goal: Prod.fst '' s ×ˢ t ⊆ s
-- Set.fst_image_prod
theorem fst_image_prod (s : Set β) {t : Set α} (ht : t.Nonempty) : Prod.fst '' s ×ˢ t = s 
Arguments: {α : Type u_1} {β : Type u_2} (s : Set β) {t : Set α} (ht : t.Nonempty)
Goal: Prod.fst '' s ×ˢ t = s
-- Set.prod_subset_preimage_snd
theorem prod_subset_preimage_snd (s : Set α) (t : Set β) : s ×ˢ t ⊆ Prod.snd ⁻¹' t 
Arguments: {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β)
Goal: s ×ˢ t ⊆ Prod.snd ⁻¹' t
-- Set.snd_image_prod_subset
theorem snd_image_prod_subset (s : Set α) (t : Set β) : Prod.snd '' s ×ˢ t ⊆ t 
Arguments: {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β)
Goal: Prod.snd '' s ×ˢ t ⊆ t
-- Set.snd_image_prod
theorem snd_image_prod {s : Set α} (hs : s.Nonempty) (t : Set β) : Prod.snd '' s ×ˢ t = t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Set α} (hs : s.Nonempty) (t : Set β)
Goal: Prod.snd '' s ×ˢ t = t
-- Set.prod_diff_prod
theorem prod_diff_prod : s ×ˢ t \ s₁ ×ˢ t₁ = s ×ˢ (t \ t₁) ∪ (s \ s₁) ×ˢ t 
Arguments: {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {t t₁ : Set β}
Goal: s ×ˢ t \ s₁ ×ˢ t₁ = s ×ˢ (t \ t₁) ∪ (s \ s₁) ×ˢ t
-- Set.prod_subset_prod_iff
theorem prod_subset_prod_iff : s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t ⊆ t₁ ∨ s = ∅ ∨ t = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {t t₁ : Set β}
Goal: s ×ˢ t ⊆ s₁ ×ˢ t₁ ↔ s ⊆ s₁ ∧ t ⊆ t₁ ∨ s = ∅ ∨ t = ∅
-- Set.prod_eq_prod_iff_of_nonempty
theorem prod_eq_prod_iff_of_nonempty (h : (s ×ˢ t).Nonempty) :
    s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁ 
Arguments: {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {t t₁ : Set β} (h : (s ×ˢ t).Nonempty)
Goal: s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁
-- Set.prod_eq_prod_iff
theorem prod_eq_prod_iff :
    s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁ ∨ (s = ∅ ∨ t = ∅) ∧ (s₁ = ∅ ∨ t₁ = ∅) 
Arguments: {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {t t₁ : Set β}
Goal: s ×ˢ t = s₁ ×ˢ t₁ ↔ s = s₁ ∧ t = t₁ ∨ (s = ∅ ∨ t = ∅) ∧ (s₁ = ∅ ∨ t₁ = ∅)
-- Set.prod_eq_iff_eq
@[simp]
theorem prod_eq_iff_eq (ht : t.Nonempty) : s ×ˢ t = s₁ ×ˢ t ↔ s = s₁ 
Arguments: {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {t : Set β} (ht : t.Nonempty)
Goal: s ×ˢ t = s₁ ×ˢ t ↔ s = s₁
-- Monotone.set_prod
theorem _root_.Monotone.set_prod (hf : Monotone f) (hg : Monotone g) :
    Monotone fun x => f x ×ˢ g x 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] {f : α → Set β} {g : α → Set γ} (hf : Monotone f) (hg : Monotone g)
Goal: Monotone fun x => f x ×ˢ g x
-- Antitone.set_prod
theorem _root_.Antitone.set_prod (hf : Antitone f) (hg : Antitone g) :
    Antitone fun x => f x ×ˢ g x 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [Preorder α] {f : α → Set β} {g : α → Set γ} (hf : Antitone f) (hg : Antitone g)
Goal: Antitone fun x => f x ×ˢ g x
-- MonotoneOn.set_prod
theorem _root_.MonotoneOn.set_prod (hf : MonotoneOn f s) (hg : MonotoneOn g s) :
    MonotoneOn (fun x => f x ×ˢ g x) s 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} [Preorder α] {f : α → Set β} {g : α → Set γ} (hf : MonotoneOn f s) (hg : MonotoneOn g s)
Goal: MonotoneOn (fun x => f x ×ˢ g x) s
-- AntitoneOn.set_prod
theorem _root_.AntitoneOn.set_prod (hf : AntitoneOn f s) (hg : AntitoneOn g s) :
    AntitoneOn (fun x => f x ×ˢ g x) s 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} [Preorder α] {f : α → Set β} {g : α → Set γ} (hf : AntitoneOn f s) (hg : AntitoneOn g s)
Goal: AntitoneOn (fun x => f x ×ˢ g x) s
-- Set.diagonal_nonempty
lemma diagonal_nonempty [Nonempty α] : (diagonal α).Nonempty 
Arguments: {α : Type u_1} [Nonempty α]
Goal: (Set.diagonal α).Nonempty
-- Set.preimage_coe_coe_diagonal
theorem preimage_coe_coe_diagonal (s : Set α) :
    Prod.map (fun x : s => (x : α)) (fun x : s => (x : α)) ⁻¹' diagonal α = diagonal s 
Arguments: {α : Type u_1} (s : Set α)
Goal: (Prod.map (fun x => ↑x) fun x => ↑x) ⁻¹' Set.diagonal α = Set.diagonal ↑s
-- Set.range_diag
@[simp]
theorem range_diag : (range fun x => (x, x)) = diagonal α 
Arguments: {α : Type u_1}
Goal: (Set.range fun x => (x, x)) = Set.diagonal α
-- Set.diagonal_subset_iff
theorem diagonal_subset_iff {s} : diagonal α ⊆ s ↔ ∀ x, (x, x) ∈ s 
Arguments: {α : Type u_1} {s : Set (α × α)}
Goal: Set.diagonal α ⊆ s ↔ ∀ (x : α), (x, x) ∈ s
-- Set.prod_subset_compl_diagonal_iff_disjoint
@[simp]
theorem prod_subset_compl_diagonal_iff_disjoint : s ×ˢ t ⊆ (diagonal α)ᶜ ↔ Disjoint s t 
Arguments: {α : Type u_1} {s t : Set α}
Goal: s ×ˢ t ⊆ (Set.diagonal α)ᶜ ↔ Disjoint s t
-- Set.diag_preimage_prod
@[simp]
theorem diag_preimage_prod (s t : Set α) : (fun x => (x, x)) ⁻¹' s ×ˢ t = s ∩ t 
Arguments: {α : Type u_1} (s t : Set α)
Goal: (fun x => (x, x)) ⁻¹' s ×ˢ t = s ∩ t
-- Set.diag_preimage_prod_self
theorem diag_preimage_prod_self (s : Set α) : (fun x => (x, x)) ⁻¹' s ×ˢ s = s 
Arguments: {α : Type u_1} (s : Set α)
Goal: (fun x => (x, x)) ⁻¹' s ×ˢ s = s
-- Set.diag_image
theorem diag_image (s : Set α) : (fun x => (x, x)) '' s = diagonal α ∩ s ×ˢ s 
Arguments: {α : Type u_1} (s : Set α)
Goal: (fun x => (x, x)) '' s = Set.diagonal α ∩ s ×ˢ s
-- Set.diagonal_eq_univ_iff
theorem diagonal_eq_univ_iff : diagonal α = univ ↔ Subsingleton α 
Arguments: {α : Type u_1}
Goal: Set.diagonal α = Set.univ ↔ Subsingleton α
-- Set.diagonal_eq_univ
theorem diagonal_eq_univ [Subsingleton α] : diagonal α = univ 
Arguments: {α : Type u_1} [Subsingleton α]
Goal: Set.diagonal α = Set.univ
-- Set.range_const_eq_diagonal
theorem range_const_eq_diagonal {α β : Type*} [hβ : Nonempty β] :
    range (const α) = {f : α → β | ∀ x y, f x = f y} 
Arguments: {α : Type u_1} {β : Type u_2} [hβ : Nonempty β]
Goal: Set.range (Function.const α) = {f | ∀ (x y : α), f x = f y}
-- Function.pullback_comm_sq
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 
Arguments: {X : Type u_2} {Y : Sort u_3} {Z : Type u_1} (f : X → Y) (g : Z → Y)
Goal: f ∘ Function.Pullback.fst = g ∘ Function.Pullback.snd
-- preimage_map_fst_pullbackDiagonal
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) 
Arguments: {X : Type u_2} {Y : Sort u_3} {Z : Type u_1} {f : X → Y} {g : Z → Y}
Goal: Function.PullbackSelf.map_fst ⁻¹' Function.pullbackDiagonal f = Function.pullbackDiagonal Function.Pullback.snd
-- Function.Injective.preimage_pullbackDiagonal
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) 
Arguments: {X : Type u_2} {Y : Sort u_3} {Z : Type u_1} {f : X → Y} {g : Z → X} (inj : Function.Injective g)
Goal: Function.mapPullback g id g ⋯ ⋯ ⁻¹' Function.pullbackDiagonal f = Function.pullbackDiagonal (f ∘ g)
-- image_toPullbackDiag
theorem image_toPullbackDiag (f : X → Y) (s : Set X) :
    toPullbackDiag f '' s = pullbackDiagonal f ∩ Subtype.val ⁻¹' s ×ˢ s 
Arguments: {X : Type u_1} {Y : Sort u_2} (f : X → Y) (s : Set X)
Goal: toPullbackDiag f '' s = Function.pullbackDiagonal f ∩ Subtype.val ⁻¹' s ×ˢ s
-- range_toPullbackDiag
theorem range_toPullbackDiag (f : X → Y) : range (toPullbackDiag f) = pullbackDiagonal f 
Arguments: {X : Type u_1} {Y : Sort u_2} (f : X → Y)
Goal: Set.range (toPullbackDiag f) = Function.pullbackDiagonal f
-- injective_toPullbackDiag
theorem injective_toPullbackDiag (f : X → Y) : (toPullbackDiag f).Injective 
Arguments: {X : Type u_1} {Y : Sort u_2} (f : X → Y)
Goal: Function.Injective (toPullbackDiag f)
-- Set.offDiag_mono
theorem offDiag_mono : Monotone (offDiag : Set α → Set (α × α)) 
Arguments: {α : Type u_1}
Goal: Monotone Set.offDiag
-- Set.offDiag_nonempty
@[simp]
theorem offDiag_nonempty : s.offDiag.Nonempty ↔ s.Nontrivial 
Arguments: {α : Type u_1} {s : Set α}
Goal: s.offDiag.Nonempty ↔ s.Nontrivial
-- Set.offDiag_eq_empty
@[simp]
theorem offDiag_eq_empty : s.offDiag = ∅ ↔ s.Subsingleton 
Arguments: {α : Type u_1} {s : Set α}
Goal: s.offDiag = ∅ ↔ s.Subsingleton
-- Set.offDiag_subset_prod
theorem offDiag_subset_prod : s.offDiag ⊆ s ×ˢ s 
Arguments: {α : Type u_1} (s : Set α)
Goal: s.offDiag ⊆ s ×ˢ s
-- Set.offDiag_eq_sep_prod
theorem offDiag_eq_sep_prod : s.offDiag = { x ∈ s ×ˢ s | x.1 ≠ x.2 } 
Arguments: {α : Type u_1} (s : Set α)
Goal: s.offDiag = {x | x ∈ s ×ˢ s ∧ x.1 ≠ x.2}
-- Set.offDiag_empty
@[simp]
theorem offDiag_empty : (∅ : Set α).offDiag = ∅ 
Arguments: {α : Type u_1}
Goal: ∅.offDiag = ∅
-- Set.offDiag_singleton
@[simp]
theorem offDiag_singleton (a : α) : ({a} : Set α).offDiag = ∅ 
Arguments: {α : Type u_1} (a : α)
Goal: {a}.offDiag = ∅
-- Set.offDiag_univ
@[simp]
theorem offDiag_univ : (univ : Set α).offDiag = (diagonal α)ᶜ 
Arguments: {α : Type u_1}
Goal: Set.univ.offDiag = (Set.diagonal α)ᶜ
-- Set.prod_sdiff_diagonal
@[simp]
theorem prod_sdiff_diagonal : s ×ˢ s \ diagonal α = s.offDiag 
Arguments: {α : Type u_1} (s : Set α)
Goal: s ×ˢ s \ Set.diagonal α = s.offDiag
-- Set.disjoint_diagonal_offDiag
@[simp]
theorem disjoint_diagonal_offDiag : Disjoint (diagonal α) s.offDiag 
Arguments: {α : Type u_1} (s : Set α)
Goal: Disjoint (Set.diagonal α) s.offDiag
-- Set.offDiag_inter
theorem offDiag_inter : (s ∩ t).offDiag = s.offDiag ∩ t.offDiag 
Arguments: {α : Type u_1} (s t : Set α)
Goal: (s ∩ t).offDiag = s.offDiag ∩ t.offDiag
-- Set.offDiag_union
theorem offDiag_union (h : Disjoint s t) :
    (s ∪ t).offDiag = s.offDiag ∪ t.offDiag ∪ s ×ˢ t ∪ t ×ˢ s 
Arguments: {α : Type u_1} {s t : Set α} (h : Disjoint s t)
Goal: (s ∪ t).offDiag = s.offDiag ∪ t.offDiag ∪ s ×ˢ t ∪ t ×ˢ s
-- Set.offDiag_insert
theorem offDiag_insert (ha : a ∉ s) : (insert a s).offDiag = s.offDiag ∪ {a} ×ˢ s ∪ s ×ˢ {a} 
Arguments: {α : Type u_1} {s : Set α} {a : α} (ha : a ∉ s)
Goal: (insert a s).offDiag = s.offDiag ∪ {a} ×ˢ s ∪ s ×ˢ {a}
-- Set.empty_pi
@[simp]
theorem empty_pi (s : ∀ i, Set (α i)) : pi ∅ s = univ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} (s : (i : ι) → Set (α i))
Goal: ∅.pi s = Set.univ
-- Set.subsingleton_univ_pi
theorem subsingleton_univ_pi (ht : ∀ i, (t i).Subsingleton) :
    (univ.pi t).Subsingleton 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {t : (i : ι) → Set (α i)} (ht : ∀ (i : ι), (t i).Subsingleton)
Goal: (Set.univ.pi t).Subsingleton
-- Set.pi_univ
@[simp]
theorem pi_univ (s : Set ι) : (pi s fun i => (univ : Set (α i))) = univ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} (s : Set ι)
Goal: (s.pi fun i => Set.univ) = Set.univ
-- Set.pi_univ_ite
@[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 
Arguments: {ι : Type u_1} {α : ι → Type u_2} (s : Set ι) [DecidablePred fun x => x ∈ s] (t : (i : ι) → Set (α i))
Goal: (Set.univ.pi fun i => if i ∈ s then t i else Set.univ) = s.pi t
-- Set.pi_mono
theorem pi_mono (h : ∀ i ∈ s, t₁ i ⊆ t₂ i) : pi s t₁ ⊆ pi s t₂ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t₁ t₂ : (i : ι) → Set (α i)} (h : ∀ i ∈ s, t₁ i ⊆ t₂ i)
Goal: s.pi t₁ ⊆ s.pi t₂
-- Set.pi_inter_distrib
theorem pi_inter_distrib : (s.pi fun i => t i ∩ t₁ i) = s.pi t ∩ s.pi t₁ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t t₁ : (i : ι) → Set (α i)}
Goal: (s.pi fun i => t i ∩ t₁ i) = s.pi t ∩ s.pi t₁
-- Set.pi_congr
theorem pi_congr (h : s₁ = s₂) (h' : ∀ i ∈ s₁, t₁ i = t₂ i) : s₁.pi t₁ = s₂.pi t₂ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {s₁ s₂ : Set ι} {t₁ t₂ : (i : ι) → Set (α i)} (h : s₁ = s₂) (h' : ∀ i ∈ s₁, t₁ i = t₂ i)
Goal: s₁.pi t₁ = s₂.pi t₂
-- Set.pi_eq_empty
theorem pi_eq_empty (hs : i ∈ s) (ht : t i = ∅) : s.pi t = ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (α i)} {i : ι} (hs : i ∈ s) (ht : t i = ∅)
Goal: s.pi t = ∅
-- Set.univ_pi_eq_empty
theorem univ_pi_eq_empty (ht : t i = ∅) : pi univ t = ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {t : (i : ι) → Set (α i)} {i : ι} (ht : t i = ∅)
Goal: Set.univ.pi t = ∅
-- Set.pi_nonempty_iff
theorem pi_nonempty_iff : (s.pi t).Nonempty ↔ ∀ i, ∃ x, i ∈ s → x ∈ t i 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (α i)}
Goal: (s.pi t).Nonempty ↔ ∀ (i : ι), ∃ x, i ∈ s → x ∈ t i
-- Set.univ_pi_nonempty_iff
theorem univ_pi_nonempty_iff : (pi univ t).Nonempty ↔ ∀ i, (t i).Nonempty 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {t : (i : ι) → Set (α i)}
Goal: (Set.univ.pi t).Nonempty ↔ ∀ (i : ι), (t i).Nonempty
-- Set.pi_eq_empty_iff
theorem pi_eq_empty_iff : s.pi t = ∅ ↔ ∃ i, IsEmpty (α i) ∨ i ∈ s ∧ t i = ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (α i)}
Goal: s.pi t = ∅ ↔ ∃ i, IsEmpty (α i) ∨ i ∈ s ∧ t i = ∅
-- Set.univ_pi_eq_empty_iff
@[simp]
theorem univ_pi_eq_empty_iff : pi univ t = ∅ ↔ ∃ i, t i = ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {t : (i : ι) → Set (α i)}
Goal: Set.univ.pi t = ∅ ↔ ∃ i, t i = ∅
-- Set.univ_pi_empty
@[simp]
theorem univ_pi_empty [h : Nonempty ι] : pi univ (fun _ => ∅ : ∀ i, Set (α i)) = ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [h : Nonempty ι]
Goal: (Set.univ.pi fun x => ∅) = ∅
-- Set.disjoint_univ_pi
@[simp]
theorem disjoint_univ_pi : Disjoint (pi univ t₁) (pi univ t₂) ↔ ∃ i, Disjoint (t₁ i) (t₂ i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {t₁ t₂ : (i : ι) → Set (α i)}
Goal: Disjoint (Set.univ.pi t₁) (Set.univ.pi t₂) ↔ ∃ i, Disjoint (t₁ i) (t₂ i)
-- Set.Disjoint.set_pi
theorem Disjoint.set_pi (hi : i ∈ s) (ht : Disjoint (t₁ i) (t₂ i)) : Disjoint (s.pi t₁) (s.pi t₂) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t₁ t₂ : (i : ι) → Set (α i)} {i : ι} (hi : i ∈ s) (ht : Disjoint (t₁ i) (t₂ i))
Goal: Disjoint (s.pi t₁) (s.pi t₂)
-- Set.uniqueElim_preimage
theorem uniqueElim_preimage [Unique ι] (t : ∀ i, Set (α i)) :
    uniqueElim ⁻¹' pi univ t = t (default : ι) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} [Unique ι] (t : (i : ι) → Set (α i))
Goal: uniqueElim ⁻¹' Set.univ.pi t = t default
-- Set.pi_eq_empty_iff'
theorem pi_eq_empty_iff' : s.pi t = ∅ ↔ ∃ i ∈ s, t i = ∅ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (α i)} [∀ (i : ι), Nonempty (α i)]
Goal: s.pi t = ∅ ↔ ∃ i ∈ s, t i = ∅
-- Set.disjoint_pi
@[simp]
theorem disjoint_pi : Disjoint (s.pi t₁) (s.pi t₂) ↔ ∃ i ∈ s, Disjoint (t₁ i) (t₂ i) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t₁ t₂ : (i : ι) → Set (α i)} [∀ (i : ι), Nonempty (α i)]
Goal: Disjoint (s.pi t₁) (s.pi t₂) ↔ ∃ i ∈ s, Disjoint (t₁ i) (t₂ i)
-- Set.range_dcomp
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) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} (f : (i : ι) → α i → β i)
Goal: (Set.range fun g i => f i (g i)) = Set.univ.pi fun i => Set.range (f i)
-- Set.insert_pi
@[simp]
theorem insert_pi (i : ι) (s : Set ι) (t : ∀ i, Set (α i)) :
    pi (insert i s) t = eval i ⁻¹' t i ∩ pi s t 
Arguments: {ι : Type u_1} {α : ι → Type u_2} (i : ι) (s : Set ι) (t : (i : ι) → Set (α i))
Goal: (insert i s).pi t = Function.eval i ⁻¹' t i ∩ s.pi t
-- Set.singleton_pi
@[simp]
theorem singleton_pi (i : ι) (t : ∀ i, Set (α i)) : pi {i} t = eval i ⁻¹' t i 
Arguments: {ι : Type u_1} {α : ι → Type u_2} (i : ι) (t : (i : ι) → Set (α i))
Goal: {i}.pi t = Function.eval i ⁻¹' t i
-- Set.singleton_pi'
theorem singleton_pi' (i : ι) (t : ∀ i, Set (α i)) : pi {i} t = { x | x i ∈ t i } 
Arguments: {ι : Type u_1} {α : ι → Type u_2} (i : ι) (t : (i : ι) → Set (α i))
Goal: {i}.pi t = {x | x i ∈ t i}
-- Set.univ_pi_singleton
theorem univ_pi_singleton (f : ∀ i, α i) : (pi univ fun i => {f i}) = ({f} : Set (∀ i, α i)) 
Arguments: {ι : Type u_1} {α : ι → Type u_2} (f : (i : ι) → α i)
Goal: (Set.univ.pi fun i => {f i}) = {f}
-- Set.preimage_pi
theorem preimage_pi (s : Set ι) (t : ∀ i, Set (β i)) (f : ∀ i, α i → β i) :
    (fun (g : ∀ i, α i) i => f _ (g i)) ⁻¹' s.pi t = s.pi fun i => f i ⁻¹' t i 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} (s : Set ι) (t : (i : ι) → Set (β i)) (f : (i : ι) → α i → β i)
Goal: (fun g i => f i (g i)) ⁻¹' s.pi t = s.pi fun i => f i ⁻¹' t i
-- Set.pi_if
theorem pi_if {p : ι → Prop} [h : DecidablePred p] (s : Set ι) (t₁ t₂ : ∀ i, Set (α i)) :
    (pi s fun i => if p i then t₁ i else t₂ i) =
      pi ({ i ∈ s | p i }) t₁ ∩ pi ({ i ∈ s | ¬p i }) t₂ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {p : ι → Prop} [h : DecidablePred p] (s : Set ι) (t₁ t₂ : (i : ι) → Set (α i))
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₂
-- Set.union_pi
theorem union_pi : (s₁ ∪ s₂).pi t = s₁.pi t ∩ s₂.pi t 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {s₁ s₂ : Set ι} {t : (i : ι) → Set (α i)}
Goal: (s₁ ∪ s₂).pi t = s₁.pi t ∩ s₂.pi t
-- Set.union_pi_inter
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₂ 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {s₁ s₂ : Set ι} {t₁ t₂ : (i : ι) → Set (α i)} (ht₁ : ∀ i ∉ s₁, t₁ i = Set.univ) (ht₂ : ∀ i ∉ s₂, t₂ i = Set.univ)
Goal: ((s₁ ∪ s₂).pi fun i => t₁ i ∩ t₂ i) = s₁.pi t₁ ∩ s₂.pi t₂
-- Set.pi_inter_compl
@[simp]
theorem pi_inter_compl (s : Set ι) : pi s t ∩ pi sᶜ t = pi univ t 
Arguments: {ι : Type u_1} {α : ι → Type u_2} {t : (i : ι) → Set (α i)} (s : Set ι)
Goal: s.pi t ∩ sᶜ.pi t = Set.univ.pi t