File: Mathlib/Data/Set/Function.lean

full_name: Set.restrict
code: /-- Restrict domain of a function `f` to a set `s`. Same as `Subtype.restrict` but this version
takes an argument `↥s` instead of `Subtype s`. -/
def restrict (s : Set α) (f : ∀ a : α, π a) : ∀ a : s, π a 
goal: π ↑a

full_name: Set.restrict_eq
code: theorem restrict_eq (f : α → β) (s : Set α) : s.restrict f = f ∘ Subtype.val 
goal: s.restrict f = f ∘ Subtype.val

full_name: Set.restrict_apply
code: @[simp]
theorem restrict_apply (f : α → β) (s : Set α) (x : s) : s.restrict f x = f x 
goal: s.restrict f x = f ↑x

full_name: Set.restrict_eq_iff
code: theorem restrict_eq_iff {f : ∀ a, π a} {s : Set α} {g : ∀ a : s, π a} :
    restrict s f = g ↔ ∀ (a) (ha : a ∈ s), f a = g ⟨a, ha⟩ 
goal: s.restrict f = g ↔ ∀ (a : α) (ha : a ∈ s), f a = g ⟨a, ha⟩

full_name: Set.eq_restrict_iff
code: theorem eq_restrict_iff {s : Set α} {f : ∀ a : s, π a} {g : ∀ a, π a} :
    f = restrict s g ↔ ∀ (a) (ha : a ∈ s), f ⟨a, ha⟩ = g a 
goal: f = s.restrict g ↔ ∀ (a : α) (ha : a ∈ s), f ⟨a, ha⟩ = g a

full_name: Set.range_restrict
code: @[simp]
theorem range_restrict (f : α → β) (s : Set α) : Set.range (s.restrict f) = f '' s 
goal: Set.range (s.restrict f) = f '' s

full_name: Set.image_restrict
code: theorem image_restrict (f : α → β) (s t : Set α) :
    s.restrict f '' (Subtype.val ⁻¹' t) = f '' (t ∩ s) 
goal: s.restrict f '' (Subtype.val ⁻¹' t) = f '' (t ∩ s)

full_name: Set.restrict_dite
code: @[simp]
theorem restrict_dite {s : Set α} [∀ x, Decidable (x ∈ s)] (f : ∀ a ∈ s, β)
    (g : ∀ a ∉ s, β) :
    (s.restrict fun a => if h : a ∈ s then f a h else g a h) = (fun a : s => f a a.2) 
goal: (s.restrict fun a => if h : a ∈ s then f a h else g a h) = fun a => f ↑a ⋯

full_name: Set.restrict_dite_compl
code: @[simp]
theorem restrict_dite_compl {s : Set α} [∀ x, Decidable (x ∈ s)] (f : ∀ a ∈ s, β)
    (g : ∀ a ∉ s, β) :
    (sᶜ.restrict fun a => if h : a ∈ s then f a h else g a h) = (fun a : (sᶜ : Set α) => g a a.2) 
goal: (sᶜ.restrict fun a => if h : a ∈ s then f a h else g a h) = fun a => g ↑a ⋯

full_name: Set.restrict_ite
code: @[simp]
theorem restrict_ite (f g : α → β) (s : Set α) [∀ x, Decidable (x ∈ s)] :
    (s.restrict fun a => if a ∈ s then f a else g a) = s.restrict f 
goal: (s.restrict fun a => if a ∈ s then f a else g a) = s.restrict f

full_name: Set.restrict_ite_compl
code: @[simp]
theorem restrict_ite_compl (f g : α → β) (s : Set α) [∀ x, Decidable (x ∈ s)] :
    (sᶜ.restrict fun a => if a ∈ s then f a else g a) = sᶜ.restrict g 
goal: (sᶜ.restrict fun a => if a ∈ s then f a else g a) = sᶜ.restrict g

full_name: Set.restrict_piecewise
code: @[simp]
theorem restrict_piecewise (f g : α → β) (s : Set α) [∀ x, Decidable (x ∈ s)] :
    s.restrict (piecewise s f g) = s.restrict f 
goal: s.restrict (s.piecewise f g) = s.restrict f

full_name: Set.restrict_piecewise_compl
code: @[simp]
theorem restrict_piecewise_compl (f g : α → β) (s : Set α) [∀ x, Decidable (x ∈ s)] :
    sᶜ.restrict (piecewise s f g) = sᶜ.restrict g 
goal: sᶜ.restrict (s.piecewise f g) = sᶜ.restrict g

full_name: Set.restrict_extend_range
code: theorem restrict_extend_range (f : α → β) (g : α → γ) (g' : β → γ) :
    (range f).restrict (extend f g g') = fun x => g x.coe_prop.choose 
goal: (Set.range f).restrict (Function.extend f g g') = fun x => g (Exists.choose ⋯)

full_name: Set.restrict_extend_compl_range
code: @[simp]
theorem restrict_extend_compl_range (f : α → β) (g : α → γ) (g' : β → γ) :
    (range f)ᶜ.restrict (extend f g g') = g' ∘ Subtype.val 
goal: (Set.range f)ᶜ.restrict (Function.extend f g g') = g' ∘ Subtype.val

full_name: Set.range_extend_subset
code: theorem range_extend_subset (f : α → β) (g : α → γ) (g' : β → γ) :
    range (extend f g g') ⊆ range g ∪ g' '' (range f)ᶜ 
goal: Set.range (Function.extend f g g') ⊆ Set.range g ∪ g' '' (Set.range f)ᶜ

full_name: Set.range_extend
code: theorem range_extend {f : α → β} (hf : Injective f) (g : α → γ) (g' : β → γ) :
    range (extend f g g') = range g ∪ g' '' (range f)ᶜ 
goal: Set.range (Function.extend f g g') = Set.range g ∪ g' '' (Set.range f)ᶜ

full_name: Set.codRestrict
code: /-- Restrict codomain of a function `f` to a set `s`. Same as `Subtype.coind` but this version
has codomain `↥s` instead of `Subtype s`. -/
def codRestrict (f : ι → α) (s : Set α) (h : ∀ x, f x ∈ s) : ι → s 
goal: ι → ↑s

full_name: Set.val_codRestrict_apply
code: @[simp]
theorem val_codRestrict_apply (f : ι → α) (s : Set α) (h : ∀ x, f x ∈ s) (x : ι) :
    (codRestrict f s h x : α) = f x 
goal: ↑(Set.codRestrict f s h x) = f x

full_name: Set.restrict_comp_codRestrict
code: @[simp]
theorem restrict_comp_codRestrict {f : ι → α} {g : α → β} {b : Set α} (h : ∀ x, f x ∈ b) :
    b.restrict g ∘ b.codRestrict f h = g ∘ f 
goal: b.restrict g ∘ Set.codRestrict f b h = g ∘ f

full_name: Set.injective_codRestrict
code: @[simp]
theorem injective_codRestrict {f : ι → α} {s : Set α} (h : ∀ x, f x ∈ s) :
    Injective (codRestrict f s h) ↔ Injective f 
goal: Function.Injective (Set.codRestrict f s h) ↔ Function.Injective f

full_name: Set.eqOn_empty
code: @[simp]
theorem eqOn_empty (f₁ f₂ : α → β) : EqOn f₁ f₂ ∅ 
goal: Set.EqOn f₁ f₂ ∅

full_name: Set.eqOn_singleton
code: @[simp]
theorem eqOn_singleton : Set.EqOn f₁ f₂ {a} ↔ f₁ a = f₂ a 
goal: Set.EqOn f₁ f₂ {a} ↔ f₁ a = f₂ a

full_name: Set.eqOn_univ
code: @[simp]
theorem eqOn_univ (f₁ f₂ : α → β) : EqOn f₁ f₂ univ ↔ f₁ = f₂ 
goal: Set.EqOn f₁ f₂ Set.univ ↔ f₁ = f₂

full_name: Set.restrict_eq_restrict_iff
code: @[simp]
theorem restrict_eq_restrict_iff : restrict s f₁ = restrict s f₂ ↔ EqOn f₁ f₂ s 
goal: s.restrict f₁ = s.restrict f₂ ↔ Set.EqOn f₁ f₂ s

full_name: Set.EqOn.symm
code: @[symm]
theorem EqOn.symm (h : EqOn f₁ f₂ s) : EqOn f₂ f₁ s 
goal: Set.EqOn f₂ f₁ s

full_name: Set.eqOn_comm
code: theorem eqOn_comm : EqOn f₁ f₂ s ↔ EqOn f₂ f₁ s 
goal: Set.EqOn f₁ f₂ s ↔ Set.EqOn f₂ f₁ s

full_name: Set.eqOn_refl
code: theorem eqOn_refl (f : α → β) (s : Set α) : EqOn f f s 
goal: Set.EqOn f f s

full_name: Set.EqOn.trans
code: theorem EqOn.trans (h₁ : EqOn f₁ f₂ s) (h₂ : EqOn f₂ f₃ s) : EqOn f₁ f₃ s 
goal: Set.EqOn f₁ f₃ s

full_name: Set.EqOn.image_eq
code: theorem EqOn.image_eq (heq : EqOn f₁ f₂ s) : f₁ '' s = f₂ '' s 
goal: f₁ '' s = f₂ '' s

full_name: Set.EqOn.image_eq_self
code: /-- Variant of `EqOn.image_eq`, for one function being the identity. -/
theorem EqOn.image_eq_self {f : α → α} (h : Set.EqOn f id s) : f '' s = s 
goal: f '' s = s

full_name: Set.EqOn.inter_preimage_eq
code: theorem EqOn.inter_preimage_eq (heq : EqOn f₁ f₂ s) (t : Set β) : s ∩ f₁ ⁻¹' t = s ∩ f₂ ⁻¹' t 
goal: s ∩ f₁ ⁻¹' t = s ∩ f₂ ⁻¹' t

full_name: Set.EqOn.mono
code: theorem EqOn.mono (hs : s₁ ⊆ s₂) (hf : EqOn f₁ f₂ s₂) : EqOn f₁ f₂ s₁ 
goal: Set.EqOn f₁ f₂ s₁

full_name: Set.eqOn_union
code: @[simp]
theorem eqOn_union : EqOn f₁ f₂ (s₁ ∪ s₂) ↔ EqOn f₁ f₂ s₁ ∧ EqOn f₁ f₂ s₂ 
goal: Set.EqOn f₁ f₂ (s₁ ∪ s₂) ↔ Set.EqOn f₁ f₂ s₁ ∧ Set.EqOn f₁ f₂ s₂

full_name: Set.EqOn.union
code: theorem EqOn.union (h₁ : EqOn f₁ f₂ s₁) (h₂ : EqOn f₁ f₂ s₂) : EqOn f₁ f₂ (s₁ ∪ s₂) 
goal: Set.EqOn f₁ f₂ (s₁ ∪ s₂)

full_name: Set.EqOn.comp_left
code: theorem EqOn.comp_left (h : s.EqOn f₁ f₂) : s.EqOn (g ∘ f₁) (g ∘ f₂) 
goal: Set.EqOn (g ∘ f₁) (g ∘ f₂) s

full_name: Set.eqOn_range
code: @[simp]
theorem eqOn_range {ι : Sort*} {f : ι → α} {g₁ g₂ : α → β} :
    EqOn g₁ g₂ (range f) ↔ g₁ ∘ f = g₂ ∘ f 
goal: Set.EqOn g₁ g₂ (Set.range f) ↔ g₁ ∘ f = g₂ ∘ f

full_name: MonotoneOn.congr
code: theorem _root_.MonotoneOn.congr (h₁ : MonotoneOn f₁ s) (h : s.EqOn f₁ f₂) : MonotoneOn f₂ s 
goal: MonotoneOn f₂ s

full_name: AntitoneOn.congr
code: theorem _root_.AntitoneOn.congr (h₁ : AntitoneOn f₁ s) (h : s.EqOn f₁ f₂) : AntitoneOn f₂ s 
goal: AntitoneOn f₂ s

full_name: StrictMonoOn.congr
code: theorem _root_.StrictMonoOn.congr (h₁ : StrictMonoOn f₁ s) (h : s.EqOn f₁ f₂) :
    StrictMonoOn f₂ s 
goal: StrictMonoOn f₂ s

full_name: StrictAntiOn.congr
code: theorem _root_.StrictAntiOn.congr (h₁ : StrictAntiOn f₁ s) (h : s.EqOn f₁ f₂) : StrictAntiOn f₂ s 
goal: StrictAntiOn f₂ s

full_name: Set.EqOn.congr_monotoneOn
code: theorem EqOn.congr_monotoneOn (h : s.EqOn f₁ f₂) : MonotoneOn f₁ s ↔ MonotoneOn f₂ s 
goal: MonotoneOn f₁ s ↔ MonotoneOn f₂ s

full_name: Set.EqOn.congr_antitoneOn
code: theorem EqOn.congr_antitoneOn (h : s.EqOn f₁ f₂) : AntitoneOn f₁ s ↔ AntitoneOn f₂ s 
goal: AntitoneOn f₁ s ↔ AntitoneOn f₂ s

full_name: Set.EqOn.congr_strictMonoOn
code: theorem EqOn.congr_strictMonoOn (h : s.EqOn f₁ f₂) : StrictMonoOn f₁ s ↔ StrictMonoOn f₂ s 
goal: StrictMonoOn f₁ s ↔ StrictMonoOn f₂ s

full_name: Set.EqOn.congr_strictAntiOn
code: theorem EqOn.congr_strictAntiOn (h : s.EqOn f₁ f₂) : StrictAntiOn f₁ s ↔ StrictAntiOn f₂ s 
goal: StrictAntiOn f₁ s ↔ StrictAntiOn f₂ s

full_name: MonotoneOn.mono
code: theorem _root_.MonotoneOn.mono (h : MonotoneOn f s) (h' : s₂ ⊆ s) : MonotoneOn f s₂ 
goal: MonotoneOn f s₂

full_name: AntitoneOn.mono
code: theorem _root_.AntitoneOn.mono (h : AntitoneOn f s) (h' : s₂ ⊆ s) : AntitoneOn f s₂ 
goal: AntitoneOn f s₂

full_name: StrictMonoOn.mono
code: theorem _root_.StrictMonoOn.mono (h : StrictMonoOn f s) (h' : s₂ ⊆ s) : StrictMonoOn f s₂ 
goal: StrictMonoOn f s₂

full_name: StrictAntiOn.mono
code: theorem _root_.StrictAntiOn.mono (h : StrictAntiOn f s) (h' : s₂ ⊆ s) : StrictAntiOn f s₂ 
goal: StrictAntiOn f s₂

full_name: MonotoneOn.monotone
code: protected theorem _root_.MonotoneOn.monotone (h : MonotoneOn f s) :
    Monotone (f ∘ Subtype.val : s → β) 
goal: Monotone (f ∘ Subtype.val)

full_name: AntitoneOn.monotone
code: protected theorem _root_.AntitoneOn.monotone (h : AntitoneOn f s) :
    Antitone (f ∘ Subtype.val : s → β) 
goal: Antitone (f ∘ Subtype.val)

full_name: StrictMonoOn.strictMono
code: protected theorem _root_.StrictMonoOn.strictMono (h : StrictMonoOn f s) :
    StrictMono (f ∘ Subtype.val : s → β) 
goal: StrictMono (f ∘ Subtype.val)

full_name: StrictAntiOn.strictAnti
code: protected theorem _root_.StrictAntiOn.strictAnti (h : StrictAntiOn f s) :
    StrictAnti (f ∘ Subtype.val : s → β) 
goal: StrictAnti (f ∘ Subtype.val)

full_name: Set.MapsTo.restrict_commutes
code: theorem MapsTo.restrict_commutes (f : α → β) (s : Set α) (t : Set β) (h : MapsTo f s t) :
    Subtype.val ∘ h.restrict f s t = f ∘ Subtype.val 
goal: Subtype.val ∘ Set.MapsTo.restrict f s t h = f ∘ Subtype.val

full_name: Set.MapsTo.val_restrict_apply
code: @[simp]
theorem MapsTo.val_restrict_apply (h : MapsTo f s t) (x : s) : (h.restrict f s t x : β) = f x 
goal: ↑(Set.MapsTo.restrict f s t h x) = f ↑x

full_name: Set.MapsTo.coe_iterate_restrict
code: theorem MapsTo.coe_iterate_restrict {f : α → α} (h : MapsTo f s s) (x : s) (k : ℕ) :
    h.restrict^[k] x = f^[k] x 
goal: ↑((Set.MapsTo.restrict f s s h)^[k] x) = f^[k] ↑x

full_name: Set.codRestrict_restrict
code: /-- Restricting the domain and then the codomain is the same as `MapsTo.restrict`. -/
@[simp]
theorem codRestrict_restrict (h : ∀ x : s, f x ∈ t) :
    codRestrict (s.restrict f) t h = MapsTo.restrict f s t fun x hx => h ⟨x, hx⟩ 
goal: Set.codRestrict (s.restrict f) t h = Set.MapsTo.restrict f s t ⋯

full_name: Set.MapsTo.restrict_eq_codRestrict
code: /-- Reverse of `Set.codRestrict_restrict`. -/
theorem MapsTo.restrict_eq_codRestrict (h : MapsTo f s t) :
    h.restrict f s t = codRestrict (s.restrict f) t fun x => h x.2 
goal: Set.MapsTo.restrict f s t h = Set.codRestrict (s.restrict f) t ⋯

full_name: Set.MapsTo.coe_restrict
code: theorem MapsTo.coe_restrict (h : Set.MapsTo f s t) :
    Subtype.val ∘ h.restrict f s t = s.restrict f 
goal: Subtype.val ∘ Set.MapsTo.restrict f s t h = s.restrict f

full_name: Set.MapsTo.range_restrict
code: theorem MapsTo.range_restrict (f : α → β) (s : Set α) (t : Set β) (h : MapsTo f s t) :
    range (h.restrict f s t) = Subtype.val ⁻¹' (f '' s) 
goal: Set.range (Set.MapsTo.restrict f s t h) = Subtype.val ⁻¹' (f '' s)

full_name: Set.mapsTo_iff_exists_map_subtype
code: theorem mapsTo_iff_exists_map_subtype : MapsTo f s t ↔ ∃ g : s → t, ∀ x : s, f x = g x 
goal: Set.MapsTo f s t ↔ ∃ g, ∀ (x : ↑s), f ↑x = ↑(g x)

full_name: Set.mapsTo'
code: theorem mapsTo' : MapsTo f s t ↔ f '' s ⊆ t 
goal: Set.MapsTo f s t ↔ f '' s ⊆ t

full_name: Set.mapsTo_prod_map_diagonal
code: theorem mapsTo_prod_map_diagonal : MapsTo (Prod.map f f) (diagonal α) (diagonal β) 
goal: Set.MapsTo (Prod.map f f) (Set.diagonal α) (Set.diagonal β)

full_name: Set.MapsTo.subset_preimage
code: theorem MapsTo.subset_preimage {f : α → β} {s : Set α} {t : Set β} (hf : MapsTo f s t) :
    s ⊆ f ⁻¹' t 
goal: s ⊆ f ⁻¹' t

full_name: Set.mapsTo_singleton
code: @[simp]
theorem mapsTo_singleton {x : α} : MapsTo f {x} t ↔ f x ∈ t 
goal: Set.MapsTo f {x} t ↔ f x ∈ t

full_name: Set.mapsTo_empty
code: theorem mapsTo_empty (f : α → β) (t : Set β) : MapsTo f ∅ t 
goal: Set.MapsTo f ∅ t

full_name: Set.mapsTo_empty_iff
code: @[simp] theorem mapsTo_empty_iff : MapsTo f s ∅ ↔ s = ∅ 
goal: Set.MapsTo f s ∅ ↔ s = ∅

full_name: Set.MapsTo.nonempty
code: /-- If `f` maps `s` to `t` and `s` is non-empty, `t` is non-empty. -/
theorem MapsTo.nonempty (h : MapsTo f s t) (hs : s.Nonempty) : t.Nonempty 
goal: t.Nonempty

full_name: Set.MapsTo.image_subset
code: theorem MapsTo.image_subset (h : MapsTo f s t) : f '' s ⊆ t 
goal: f '' s ⊆ t

full_name: Set.MapsTo.congr
code: theorem MapsTo.congr (h₁ : MapsTo f₁ s t) (h : EqOn f₁ f₂ s) : MapsTo f₂ s t 
goal: Set.MapsTo f₂ s t

full_name: Set.EqOn.comp_right
code: theorem EqOn.comp_right (hg : t.EqOn g₁ g₂) (hf : s.MapsTo f t) : s.EqOn (g₁ ∘ f) (g₂ ∘ f) 
goal: Set.EqOn (g₁ ∘ f) (g₂ ∘ f) s

full_name: Set.EqOn.mapsTo_iff
code: theorem EqOn.mapsTo_iff (H : EqOn f₁ f₂ s) : MapsTo f₁ s t ↔ MapsTo f₂ s t 
goal: Set.MapsTo f₁ s t ↔ Set.MapsTo f₂ s t

full_name: Set.MapsTo.comp
code: theorem MapsTo.comp (h₁ : MapsTo g t p) (h₂ : MapsTo f s t) : MapsTo (g ∘ f) s p 
goal: Set.MapsTo (g ∘ f) s p

full_name: Set.mapsTo_id
code: theorem mapsTo_id (s : Set α) : MapsTo id s s 
goal: Set.MapsTo id s s

full_name: Set.MapsTo.iterate
code: theorem MapsTo.iterate {f : α → α} {s : Set α} (h : MapsTo f s s) : ∀ n, MapsTo f^[n] s s
  
goal: Set.MapsTo f^[n] s s

full_name: Set.MapsTo.iterate_restrict
code: theorem MapsTo.iterate_restrict {f : α → α} {s : Set α} (h : MapsTo f s s) (n : ℕ) :
    (h.restrict f s s)^[n] = (h.iterate n).restrict _ _ _ 
goal: (Set.MapsTo.restrict f s s h)^[n] = Set.MapsTo.restrict f^[n] s s ⋯

full_name: Set.mapsTo_of_subsingleton'
code: lemma mapsTo_of_subsingleton' [Subsingleton β] (f : α → β) (h : s.Nonempty → t.Nonempty) :
    MapsTo f s t 
goal: Set.MapsTo f s t

full_name: Set.mapsTo_of_subsingleton
code: lemma mapsTo_of_subsingleton [Subsingleton α] (f : α → α) (s : Set α) : MapsTo f s s 
goal: Set.MapsTo f s s

full_name: Set.MapsTo.mono
code: theorem MapsTo.mono (hf : MapsTo f s₁ t₁) (hs : s₂ ⊆ s₁) (ht : t₁ ⊆ t₂) : MapsTo f s₂ t₂ 
goal: Set.MapsTo f s₂ t₂

full_name: Set.MapsTo.mono_left
code: theorem MapsTo.mono_left (hf : MapsTo f s₁ t) (hs : s₂ ⊆ s₁) : MapsTo f s₂ t 
goal: Set.MapsTo f s₂ t

full_name: Set.MapsTo.mono_right
code: theorem MapsTo.mono_right (hf : MapsTo f s t₁) (ht : t₁ ⊆ t₂) : MapsTo f s t₂ 
goal: Set.MapsTo f s t₂

full_name: Set.MapsTo.union_union
code: theorem MapsTo.union_union (h₁ : MapsTo f s₁ t₁) (h₂ : MapsTo f s₂ t₂) :
    MapsTo f (s₁ ∪ s₂) (t₁ ∪ t₂) 
goal: Set.MapsTo f (s₁ ∪ s₂) (t₁ ∪ t₂)

full_name: Set.MapsTo.union
code: theorem MapsTo.union (h₁ : MapsTo f s₁ t) (h₂ : MapsTo f s₂ t) : MapsTo f (s₁ ∪ s₂) t 
goal: Set.MapsTo f (s₁ ∪ s₂) t

full_name: Set.mapsTo_union
code: @[simp]
theorem mapsTo_union : MapsTo f (s₁ ∪ s₂) t ↔ MapsTo f s₁ t ∧ MapsTo f s₂ t 
goal: Set.MapsTo f (s₁ ∪ s₂) t ↔ Set.MapsTo f s₁ t ∧ Set.MapsTo f s₂ t

full_name: Set.MapsTo.inter
code: theorem MapsTo.inter (h₁ : MapsTo f s t₁) (h₂ : MapsTo f s t₂) : MapsTo f s (t₁ ∩ t₂) 
goal: Set.MapsTo f s (t₁ ∩ t₂)

full_name: Set.MapsTo.inter_inter
code: theorem MapsTo.inter_inter (h₁ : MapsTo f s₁ t₁) (h₂ : MapsTo f s₂ t₂) :
    MapsTo f (s₁ ∩ s₂) (t₁ ∩ t₂) 
goal: Set.MapsTo f (s₁ ∩ s₂) (t₁ ∩ t₂)

full_name: Set.mapsTo_inter
code: @[simp]
theorem mapsTo_inter : MapsTo f s (t₁ ∩ t₂) ↔ MapsTo f s t₁ ∧ MapsTo f s t₂ 
goal: Set.MapsTo f s (t₁ ∩ t₂) ↔ Set.MapsTo f s t₁ ∧ Set.MapsTo f s t₂

full_name: Set.mapsTo_univ
code: theorem mapsTo_univ (f : α → β) (s : Set α) : MapsTo f s univ 
goal: Set.MapsTo f s Set.univ

full_name: Set.mapsTo_range
code: theorem mapsTo_range (f : α → β) (s : Set α) : MapsTo f s (range f) 
goal: Set.MapsTo f s (Set.range f)

full_name: Set.mapsTo_image_iff
code: @[simp]
theorem mapsTo_image_iff {f : α → β} {g : γ → α} {s : Set γ} {t : Set β} :
    MapsTo f (g '' s) t ↔ MapsTo (f ∘ g) s t 
goal: Set.MapsTo f (g '' s) t ↔ Set.MapsTo (f ∘ g) s t

full_name: Set.maps_image_to
code: @[deprecated (since := "2023-12-25")]
lemma maps_image_to (f : α → β) (g : γ → α) (s : Set γ) (t : Set β) :
    MapsTo f (g '' s) t ↔ MapsTo (f ∘ g) s t 
goal: Set.MapsTo f (g '' s) t ↔ Set.MapsTo (f ∘ g) s t

full_name: Set.MapsTo.comp_left
code: lemma MapsTo.comp_left (g : β → γ) (hf : MapsTo f s t) : MapsTo (g ∘ f) s (g '' t) 
goal: Set.MapsTo (g ∘ f) s (g '' t)

full_name: Set.MapsTo.comp_right
code: lemma MapsTo.comp_right {s : Set β} {t : Set γ} (hg : MapsTo g s t) (f : α → β) :
    MapsTo (g ∘ f) (f ⁻¹' s) t 
goal: Set.MapsTo (g ∘ f) (f ⁻¹' s) t

full_name: Set.mapsTo_univ_iff
code: @[simp]
lemma mapsTo_univ_iff : MapsTo f univ t ↔ ∀ x, f x ∈ t 
goal: Set.MapsTo f Set.univ t ↔ ∀ (x : α), f x ∈ t

full_name: Set.maps_univ_to
code: @[deprecated (since := "2023-12-25")]
theorem maps_univ_to (f : α → β) (s : Set β) : MapsTo f univ s ↔ ∀ a, f a ∈ s 
goal: Set.MapsTo f Set.univ s ↔ ∀ (a : α), f a ∈ s

full_name: Set.mapsTo_range_iff
code: @[simp]
lemma mapsTo_range_iff {g : ι → α} : MapsTo f (range g) t ↔ ∀ i, f (g i) ∈ t 
goal: Set.MapsTo f (Set.range g) t ↔ ∀ (i : ι), f (g i) ∈ t

full_name: Set.maps_range_to
code: @[deprecated mapsTo_range_iff (since := "2023-12-25")]
theorem maps_range_to (f : α → β) (g : γ → α) (s : Set β) :
    MapsTo f (range g) s ↔ MapsTo (f ∘ g) univ s 
goal: Set.MapsTo f (Set.range g) s ↔ Set.MapsTo (f ∘ g) Set.univ s

full_name: Set.surjective_mapsTo_image_restrict
code: theorem surjective_mapsTo_image_restrict (f : α → β) (s : Set α) :
    Surjective ((mapsTo_image f s).restrict f s (f '' s)) 
goal: Function.Surjective (Set.MapsTo.restrict f s (f '' s) ⋯)

full_name: Set.MapsTo.mem_iff
code: theorem MapsTo.mem_iff (h : MapsTo f s t) (hc : MapsTo f sᶜ tᶜ) {x} : f x ∈ t ↔ x ∈ s 
goal: f x ∈ t ↔ x ∈ s

full_name: Set.image_restrictPreimage
code: theorem image_restrictPreimage :
    t.restrictPreimage f '' (Subtype.val ⁻¹' s) = Subtype.val ⁻¹' (f '' s) 
goal: t.restrictPreimage f '' (Subtype.val ⁻¹' s) = Subtype.val ⁻¹' (f '' s)

full_name: Set.range_restrictPreimage
code: theorem range_restrictPreimage : range (t.restrictPreimage f) = Subtype.val ⁻¹' range f 
goal: Set.range (t.restrictPreimage f) = Subtype.val ⁻¹' Set.range f

full_name: Set.restrictPreimage_mk
code: @[simp]
theorem restrictPreimage_mk (h : a ∈ f ⁻¹' t) : t.restrictPreimage f ⟨a, h⟩ = ⟨f a, h⟩ 
goal: t.restrictPreimage f ⟨a, h⟩ = ⟨f a, h⟩

full_name: Set.image_val_preimage_restrictPreimage
code: theorem image_val_preimage_restrictPreimage {u : Set t} :
    Subtype.val '' (t.restrictPreimage f ⁻¹' u) = f ⁻¹' (Subtype.val '' u) 
goal: Subtype.val '' (t.restrictPreimage f ⁻¹' u) = f ⁻¹' (Subtype.val '' u)

full_name: Set.preimage_restrictPreimage
code: theorem preimage_restrictPreimage {u : Set t} :
    t.restrictPreimage f ⁻¹' u = (fun a : f ⁻¹' t ↦ f a) ⁻¹' (Subtype.val '' u) 
goal: t.restrictPreimage f ⁻¹' u = (fun a => f ↑a) ⁻¹' (Subtype.val '' u)

full_name: Set.restrictPreimage_injective
code: lemma restrictPreimage_injective (hf : Injective f) : Injective (t.restrictPreimage f) 
goal: Function.Injective (t.restrictPreimage f)

full_name: Set.restrictPreimage_surjective
code: lemma restrictPreimage_surjective (hf : Surjective f) : Surjective (t.restrictPreimage f) 
goal: Function.Surjective (t.restrictPreimage f)

full_name: Set.restrictPreimage_bijective
code: lemma restrictPreimage_bijective (hf : Bijective f) : Bijective (t.restrictPreimage f) 
goal: Function.Bijective (t.restrictPreimage f)

full_name: Set.Subsingleton.injOn
code: theorem Subsingleton.injOn (hs : s.Subsingleton) (f : α → β) : InjOn f s 
goal: Set.InjOn f s

full_name: Set.injOn_empty
code: @[simp]
theorem injOn_empty (f : α → β) : InjOn f ∅ 
goal: Set.InjOn f ∅

full_name: Set.injOn_singleton
code: @[simp]
theorem injOn_singleton (f : α → β) (a : α) : InjOn f {a} 
goal: Set.InjOn f {a}

full_name: Set.injOn_pair
code: @[simp] lemma injOn_pair {b : α} : InjOn f {a, b} ↔ f a = f b → a = b 
goal: Set.InjOn f {a, b} ↔ f a = f b → a = b

full_name: Set.InjOn.eq_iff
code: theorem InjOn.eq_iff {x y} (h : InjOn f s) (hx : x ∈ s) (hy : y ∈ s) : f x = f y ↔ x = y 
goal: f x = f y ↔ x = y

full_name: Set.InjOn.ne_iff
code: theorem InjOn.ne_iff {x y} (h : InjOn f s) (hx : x ∈ s) (hy : y ∈ s) : f x ≠ f y ↔ x ≠ y 
goal: f x ≠ f y ↔ x ≠ y

full_name: Set.InjOn.congr
code: theorem InjOn.congr (h₁ : InjOn f₁ s) (h : EqOn f₁ f₂ s) : InjOn f₂ s 
goal: Set.InjOn f₂ s

full_name: Set.EqOn.injOn_iff
code: theorem EqOn.injOn_iff (H : EqOn f₁ f₂ s) : InjOn f₁ s ↔ InjOn f₂ s 
goal: Set.InjOn f₁ s ↔ Set.InjOn f₂ s

full_name: Set.InjOn.mono
code: theorem InjOn.mono (h : s₁ ⊆ s₂) (ht : InjOn f s₂) : InjOn f s₁ 
goal: Set.InjOn f s₁

full_name: Set.injOn_union
code: theorem injOn_union (h : Disjoint s₁ s₂) :
    InjOn f (s₁ ∪ s₂) ↔ InjOn f s₁ ∧ InjOn f s₂ ∧ ∀ x ∈ s₁, ∀ y ∈ s₂, f x ≠ f y 
goal: Set.InjOn f (s₁ ∪ s₂) ↔ Set.InjOn f s₁ ∧ Set.InjOn f s₂ ∧ ∀ x ∈ s₁, ∀ y ∈ s₂, f x ≠ f y

full_name: Set.injOn_insert
code: theorem injOn_insert {f : α → β} {s : Set α} {a : α} (has : a ∉ s) :
    Set.InjOn f (insert a s) ↔ Set.InjOn f s ∧ f a ∉ f '' s 
goal: Set.InjOn f (insert a s) ↔ Set.InjOn f s ∧ f a ∉ f '' s

full_name: Set.injective_iff_injOn_univ
code: theorem injective_iff_injOn_univ : Injective f ↔ InjOn f univ 
goal: Function.Injective f ↔ Set.InjOn f Set.univ

full_name: Set.injOn_of_injective
code: theorem injOn_of_injective (h : Injective f) {s : Set α} : InjOn f s 
goal: Set.InjOn f s

full_name: Set.injOn_subtype_val
code: theorem injOn_subtype_val {s : Set { x // p x }} : Set.InjOn Subtype.val s 
goal: Set.InjOn Subtype.val s

full_name: Set.injOn_id
code: lemma injOn_id (s : Set α) : InjOn id s 
goal: Set.InjOn id s

full_name: Set.InjOn.comp
code: theorem InjOn.comp (hg : InjOn g t) (hf : InjOn f s) (h : MapsTo f s t) : InjOn (g ∘ f) s 
goal: Set.InjOn (g ∘ f) s

full_name: Set.InjOn.image_of_comp
code: lemma InjOn.image_of_comp (h : InjOn (g ∘ f) s) : InjOn g (f '' s) 
goal: Set.InjOn g (f '' s)

full_name: Set.InjOn.iterate
code: lemma InjOn.iterate {f : α → α} {s : Set α} (h : InjOn f s) (hf : MapsTo f s s) :
    ∀ n, InjOn f^[n] s
  
goal: Set.InjOn f^[n] s

full_name: Set.injOn_of_subsingleton
code: lemma injOn_of_subsingleton [Subsingleton α] (f : α → β) (s : Set α) : InjOn f s 
goal: Set.InjOn f s

full_name: Function.Injective.injOn_range
code: theorem _root_.Function.Injective.injOn_range (h : Injective (g ∘ f)) : InjOn g (range f) 
goal: Set.InjOn g (Set.range f)

full_name: Set.injOn_iff_injective
code: theorem injOn_iff_injective : InjOn f s ↔ Injective (s.restrict f) 
goal: Set.InjOn f s ↔ Function.Injective (s.restrict f)

full_name: Set.MapsTo.restrict_inj
code: theorem MapsTo.restrict_inj (h : MapsTo f s t) : Injective (h.restrict f s t) ↔ InjOn f s 
goal: Function.Injective (Set.MapsTo.restrict f s t h) ↔ Set.InjOn f s

full_name: Set.exists_injOn_iff_injective
code: theorem exists_injOn_iff_injective [Nonempty β] :
    (∃ f : α → β, InjOn f s) ↔ ∃ f : s → β, Injective f 
goal: (∃ f, Set.InjOn f s) ↔ ∃ f, Function.Injective f

full_name: Set.injOn_preimage
code: theorem injOn_preimage {B : Set (Set β)} (hB : B ⊆ 𝒫 range f) : InjOn (preimage f) B 
goal: Set.InjOn (Set.preimage f) B

full_name: Set.InjOn.mem_of_mem_image
code: theorem InjOn.mem_of_mem_image {x} (hf : InjOn f s) (hs : s₁ ⊆ s) (h : x ∈ s) (h₁ : f x ∈ f '' s₁) :
    x ∈ s₁ 
goal: x ∈ s₁

full_name: Set.InjOn.mem_image_iff
code: theorem InjOn.mem_image_iff {x} (hf : InjOn f s) (hs : s₁ ⊆ s) (hx : x ∈ s) :
    f x ∈ f '' s₁ ↔ x ∈ s₁ 
goal: f x ∈ f '' s₁ ↔ x ∈ s₁

full_name: Set.InjOn.preimage_image_inter
code: theorem InjOn.preimage_image_inter (hf : InjOn f s) (hs : s₁ ⊆ s) : f ⁻¹' (f '' s₁) ∩ s = s₁ 
goal: f ⁻¹' (f '' s₁) ∩ s = s₁

full_name: Set.EqOn.cancel_left
code: theorem EqOn.cancel_left (h : s.EqOn (g ∘ f₁) (g ∘ f₂)) (hg : t.InjOn g) (hf₁ : s.MapsTo f₁ t)
    (hf₂ : s.MapsTo f₂ t) : s.EqOn f₁ f₂ 
goal: Set.EqOn f₁ f₂ s

full_name: Set.InjOn.cancel_left
code: theorem InjOn.cancel_left (hg : t.InjOn g) (hf₁ : s.MapsTo f₁ t) (hf₂ : s.MapsTo f₂ t) :
    s.EqOn (g ∘ f₁) (g ∘ f₂) ↔ s.EqOn f₁ f₂ 
goal: Set.EqOn (g ∘ f₁) (g ∘ f₂) s ↔ Set.EqOn f₁ f₂ s

full_name: Set.InjOn.image_inter
code: lemma InjOn.image_inter {s t u : Set α} (hf : u.InjOn f) (hs : s ⊆ u) (ht : t ⊆ u) :
    f '' (s ∩ t) = f '' s ∩ f '' t 
goal: f '' (s ∩ t) = f '' s ∩ f '' t

full_name: Set.InjOn.image
code: lemma InjOn.image (h : s.InjOn f) : s.powerset.InjOn (image f) 
goal: Set.InjOn (Set.image f) (𝒫 s)

full_name: Set.InjOn.image_eq_image_iff
code: theorem InjOn.image_eq_image_iff (h : s.InjOn f) (h₁ : s₁ ⊆ s) (h₂ : s₂ ⊆ s) :
    f '' s₁ = f '' s₂ ↔ s₁ = s₂ 
goal: f '' s₁ = f '' s₂ ↔ s₁ = s₂

full_name: Set.InjOn.image_subset_image_iff
code: lemma InjOn.image_subset_image_iff (h : s.InjOn f) (h₁ : s₁ ⊆ s) (h₂ : s₂ ⊆ s) :
    f '' s₁ ⊆ f '' s₂ ↔ s₁ ⊆ s₂ 
goal: f '' s₁ ⊆ f '' s₂ ↔ s₁ ⊆ s₂

full_name: Set.InjOn.image_ssubset_image_iff
code: lemma InjOn.image_ssubset_image_iff (h : s.InjOn f) (h₁ : s₁ ⊆ s) (h₂ : s₂ ⊆ s) :
    f '' s₁ ⊂ f '' s₂ ↔ s₁ ⊂ s₂ 
goal: f '' s₁ ⊂ f '' s₂ ↔ s₁ ⊂ s₂

full_name: Disjoint.image
code: theorem _root_.Disjoint.image {s t u : Set α} {f : α → β} (h : Disjoint s t) (hf : u.InjOn f)
    (hs : s ⊆ u) (ht : t ⊆ u) : Disjoint (f '' s) (f '' t) 
goal: Disjoint (f '' s) (f '' t)

full_name: Set.InjOn.image_diff
code: lemma InjOn.image_diff {t : Set α} (h : s.InjOn f) : f '' (s \ t) = f '' s \ f '' (s ∩ t) 
goal: f '' (s \ t) = f '' s \ f '' (s ∩ t)

full_name: Set.InjOn.image_diff_subset
code: lemma InjOn.image_diff_subset {f : α → β} {t : Set α} (h : InjOn f s) (hst : t ⊆ s) :
    f '' (s \ t) = f '' s \ f '' t 
goal: f '' (s \ t) = f '' s \ f '' t

full_name: Set.InjOn.imageFactorization_injective
code: theorem InjOn.imageFactorization_injective (h : InjOn f s) :
    Injective (s.imageFactorization f) 
goal: Function.Injective (Set.imageFactorization f s)

full_name: Set.imageFactorization_injective_iff
code: @[simp] theorem imageFactorization_injective_iff : Injective (s.imageFactorization f) ↔ InjOn f s 
goal: Function.Injective (Set.imageFactorization f s) ↔ Set.InjOn f s

full_name: Set.graphOn_empty
code: @[simp] lemma graphOn_empty (f : α → β) : graphOn f ∅ = ∅ 
goal: Set.graphOn f ∅ = ∅

full_name: Set.graphOn_union
code: @[simp]
lemma graphOn_union (f : α → β) (s t : Set α) : graphOn f (s ∪ t) = graphOn f s ∪ graphOn f t 
goal: Set.graphOn f (s ∪ t) = Set.graphOn f s ∪ Set.graphOn f t

full_name: Set.graphOn_singleton
code: @[simp]
lemma graphOn_singleton (f : α → β) (x : α) : graphOn f {x} = {(x, f x)} 
goal: Set.graphOn f {x} = {(x, f x)}

full_name: Set.graphOn_insert
code: @[simp]
lemma graphOn_insert (f : α → β) (x : α) (s : Set α) :
    graphOn f (insert x s) = insert (x, f x) (graphOn f s) 
goal: Set.graphOn f (insert x s) = insert (x, f x) (Set.graphOn f s)

full_name: Set.image_fst_graphOn
code: @[simp]
lemma image_fst_graphOn (f : α → β) (s : Set α) : Prod.fst '' graphOn f s = s 
goal: Prod.fst '' Set.graphOn f s = s

full_name: Set.exists_eq_graphOn_image_fst
code: lemma exists_eq_graphOn_image_fst [Nonempty β] {s : Set (α × β)} :
    (∃ f : α → β, s = graphOn f (Prod.fst '' s)) ↔ InjOn Prod.fst s 
goal: (∃ f, s = Set.graphOn f (Prod.fst '' s)) ↔ Set.InjOn Prod.fst s

full_name: Set.exists_eq_graphOn
code: lemma exists_eq_graphOn [Nonempty β] {s : Set (α × β)} :
    (∃ f t, s = graphOn f t) ↔ InjOn Prod.fst s 
goal: (∃ f t, s = Set.graphOn f t) ↔ Set.InjOn Prod.fst s

full_name: Set.SurjOn.subset_range
code: theorem SurjOn.subset_range (h : SurjOn f s t) : t ⊆ range f 
goal: t ⊆ Set.range f

full_name: Set.surjOn_iff_exists_map_subtype
code: theorem surjOn_iff_exists_map_subtype :
    SurjOn f s t ↔ ∃ (t' : Set β) (g : s → t'), t ⊆ t' ∧ Surjective g ∧ ∀ x : s, f x = g x 
goal: Set.SurjOn f s t ↔ ∃ t' g, t ⊆ t' ∧ Function.Surjective g ∧ ∀ (x : ↑s), f ↑x = ↑(g x)

full_name: Set.surjOn_empty
code: theorem surjOn_empty (f : α → β) (s : Set α) : SurjOn f s ∅ 
goal: Set.SurjOn f s ∅

full_name: Set.surjOn_empty_iff
code: @[simp] theorem surjOn_empty_iff : SurjOn f ∅ t ↔ t = ∅ 
goal: Set.SurjOn f ∅ t ↔ t = ∅

full_name: Set.surjOn_singleton
code: @[simp] lemma surjOn_singleton : SurjOn f s {b} ↔ b ∈ f '' s 
goal: Set.SurjOn f s {b} ↔ b ∈ f '' s

full_name: Set.surjOn_image
code: theorem surjOn_image (f : α → β) (s : Set α) : SurjOn f s (f '' s) 
goal: Set.SurjOn f s (f '' s)

full_name: Set.SurjOn.comap_nonempty
code: theorem SurjOn.comap_nonempty (h : SurjOn f s t) (ht : t.Nonempty) : s.Nonempty 
goal: s.Nonempty

full_name: Set.SurjOn.congr
code: theorem SurjOn.congr (h : SurjOn f₁ s t) (H : EqOn f₁ f₂ s) : SurjOn f₂ s t 
goal: Set.SurjOn f₂ s t

full_name: Set.EqOn.surjOn_iff
code: theorem EqOn.surjOn_iff (h : EqOn f₁ f₂ s) : SurjOn f₁ s t ↔ SurjOn f₂ s t 
goal: Set.SurjOn f₁ s t ↔ Set.SurjOn f₂ s t

full_name: Set.SurjOn.mono
code: theorem SurjOn.mono (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) (hf : SurjOn f s₁ t₂) : SurjOn f s₂ t₁ 
goal: Set.SurjOn f s₂ t₁

full_name: Set.SurjOn.union
code: theorem SurjOn.union (h₁ : SurjOn f s t₁) (h₂ : SurjOn f s t₂) : SurjOn f s (t₁ ∪ t₂) 
goal: Set.SurjOn f s (t₁ ∪ t₂)

full_name: Set.SurjOn.union_union
code: theorem SurjOn.union_union (h₁ : SurjOn f s₁ t₁) (h₂ : SurjOn f s₂ t₂) :
    SurjOn f (s₁ ∪ s₂) (t₁ ∪ t₂) 
goal: Set.SurjOn f (s₁ ∪ s₂) (t₁ ∪ t₂)

full_name: Set.SurjOn.inter_inter
code: theorem SurjOn.inter_inter (h₁ : SurjOn f s₁ t₁) (h₂ : SurjOn f s₂ t₂) (h : InjOn f (s₁ ∪ s₂)) :
    SurjOn f (s₁ ∩ s₂) (t₁ ∩ t₂) 
goal: Set.SurjOn f (s₁ ∩ s₂) (t₁ ∩ t₂)

full_name: Set.SurjOn.inter
code: theorem SurjOn.inter (h₁ : SurjOn f s₁ t) (h₂ : SurjOn f s₂ t) (h : InjOn f (s₁ ∪ s₂)) :
    SurjOn f (s₁ ∩ s₂) t 
goal: Set.SurjOn f (s₁ ∩ s₂) t

full_name: Set.surjOn_id
code: lemma surjOn_id (s : Set α) : SurjOn id s s 
goal: Set.SurjOn id s s

full_name: Set.SurjOn.comp
code: theorem SurjOn.comp (hg : SurjOn g t p) (hf : SurjOn f s t) : SurjOn (g ∘ f) s p 
goal: Set.SurjOn (g ∘ f) s p

full_name: Set.SurjOn.iterate
code: lemma SurjOn.iterate {f : α → α} {s : Set α} (h : SurjOn f s s) : ∀ n, SurjOn f^[n] s s
  
goal: Set.SurjOn f^[n] s s

full_name: Set.SurjOn.comp_left
code: lemma SurjOn.comp_left (hf : SurjOn f s t) (g : β → γ) : SurjOn (g ∘ f) s (g '' t) 
goal: Set.SurjOn (g ∘ f) s (g '' t)

full_name: Set.SurjOn.comp_right
code: lemma SurjOn.comp_right {s : Set β} {t : Set γ} (hf : Surjective f) (hg : SurjOn g s t) :
    SurjOn (g ∘ f) (f ⁻¹' s) t 
goal: Set.SurjOn (g ∘ f) (f ⁻¹' s) t

full_name: Set.surjOn_of_subsingleton'
code: lemma surjOn_of_subsingleton' [Subsingleton β] (f : α → β) (h : t.Nonempty → s.Nonempty) :
    SurjOn f s t 
goal: Set.SurjOn f s t

full_name: Set.surjOn_of_subsingleton
code: lemma surjOn_of_subsingleton [Subsingleton α] (f : α → α) (s : Set α) : SurjOn f s s 
goal: Set.SurjOn f s s

full_name: Set.surjective_iff_surjOn_univ
code: theorem surjective_iff_surjOn_univ : Surjective f ↔ SurjOn f univ univ 
goal: Function.Surjective f ↔ Set.SurjOn f Set.univ Set.univ

full_name: Set.surjOn_iff_surjective
code: theorem surjOn_iff_surjective : SurjOn f s univ ↔ Surjective (s.restrict f) 
goal: Set.SurjOn f s Set.univ ↔ Function.Surjective (s.restrict f)

full_name: Set.MapsTo.restrict_surjective_iff
code: @[simp]
theorem MapsTo.restrict_surjective_iff (h : MapsTo f s t) :
    Surjective (MapsTo.restrict _ _ _ h) ↔ SurjOn f s t 
goal: Function.Surjective (Set.MapsTo.restrict f s t h) ↔ Set.SurjOn f s t

full_name: Set.SurjOn.image_eq_of_mapsTo
code: theorem SurjOn.image_eq_of_mapsTo (h₁ : SurjOn f s t) (h₂ : MapsTo f s t) : f '' s = t 
goal: f '' s = t

full_name: Set.image_eq_iff_surjOn_mapsTo
code: theorem image_eq_iff_surjOn_mapsTo : f '' s = t ↔ s.SurjOn f t ∧ s.MapsTo f t 
goal: f '' s = t ↔ Set.SurjOn f s t ∧ Set.MapsTo f s t

full_name: Set.SurjOn.image_preimage
code: lemma SurjOn.image_preimage (h : Set.SurjOn f s t) (ht : t₁ ⊆ t) : f '' (f ⁻¹' t₁) = t₁ 
goal: f '' (f ⁻¹' t₁) = t₁

full_name: Set.SurjOn.mapsTo_compl
code: theorem SurjOn.mapsTo_compl (h : SurjOn f s t) (h' : Injective f) : MapsTo f sᶜ tᶜ 
goal: Set.MapsTo f sᶜ tᶜ

full_name: Set.MapsTo.surjOn_compl
code: theorem MapsTo.surjOn_compl (h : MapsTo f s t) (h' : Surjective f) : SurjOn f sᶜ tᶜ 
goal: Set.SurjOn f sᶜ tᶜ

full_name: Set.EqOn.cancel_right
code: theorem EqOn.cancel_right (hf : s.EqOn (g₁ ∘ f) (g₂ ∘ f)) (hf' : s.SurjOn f t) : t.EqOn g₁ g₂ 
goal: Set.EqOn g₁ g₂ t

full_name: Set.SurjOn.cancel_right
code: theorem SurjOn.cancel_right (hf : s.SurjOn f t) (hf' : s.MapsTo f t) :
    s.EqOn (g₁ ∘ f) (g₂ ∘ f) ↔ t.EqOn g₁ g₂ 
goal: Set.EqOn (g₁ ∘ f) (g₂ ∘ f) s ↔ Set.EqOn g₁ g₂ t

full_name: Set.eqOn_comp_right_iff
code: theorem eqOn_comp_right_iff : s.EqOn (g₁ ∘ f) (g₂ ∘ f) ↔ (f '' s).EqOn g₁ g₂ 
goal: Set.EqOn (g₁ ∘ f) (g₂ ∘ f) s ↔ Set.EqOn g₁ g₂ (f '' s)

full_name: Set.SurjOn.forall
code: theorem SurjOn.forall {p : β → Prop} (hf : s.SurjOn f t) (hf' : s.MapsTo f t) :
    (∀ y ∈ t, p y) ↔ (∀ x ∈ s, p (f x)) 
goal: (∀ y ∈ t, p y) ↔ ∀ x ∈ s, p (f x)

full_name: Set.BijOn.mapsTo
code: theorem BijOn.mapsTo (h : BijOn f s t) : MapsTo f s t 
goal: Set.MapsTo f s t

full_name: Set.BijOn.injOn
code: theorem BijOn.injOn (h : BijOn f s t) : InjOn f s 
goal: Set.InjOn f s

full_name: Set.BijOn.surjOn
code: theorem BijOn.surjOn (h : BijOn f s t) : SurjOn f s t 
goal: Set.SurjOn f s t

full_name: Set.BijOn.mk
code: theorem BijOn.mk (h₁ : MapsTo f s t) (h₂ : InjOn f s) (h₃ : SurjOn f s t) : BijOn f s t 
goal: Set.BijOn f s t

full_name: Set.bijOn_empty
code: theorem bijOn_empty (f : α → β) : BijOn f ∅ ∅ 
goal: Set.BijOn f ∅ ∅

full_name: Set.bijOn_empty_iff_left
code: @[simp] theorem bijOn_empty_iff_left : BijOn f s ∅ ↔ s = ∅ 
goal: Set.BijOn f s ∅ ↔ s = ∅

full_name: Set.bijOn_empty_iff_right
code: @[simp] theorem bijOn_empty_iff_right : BijOn f ∅ t ↔ t = ∅ 
goal: Set.BijOn f ∅ t ↔ t = ∅

full_name: Set.bijOn_singleton
code: @[simp] lemma bijOn_singleton : BijOn f {a} {b} ↔ f a = b 
goal: Set.BijOn f {a} {b} ↔ f a = b

full_name: Set.BijOn.inter_mapsTo
code: theorem BijOn.inter_mapsTo (h₁ : BijOn f s₁ t₁) (h₂ : MapsTo f s₂ t₂) (h₃ : s₁ ∩ f ⁻¹' t₂ ⊆ s₂) :
    BijOn f (s₁ ∩ s₂) (t₁ ∩ t₂) 
goal: Set.BijOn f (s₁ ∩ s₂) (t₁ ∩ t₂)

full_name: Set.MapsTo.inter_bijOn
code: theorem MapsTo.inter_bijOn (h₁ : MapsTo f s₁ t₁) (h₂ : BijOn f s₂ t₂) (h₃ : s₂ ∩ f ⁻¹' t₁ ⊆ s₁) :
    BijOn f (s₁ ∩ s₂) (t₁ ∩ t₂) 
goal: Set.BijOn f (s₁ ∩ s₂) (t₁ ∩ t₂)

full_name: Set.BijOn.inter
code: theorem BijOn.inter (h₁ : BijOn f s₁ t₁) (h₂ : BijOn f s₂ t₂) (h : InjOn f (s₁ ∪ s₂)) :
    BijOn f (s₁ ∩ s₂) (t₁ ∩ t₂) 
goal: Set.BijOn f (s₁ ∩ s₂) (t₁ ∩ t₂)

full_name: Set.BijOn.union
code: theorem BijOn.union (h₁ : BijOn f s₁ t₁) (h₂ : BijOn f s₂ t₂) (h : InjOn f (s₁ ∪ s₂)) :
    BijOn f (s₁ ∪ s₂) (t₁ ∪ t₂) 
goal: Set.BijOn f (s₁ ∪ s₂) (t₁ ∪ t₂)

full_name: Set.BijOn.subset_range
code: theorem BijOn.subset_range (h : BijOn f s t) : t ⊆ range f 
goal: t ⊆ Set.range f

full_name: Set.InjOn.bijOn_image
code: theorem InjOn.bijOn_image (h : InjOn f s) : BijOn f s (f '' s) 
goal: Set.BijOn f s (f '' s)

full_name: Set.BijOn.congr
code: theorem BijOn.congr (h₁ : BijOn f₁ s t) (h : EqOn f₁ f₂ s) : BijOn f₂ s t 
goal: Set.BijOn f₂ s t

full_name: Set.EqOn.bijOn_iff
code: theorem EqOn.bijOn_iff (H : EqOn f₁ f₂ s) : BijOn f₁ s t ↔ BijOn f₂ s t 
goal: Set.BijOn f₁ s t ↔ Set.BijOn f₂ s t

full_name: Set.BijOn.image_eq
code: theorem BijOn.image_eq (h : BijOn f s t) : f '' s = t 
goal: f '' s = t

full_name: Set.BijOn.forall
code: lemma BijOn.forall {p : β → Prop} (hf : BijOn f s t) : (∀ b ∈ t, p b) ↔ ∀ a ∈ s, p (f a) 
goal: (∀ b ∈ t, p b) ↔ ∀ a ∈ s, p (f a)

full_name: Set.BijOn.exists
code: lemma BijOn.exists {p : β → Prop} (hf : BijOn f s t) : (∃ b ∈ t, p b) ↔ ∃ a ∈ s, p (f a) 
goal: (∃ b ∈ t, p b) ↔ ∃ a ∈ s, p (f a)

full_name: Equiv.image_eq_iff_bijOn
code: lemma _root_.Equiv.image_eq_iff_bijOn (e : α ≃ β) : e '' s = t ↔ BijOn e s t 
goal: ⇑e '' s = t ↔ Set.BijOn (⇑e) s t

full_name: Set.bijOn_id
code: lemma bijOn_id (s : Set α) : BijOn id s s 
goal: Set.BijOn id s s

full_name: Set.BijOn.comp
code: theorem BijOn.comp (hg : BijOn g t p) (hf : BijOn f s t) : BijOn (g ∘ f) s p 
goal: Set.BijOn (g ∘ f) s p

full_name: Set.BijOn.iterate
code: lemma BijOn.iterate {f : α → α} {s : Set α} (h : BijOn f s s) : ∀ n, BijOn f^[n] s s
  
goal: Set.BijOn f^[n] s s

full_name: Set.bijOn_of_subsingleton'
code: lemma bijOn_of_subsingleton' [Subsingleton α] [Subsingleton β] (f : α → β)
    (h : s.Nonempty ↔ t.Nonempty) : BijOn f s t 
goal: Set.BijOn f s t

full_name: Set.bijOn_of_subsingleton
code: lemma bijOn_of_subsingleton [Subsingleton α] (f : α → α) (s : Set α) : BijOn f s s 
goal: Set.BijOn f s s

full_name: Set.BijOn.bijective
code: theorem BijOn.bijective (h : BijOn f s t) : Bijective (h.mapsTo.restrict f s t) 
goal: Function.Bijective (Set.MapsTo.restrict f s t ⋯)

full_name: Set.bijective_iff_bijOn_univ
code: theorem bijective_iff_bijOn_univ : Bijective f ↔ BijOn f univ univ 
goal: Function.Bijective f ↔ Set.BijOn f Set.univ Set.univ

full_name: Set.BijOn.compl
code: theorem BijOn.compl (hst : BijOn f s t) (hf : Bijective f) : BijOn f sᶜ tᶜ 
goal: Set.BijOn f sᶜ tᶜ

full_name: Set.BijOn.subset_right
code: theorem BijOn.subset_right {r : Set β} (hf : BijOn f s t) (hrt : r ⊆ t) :
    BijOn f (s ∩ f ⁻¹' r) r 
goal: Set.BijOn f (s ∩ f ⁻¹' r) r

full_name: Set.BijOn.subset_left
code: theorem BijOn.subset_left {r : Set α} (hf : BijOn f s t) (hrs : r ⊆ s) :
    BijOn f r (f '' r) 
goal: Set.BijOn f r (f '' r)

full_name: Set.LeftInvOn.eqOn
code: theorem eqOn (h : LeftInvOn f' f s) : EqOn (f' ∘ f) id s 
goal: Set.EqOn (f' ∘ f) id s

full_name: Set.LeftInvOn.eq
code: theorem eq (h : LeftInvOn f' f s) {x} (hx : x ∈ s) : f' (f x) = x 
goal: f' (f x) = x

full_name: Set.LeftInvOn.congr_left
code: theorem congr_left (h₁ : LeftInvOn f₁' f s) {t : Set β} (h₁' : MapsTo f s t)
    (heq : EqOn f₁' f₂' t) : LeftInvOn f₂' f s 
goal: Set.LeftInvOn f₂' f s

full_name: Set.LeftInvOn.congr_right
code: theorem congr_right (h₁ : LeftInvOn f₁' f₁ s) (heq : EqOn f₁ f₂ s) : LeftInvOn f₁' f₂ s 
goal: Set.LeftInvOn f₁' f₂ s

full_name: Set.LeftInvOn.injOn
code: theorem injOn (h : LeftInvOn f₁' f s) : InjOn f s 
goal: Set.InjOn f s

full_name: Set.LeftInvOn.surjOn
code: theorem surjOn (h : LeftInvOn f' f s) (hf : MapsTo f s t) : SurjOn f' t s 
goal: Set.SurjOn f' t s

full_name: Set.LeftInvOn.mapsTo
code: theorem mapsTo (h : LeftInvOn f' f s) (hf : SurjOn f s t) :
    MapsTo f' t s 
goal: Set.MapsTo f' t s

full_name: Set.leftInvOn_id
code: lemma _root_.Set.leftInvOn_id (s : Set α) : LeftInvOn id id s 
goal: Set.LeftInvOn id id s

full_name: Set.LeftInvOn.comp
code: theorem comp (hf' : LeftInvOn f' f s) (hg' : LeftInvOn g' g t) (hf : MapsTo f s t) :
    LeftInvOn (f' ∘ g') (g ∘ f) s 
goal: Set.LeftInvOn (f' ∘ g') (g ∘ f) s

full_name: Set.LeftInvOn.mono
code: theorem mono (hf : LeftInvOn f' f s) (ht : s₁ ⊆ s) : LeftInvOn f' f s₁ 
goal: Set.LeftInvOn f' f s₁

full_name: Set.LeftInvOn.image_inter'
code: theorem image_inter' (hf : LeftInvOn f' f s) : f '' (s₁ ∩ s) = f' ⁻¹' s₁ ∩ f '' s 
goal: f '' (s₁ ∩ s) = f' ⁻¹' s₁ ∩ f '' s

full_name: Set.LeftInvOn.image_inter
code: theorem image_inter (hf : LeftInvOn f' f s) :
    f '' (s₁ ∩ s) = f' ⁻¹' (s₁ ∩ s) ∩ f '' s 
goal: f '' (s₁ ∩ s) = f' ⁻¹' (s₁ ∩ s) ∩ f '' s

full_name: Set.LeftInvOn.image_image
code: theorem image_image (hf : LeftInvOn f' f s) : f' '' (f '' s) = s 
goal: f' '' (f '' s) = s

full_name: Set.LeftInvOn.image_image'
code: theorem image_image' (hf : LeftInvOn f' f s) (hs : s₁ ⊆ s) : f' '' (f '' s₁) = s₁ 
goal: f' '' (f '' s₁) = s₁

full_name: Set.RightInvOn.eqOn
code: theorem eqOn (h : RightInvOn f' f t) : EqOn (f ∘ f') id t 
goal: Set.EqOn (f ∘ f') id t

full_name: Set.RightInvOn.eq
code: theorem eq (h : RightInvOn f' f t) {y} (hy : y ∈ t) : f (f' y) = y 
goal: f (f' y) = y

full_name: Set.LeftInvOn.rightInvOn_image
code: theorem _root_.Set.LeftInvOn.rightInvOn_image (h : LeftInvOn f' f s) : RightInvOn f' f (f '' s) 
goal: Set.RightInvOn f' f (f '' s)

full_name: Set.RightInvOn.congr_left
code: theorem congr_left (h₁ : RightInvOn f₁' f t) (heq : EqOn f₁' f₂' t) :
    RightInvOn f₂' f t 
goal: Set.RightInvOn f₂' f t

full_name: Set.RightInvOn.congr_right
code: theorem congr_right (h₁ : RightInvOn f' f₁ t) (hg : MapsTo f' t s) (heq : EqOn f₁ f₂ s) :
    RightInvOn f' f₂ t 
goal: Set.RightInvOn f' f₂ t

full_name: Set.RightInvOn.surjOn
code: theorem surjOn (hf : RightInvOn f' f t) (hf' : MapsTo f' t s) : SurjOn f s t 
goal: Set.SurjOn f s t

full_name: Set.RightInvOn.mapsTo
code: theorem mapsTo (h : RightInvOn f' f t) (hf : SurjOn f' t s) : MapsTo f s t 
goal: Set.MapsTo f s t

full_name: Set.rightInvOn_id
code: lemma _root_.Set.rightInvOn_id (s : Set α) : RightInvOn id id s 
goal: Set.RightInvOn id id s

full_name: Set.RightInvOn.comp
code: theorem comp (hf : RightInvOn f' f t) (hg : RightInvOn g' g p) (g'pt : MapsTo g' p t) :
    RightInvOn (f' ∘ g') (g ∘ f) p 
goal: Set.RightInvOn (f' ∘ g') (g ∘ f) p

full_name: Set.RightInvOn.mono
code: theorem mono (hf : RightInvOn f' f t) (ht : t₁ ⊆ t) : RightInvOn f' f t₁ 
goal: Set.RightInvOn f' f t₁

full_name: Set.InjOn.rightInvOn_of_leftInvOn
code: theorem InjOn.rightInvOn_of_leftInvOn (hf : InjOn f s) (hf' : LeftInvOn f f' t)
    (h₁ : MapsTo f s t) (h₂ : MapsTo f' t s) : RightInvOn f f' s 
goal: Set.RightInvOn f f' s

full_name: Set.eqOn_of_leftInvOn_of_rightInvOn
code: theorem eqOn_of_leftInvOn_of_rightInvOn (h₁ : LeftInvOn f₁' f s) (h₂ : RightInvOn f₂' f t)
    (h : MapsTo f₂' t s) : EqOn f₁' f₂' t 
goal: Set.EqOn f₁' f₂' t

full_name: Set.SurjOn.leftInvOn_of_rightInvOn
code: theorem SurjOn.leftInvOn_of_rightInvOn (hf : SurjOn f s t) (hf' : RightInvOn f f' s) :
    LeftInvOn f f' t 
goal: Set.LeftInvOn f f' t

full_name: Set.invOn_id
code: lemma _root_.Set.invOn_id (s : Set α) : InvOn id id s s 
goal: Set.InvOn id id s s

full_name: Set.InvOn.comp
code: lemma comp (hf : InvOn f' f s t) (hg : InvOn g' g t p) (fst : MapsTo f s t)
    (g'pt : MapsTo g' p t) :
    InvOn (f' ∘ g') (g ∘ f) s p 
goal: Set.InvOn (f' ∘ g') (g ∘ f) s p

full_name: Set.InvOn.symm
code: @[symm]
theorem symm (h : InvOn f' f s t) : InvOn f f' t s 
goal: Set.InvOn f f' t s

full_name: Set.InvOn.mono
code: theorem mono (h : InvOn f' f s t) (hs : s₁ ⊆ s) (ht : t₁ ⊆ t) : InvOn f' f s₁ t₁ 
goal: Set.InvOn f' f s₁ t₁

full_name: Set.InvOn.bijOn
code: /-- If functions `f'` and `f` are inverse on `s` and `t`, `f` maps `s` into `t`, and `f'` maps `t`
into `s`, then `f` is a bijection between `s` and `t`. The `mapsTo` arguments can be deduced from
`surjOn` statements using `LeftInvOn.mapsTo` and `RightInvOn.mapsTo`. -/
theorem bijOn (h : InvOn f' f s t) (hf : MapsTo f s t) (hf' : MapsTo f' t s) : BijOn f s t 
goal: Set.BijOn f s t

full_name: Function.invFunOn
code: /-- Construct the inverse for a function `f` on domain `s`. This function is a right inverse of `f`
on `f '' s`. For a computable version, see `Function.Embedding.invOfMemRange`. -/
noncomputable def invFunOn (f : α → β) (s : Set α) (b : β) : α 
goal: α

full_name: Function.invFunOn_pos
code: theorem invFunOn_pos (h : ∃ a ∈ s, f a = b) : invFunOn f s b ∈ s ∧ f (invFunOn f s b) = b 
goal: Function.invFunOn f s b ∈ s ∧ f (Function.invFunOn f s b) = b

full_name: Function.invFunOn_mem
code: theorem invFunOn_mem (h : ∃ a ∈ s, f a = b) : invFunOn f s b ∈ s 
goal: Function.invFunOn f s b ∈ s

full_name: Function.invFunOn_eq
code: theorem invFunOn_eq (h : ∃ a ∈ s, f a = b) : f (invFunOn f s b) = b 
goal: f (Function.invFunOn f s b) = b

full_name: Function.invFunOn_neg
code: theorem invFunOn_neg (h : ¬∃ a ∈ s, f a = b) : invFunOn f s b = Classical.choice ‹Nonempty α› 
goal: Function.invFunOn f s b = Classical.choice inst✝

full_name: Function.invFunOn_apply_mem
code: @[simp]
theorem invFunOn_apply_mem (h : a ∈ s) : invFunOn f s (f a) ∈ s 
goal: Function.invFunOn f s (f a) ∈ s

full_name: Function.invFunOn_apply_eq
code: theorem invFunOn_apply_eq (h : a ∈ s) : f (invFunOn f s (f a)) = f a 
goal: f (Function.invFunOn f s (f a)) = f a

full_name: Set.InjOn.leftInvOn_invFunOn
code: theorem InjOn.leftInvOn_invFunOn [Nonempty α] (h : InjOn f s) : LeftInvOn (invFunOn f s) f s 
goal: Set.LeftInvOn (Function.invFunOn f s) f s

full_name: Set.InjOn.invFunOn_image
code: theorem InjOn.invFunOn_image [Nonempty α] (h : InjOn f s₂) (ht : s₁ ⊆ s₂) :
    invFunOn f s₂ '' (f '' s₁) = s₁ 
goal: Function.invFunOn f s₂ '' (f '' s₁) = s₁

full_name: Function.leftInvOn_invFunOn_of_subset_image_image
code: theorem _root_.Function.leftInvOn_invFunOn_of_subset_image_image [Nonempty α]
    (h : s ⊆ (invFunOn f s) '' (f '' s)) : LeftInvOn (invFunOn f s) f s 
goal: Set.LeftInvOn (Function.invFunOn f s) f s

full_name: Set.injOn_iff_invFunOn_image_image_eq_self
code: theorem injOn_iff_invFunOn_image_image_eq_self [Nonempty α] :
    InjOn f s ↔ (invFunOn f s) '' (f '' s) = s 
goal: Set.InjOn f s ↔ Function.invFunOn f s '' (f '' s) = s

full_name: Function.invFunOn_injOn_image
code: theorem _root_.Function.invFunOn_injOn_image [Nonempty α] (f : α → β) (s : Set α) :
    Set.InjOn (invFunOn f s) (f '' s) 
goal: Set.InjOn (Function.invFunOn f s) (f '' s)

full_name: Function.invFunOn_image_image_subset
code: theorem _root_.Function.invFunOn_image_image_subset [Nonempty α] (f : α → β) (s : Set α) :
    (invFunOn f s) '' (f '' s) ⊆ s 
goal: Function.invFunOn f s '' (f '' s) ⊆ s

full_name: Set.SurjOn.rightInvOn_invFunOn
code: theorem SurjOn.rightInvOn_invFunOn [Nonempty α] (h : SurjOn f s t) :
    RightInvOn (invFunOn f s) f t 
goal: Set.RightInvOn (Function.invFunOn f s) f t

full_name: Set.BijOn.invOn_invFunOn
code: theorem BijOn.invOn_invFunOn [Nonempty α] (h : BijOn f s t) : InvOn (invFunOn f s) f s t 
goal: Set.InvOn (Function.invFunOn f s) f s t

full_name: Set.SurjOn.invOn_invFunOn
code: theorem SurjOn.invOn_invFunOn [Nonempty α] (h : SurjOn f s t) :
    InvOn (invFunOn f s) f (invFunOn f s '' t) t 
goal: Set.InvOn (Function.invFunOn f s) f (Function.invFunOn f s '' t) t

full_name: Set.SurjOn.mapsTo_invFunOn
code: theorem SurjOn.mapsTo_invFunOn [Nonempty α] (h : SurjOn f s t) : MapsTo (invFunOn f s) t s 
goal: Set.MapsTo (Function.invFunOn f s) t s

full_name: Set.SurjOn.image_invFunOn_image_of_subset
code: /-- This lemma is a special case of `rightInvOn_invFunOn.image_image'`; it may make more sense
to use the other lemma directly in an application. -/
theorem SurjOn.image_invFunOn_image_of_subset [Nonempty α] {r : Set β} (hf : SurjOn f s t)
    (hrt : r ⊆ t) : f '' (f.invFunOn s '' r) = r 
goal: f '' (Function.invFunOn f s '' r) = r

full_name: Set.SurjOn.image_invFunOn_image
code: /-- This lemma is a special case of `rightInvOn_invFunOn.image_image`; it may make more sense
to use the other lemma directly in an application. -/
theorem SurjOn.image_invFunOn_image [Nonempty α] (hf : SurjOn f s t) :
    f '' (f.invFunOn s '' t) = t 
goal: f '' (Function.invFunOn f s '' t) = t

full_name: Set.SurjOn.bijOn_subset
code: theorem SurjOn.bijOn_subset [Nonempty α] (h : SurjOn f s t) : BijOn f (invFunOn f s '' t) t 
goal: Set.BijOn f (Function.invFunOn f s '' t) t

full_name: Set.surjOn_iff_exists_bijOn_subset
code: theorem surjOn_iff_exists_bijOn_subset : SurjOn f s t ↔ ∃ s' ⊆ s, BijOn f s' t 
goal: Set.SurjOn f s t ↔ ∃ s' ⊆ s, Set.BijOn f s' t

full_name: Set.exists_subset_bijOn
code: lemma exists_subset_bijOn : ∃ s' ⊆ s, BijOn f s' (f '' s) 
goal: ∃ s' ⊆ s, Set.BijOn f s' (f '' s)

full_name: Set.exists_image_eq_and_injOn
code: lemma exists_image_eq_and_injOn : ∃ u, f '' u =  f '' s ∧ InjOn f u 
goal: ∃ u, f '' u = f '' s ∧ Set.InjOn f u

full_name: Set.exists_image_eq_injOn_of_subset_range
code: lemma exists_image_eq_injOn_of_subset_range (ht : t ⊆ range f) :
    ∃ s, f '' s = t ∧ InjOn f s 
goal: ∃ s, f '' s = t ∧ Set.InjOn f s

full_name: Set.BijOn.exists_extend_of_subset
code: /-- If `f` maps `s` bijectively to `t` and a set `t'` is contained in the image of some `s₁ ⊇ s`,
then `s₁` has a subset containing `s` that `f` maps bijectively to `t'`.-/
theorem BijOn.exists_extend_of_subset {t' : Set β} (h : BijOn f s t) (hss₁ : s ⊆ s₁) (htt' : t ⊆ t')
    (ht' : SurjOn f s₁ t') : ∃ s', s ⊆ s' ∧ s' ⊆ s₁ ∧ Set.BijOn f s' t' 
goal: ∃ s', s ⊆ s' ∧ s' ⊆ s₁ ∧ Set.BijOn f s' t'

full_name: Set.BijOn.exists_extend
code: /-- If `f` maps `s` bijectively to `t`, and `t'` is a superset of `t` contained in the range of `f`,
then `f` maps some superset of `s` bijectively to `t'`. -/
theorem BijOn.exists_extend {t' : Set β} (h : BijOn f s t) (htt' : t ⊆ t') (ht' : t' ⊆ range f) :
    ∃ s', s ⊆ s' ∧ BijOn f s' t' 
goal: ∃ s', s ⊆ s' ∧ Set.BijOn f s' t'

full_name: Set.InjOn.exists_subset_injOn_subset_range_eq
code: theorem InjOn.exists_subset_injOn_subset_range_eq {r : Set α} (hinj : InjOn f r) (hrs : r ⊆ s) :
    ∃ u : Set α, r ⊆ u ∧ u ⊆ s ∧ f '' u = f '' s ∧ InjOn f u 
goal: ∃ u, r ⊆ u ∧ u ⊆ s ∧ f '' u = f '' s ∧ Set.InjOn f u

full_name: Set.preimage_invFun_of_mem
code: theorem preimage_invFun_of_mem [n : Nonempty α] {f : α → β} (hf : Injective f) {s : Set α}
    (h : Classical.choice n ∈ s) : invFun f ⁻¹' s = f '' s ∪ (range f)ᶜ 
goal: Function.invFun f ⁻¹' s = f '' s ∪ (Set.range f)ᶜ

full_name: Set.preimage_invFun_of_not_mem
code: theorem preimage_invFun_of_not_mem [n : Nonempty α] {f : α → β} (hf : Injective f) {s : Set α}
    (h : Classical.choice n ∉ s) : invFun f ⁻¹' s = f '' s 
goal: Function.invFun f ⁻¹' s = f '' s

full_name: Set.BijOn.symm
code: lemma BijOn.symm {g : β → α} (h : InvOn f g t s) (hf : BijOn f s t) : BijOn g t s 
goal: Set.BijOn g t s

full_name: Set.bijOn_comm
code: lemma bijOn_comm {g : β → α} (h : InvOn f g t s) : BijOn f s t ↔ BijOn g t s 
goal: Set.BijOn f s t ↔ Set.BijOn g t s

full_name: Monotone.restrict
code: protected theorem restrict (h : Monotone f) (s : Set α) : Monotone (s.restrict f) 
goal: Monotone (s.restrict f)

full_name: Monotone.codRestrict
code: protected theorem codRestrict (h : Monotone f) {s : Set β} (hs : ∀ x, f x ∈ s) :
    Monotone (s.codRestrict f hs) 
goal: Monotone (Set.codRestrict f s hs)

full_name: Monotone.rangeFactorization
code: protected theorem rangeFactorization (h : Monotone f) : Monotone (Set.rangeFactorization f) 
goal: Monotone (Set.rangeFactorization f)

full_name: Set.piecewise_empty
code: @[simp]
theorem piecewise_empty [∀ i : α, Decidable (i ∈ (∅ : Set α))] : piecewise ∅ f g = g 
goal: ∅.piecewise f g = g

full_name: Set.piecewise_univ
code: @[simp]
theorem piecewise_univ [∀ i : α, Decidable (i ∈ (Set.univ : Set α))] :
    piecewise Set.univ f g = f 
goal: Set.univ.piecewise f g = f

full_name: Set.piecewise_insert_self
code: theorem piecewise_insert_self {j : α} [∀ i, Decidable (i ∈ insert j s)] :
    (insert j s).piecewise f g j = f j 
goal: (insert j s).piecewise f g j = f j

full_name: Set.Compl.decidableMem
code: instance Compl.decidableMem (j : α) : Decidable (j ∈ sᶜ) 
goal: Decidable (j ∈ sᶜ)

full_name: Set.piecewise_insert
code: theorem piecewise_insert [DecidableEq α] (j : α) [∀ i, Decidable (i ∈ insert j s)] :
    (insert j s).piecewise f g = Function.update (s.piecewise f g) j (f j) 
goal: (insert j s).piecewise f g = Function.update (s.piecewise f g) j (f j)

full_name: Set.piecewise_eq_of_mem
code: @[simp]
theorem piecewise_eq_of_mem {i : α} (hi : i ∈ s) : s.piecewise f g i = f i 
goal: s.piecewise f g i = f i

full_name: Set.piecewise_eq_of_not_mem
code: @[simp]
theorem piecewise_eq_of_not_mem {i : α} (hi : i ∉ s) : s.piecewise f g i = g i 
goal: s.piecewise f g i = g i

full_name: Set.piecewise_singleton
code: theorem piecewise_singleton (x : α) [∀ y, Decidable (y ∈ ({x} : Set α))] [DecidableEq α]
    (f g : α → β) : piecewise {x} f g = Function.update g x (f x) 
goal: {x}.piecewise f g = Function.update g x (f x)

full_name: Set.piecewise_eqOn
code: theorem piecewise_eqOn (f g : α → β) : EqOn (s.piecewise f g) f s 
goal: Set.EqOn (s.piecewise f g) f s

full_name: Set.piecewise_eqOn_compl
code: theorem piecewise_eqOn_compl (f g : α → β) : EqOn (s.piecewise f g) g sᶜ 
goal: Set.EqOn (s.piecewise f g) g sᶜ

full_name: Set.piecewise_le
code: theorem piecewise_le {δ : α → Type*} [∀ i, Preorder (δ i)] {s : Set α} [∀ j, Decidable (j ∈ s)]
    {f₁ f₂ g : ∀ i, δ i} (h₁ : ∀ i ∈ s, f₁ i ≤ g i) (h₂ : ∀ i ∉ s, f₂ i ≤ g i) :
    s.piecewise f₁ f₂ ≤ g 
goal: s.piecewise f₁ f₂ ≤ g

full_name: Set.le_piecewise
code: theorem le_piecewise {δ : α → Type*} [∀ i, Preorder (δ i)] {s : Set α} [∀ j, Decidable (j ∈ s)]
    {f₁ f₂ g : ∀ i, δ i} (h₁ : ∀ i ∈ s, g i ≤ f₁ i) (h₂ : ∀ i ∉ s, g i ≤ f₂ i) :
    g ≤ s.piecewise f₁ f₂ 
goal: g ≤ s.piecewise f₁ f₂

full_name: Set.piecewise_le_piecewise
code: theorem piecewise_le_piecewise {δ : α → Type*} [∀ i, Preorder (δ i)] {s : Set α}
    [∀ j, Decidable (j ∈ s)] {f₁ f₂ g₁ g₂ : ∀ i, δ i} (h₁ : ∀ i ∈ s, f₁ i ≤ g₁ i)
    (h₂ : ∀ i ∉ s, f₂ i ≤ g₂ i) : s.piecewise f₁ f₂ ≤ s.piecewise g₁ g₂ 
goal: s.piecewise f₁ f₂ ≤ s.piecewise g₁ g₂

full_name: Set.piecewise_insert_of_ne
code: @[simp]
theorem piecewise_insert_of_ne {i j : α} (h : i ≠ j) [∀ i, Decidable (i ∈ insert j s)] :
    (insert j s).piecewise f g i = s.piecewise f g i 
goal: (insert j s).piecewise f g i = s.piecewise f g i

full_name: Set.piecewise_compl
code: @[simp]
theorem piecewise_compl [∀ i, Decidable (i ∈ sᶜ)] : sᶜ.piecewise f g = s.piecewise g f 
goal: sᶜ.piecewise f g = s.piecewise g f

full_name: Set.piecewise_range_comp
code: @[simp]
theorem piecewise_range_comp {ι : Sort*} (f : ι → α) [∀ j, Decidable (j ∈ range f)]
    (g₁ g₂ : α → β) : (range f).piecewise g₁ g₂ ∘ f = g₁ ∘ f 
goal: (Set.range f).piecewise g₁ g₂ ∘ f = g₁ ∘ f

full_name: Set.MapsTo.piecewise_ite
code: theorem MapsTo.piecewise_ite {s s₁ s₂ : Set α} {t t₁ t₂ : Set β} {f₁ f₂ : α → β}
    [∀ i, Decidable (i ∈ s)] (h₁ : MapsTo f₁ (s₁ ∩ s) (t₁ ∩ t))
    (h₂ : MapsTo f₂ (s₂ ∩ sᶜ) (t₂ ∩ tᶜ)) :
    MapsTo (s.piecewise f₁ f₂) (s.ite s₁ s₂) (t.ite t₁ t₂) 
goal: Set.MapsTo (s.piecewise f₁ f₂) (s.ite s₁ s₂) (t.ite t₁ t₂)

full_name: Set.eqOn_piecewise
code: theorem eqOn_piecewise {f f' g : α → β} {t} :
    EqOn (s.piecewise f f') g t ↔ EqOn f g (t ∩ s) ∧ EqOn f' g (t ∩ sᶜ) 
goal: Set.EqOn (s.piecewise f f') g t ↔ Set.EqOn f g (t ∩ s) ∧ Set.EqOn f' g (t ∩ sᶜ)

full_name: Set.EqOn.piecewise_ite'
code: theorem EqOn.piecewise_ite' {f f' g : α → β} {t t'} (h : EqOn f g (t ∩ s))
    (h' : EqOn f' g (t' ∩ sᶜ)) : EqOn (s.piecewise f f') g (s.ite t t') 
goal: Set.EqOn (s.piecewise f f') g (s.ite t t')

full_name: Set.EqOn.piecewise_ite
code: theorem EqOn.piecewise_ite {f f' g : α → β} {t t'} (h : EqOn f g t) (h' : EqOn f' g t') :
    EqOn (s.piecewise f f') g (s.ite t t') 
goal: Set.EqOn (s.piecewise f f') g (s.ite t t')

full_name: Set.piecewise_preimage
code: theorem piecewise_preimage (f g : α → β) (t) : s.piecewise f g ⁻¹' t = s.ite (f ⁻¹' t) (g ⁻¹' t) 
goal: s.piecewise f g ⁻¹' t = s.ite (f ⁻¹' t) (g ⁻¹' t)

full_name: Set.apply_piecewise
code: theorem apply_piecewise {δ' : α → Sort*} (h : ∀ i, δ i → δ' i) {x : α} :
    h x (s.piecewise f g x) = s.piecewise (fun x => h x (f x)) (fun x => h x (g x)) x 
goal: h x (s.piecewise f g x) = s.piecewise (fun x => h x (f x)) (fun x => h x (g x)) x

full_name: Set.apply_piecewise₂
code: theorem apply_piecewise₂ {δ' δ'' : α → Sort*} (f' g' : ∀ i, δ' i) (h : ∀ i, δ i → δ' i → δ'' i)
    {x : α} :
    h x (s.piecewise f g x) (s.piecewise f' g' x) =
      s.piecewise (fun x => h x (f x) (f' x)) (fun x => h x (g x) (g' x)) x 
goal: h x (s.piecewise f g x) (s.piecewise f' g' x) = s.piecewise (fun x => h x (f x) (f' x)) (fun x => h x (g x) (g' x)) x

full_name: Set.piecewise_op
code: theorem piecewise_op {δ' : α → Sort*} (h : ∀ i, δ i → δ' i) :
    (s.piecewise (fun x => h x (f x)) fun x => h x (g x)) = fun x => h x (s.piecewise f g x) 
goal: (s.piecewise (fun x => h x (f x)) fun x => h x (g x)) = fun x => h x (s.piecewise f g x)

full_name: Set.piecewise_op₂
code: theorem piecewise_op₂ {δ' δ'' : α → Sort*} (f' g' : ∀ i, δ' i) (h : ∀ i, δ i → δ' i → δ'' i) :
    (s.piecewise (fun x => h x (f x) (f' x)) fun x => h x (g x) (g' x)) = fun x =>
      h x (s.piecewise f g x) (s.piecewise f' g' x) 
goal: (s.piecewise (fun x => h x (f x) (f' x)) fun x => h x (g x) (g' x)) = fun x =>
  h x (s.piecewise f g x) (s.piecewise f' g' x)

full_name: Set.piecewise_same
code: @[simp]
theorem piecewise_same : s.piecewise f f = f 
goal: s.piecewise f f = f

full_name: Set.range_piecewise
code: theorem range_piecewise (f g : α → β) : range (s.piecewise f g) = f '' s ∪ g '' sᶜ 
goal: Set.range (s.piecewise f g) = f '' s ∪ g '' sᶜ

full_name: Set.injective_piecewise_iff
code: theorem injective_piecewise_iff {f g : α → β} :
    Injective (s.piecewise f g) ↔
      InjOn f s ∧ InjOn g sᶜ ∧ ∀ x ∈ s, ∀ y ∉ s, f x ≠ g y 
goal: Function.Injective (s.piecewise f g) ↔ Set.InjOn f s ∧ Set.InjOn g sᶜ ∧ ∀ x ∈ s, ∀ y ∉ s, f x ≠ g y

full_name: Set.piecewise_mem_pi
code: theorem piecewise_mem_pi {δ : α → Type*} {t : Set α} {t' : ∀ i, Set (δ i)} {f g} (hf : f ∈ pi t t')
    (hg : g ∈ pi t t') : s.piecewise f g ∈ pi t t' 
goal: s.piecewise f g ∈ t.pi t'

full_name: Set.pi_piecewise
code: @[simp]
theorem pi_piecewise {ι : Type*} {α : ι → Type*} (s s' : Set ι) (t t' : ∀ i, Set (α i))
    [∀ x, Decidable (x ∈ s')] : pi s (s'.piecewise t t') = pi (s ∩ s') t ∩ pi (s \ s') t' 
goal: s.pi (s'.piecewise t t') = (s ∩ s').pi t ∩ (s \ s').pi t'

full_name: Set.univ_pi_piecewise
code: theorem univ_pi_piecewise {ι : Type*} {α : ι → Type*} (s : Set ι) (t t' : ∀ i, Set (α i))
    [∀ x, Decidable (x ∈ s)] : pi univ (s.piecewise t t') = pi s t ∩ pi sᶜ t' 
goal: Set.univ.pi (s.piecewise t t') = s.pi t ∩ sᶜ.pi t'

full_name: Set.univ_pi_piecewise_univ
code: theorem univ_pi_piecewise_univ {ι : Type*} {α : ι → Type*} (s : Set ι) (t : ∀ i, Set (α i))
    [∀ x, Decidable (x ∈ s)] : pi univ (s.piecewise t fun _ => univ) = pi s t 
goal: Set.univ.pi (s.piecewise t fun x => Set.univ) = s.pi t

full_name: StrictMonoOn.injOn
code: theorem StrictMonoOn.injOn [LinearOrder α] [Preorder β] {f : α → β} {s : Set α}
    (H : StrictMonoOn f s) : s.InjOn f 
goal: Set.InjOn f s

full_name: StrictAntiOn.injOn
code: theorem StrictAntiOn.injOn [LinearOrder α] [Preorder β] {f : α → β} {s : Set α}
    (H : StrictAntiOn f s) : s.InjOn f 
goal: Set.InjOn f s

full_name: StrictMonoOn.comp
code: theorem StrictMonoOn.comp [Preorder α] [Preorder β] [Preorder γ] {g : β → γ} {f : α → β} {s : Set α}
    {t : Set β} (hg : StrictMonoOn g t) (hf : StrictMonoOn f s) (hs : Set.MapsTo f s t) :
    StrictMonoOn (g ∘ f) s 
goal: StrictMonoOn (g ∘ f) s

full_name: StrictMonoOn.comp_strictAntiOn
code: theorem StrictMonoOn.comp_strictAntiOn [Preorder α] [Preorder β] [Preorder γ] {g : β → γ}
    {f : α → β} {s : Set α} {t : Set β} (hg : StrictMonoOn g t) (hf : StrictAntiOn f s)
    (hs : Set.MapsTo f s t) : StrictAntiOn (g ∘ f) s 
goal: StrictAntiOn (g ∘ f) s

full_name: StrictAntiOn.comp
code: theorem StrictAntiOn.comp [Preorder α] [Preorder β] [Preorder γ] {g : β → γ} {f : α → β} {s : Set α}
    {t : Set β} (hg : StrictAntiOn g t) (hf : StrictAntiOn f s) (hs : Set.MapsTo f s t) :
    StrictMonoOn (g ∘ f) s 
goal: StrictMonoOn (g ∘ f) s

full_name: StrictAntiOn.comp_strictMonoOn
code: theorem StrictAntiOn.comp_strictMonoOn [Preorder α] [Preorder β] [Preorder γ] {g : β → γ}
    {f : α → β} {s : Set α} {t : Set β} (hg : StrictAntiOn g t) (hf : StrictMonoOn f s)
    (hs : Set.MapsTo f s t) : StrictAntiOn (g ∘ f) s 
goal: StrictAntiOn (g ∘ f) s

full_name: strictMono_restrict
code: @[simp]
theorem strictMono_restrict [Preorder α] [Preorder β] {f : α → β} {s : Set α} :
    StrictMono (s.restrict f) ↔ StrictMonoOn f s 
goal: StrictMono (s.restrict f) ↔ StrictMonoOn f s

full_name: StrictMono.codRestrict
code: theorem StrictMono.codRestrict [Preorder α] [Preorder β] {f : α → β} (hf : StrictMono f)
    {s : Set β} (hs : ∀ x, f x ∈ s) : StrictMono (Set.codRestrict f s hs) 
goal: StrictMono (Set.codRestrict f s hs)

full_name: Function.Injective.comp_injOn
code: theorem Injective.comp_injOn (hg : Injective g) (hf : s.InjOn f) : s.InjOn (g ∘ f) 
goal: Set.InjOn (g ∘ f) s

full_name: Function.Surjective.surjOn
code: theorem Surjective.surjOn (hf : Surjective f) (s : Set β) : SurjOn f univ s 
goal: Set.SurjOn f Set.univ s

full_name: Function.LeftInverse.leftInvOn
code: theorem LeftInverse.leftInvOn {g : β → α} (h : LeftInverse f g) (s : Set β) : LeftInvOn f g s 
goal: Set.LeftInvOn f g s

full_name: Function.RightInverse.rightInvOn
code: theorem RightInverse.rightInvOn {g : β → α} (h : RightInverse f g) (s : Set α) :
    RightInvOn f g s 
goal: Set.RightInvOn f g s

full_name: Function.LeftInverse.rightInvOn_range
code: theorem LeftInverse.rightInvOn_range {g : β → α} (h : LeftInverse f g) :
    RightInvOn f g (range g) 
goal: Set.RightInvOn f g (Set.range g)

full_name: Function.Semiconj.mapsTo_image
code: theorem mapsTo_image (h : Semiconj f fa fb) (ha : MapsTo fa s t) : MapsTo fb (f '' s) (f '' t) 
goal: Set.MapsTo fb (f '' s) (f '' t)

full_name: Function.Semiconj.mapsTo_range
code: theorem mapsTo_range (h : Semiconj f fa fb) : MapsTo fb (range f) (range f) 
goal: Set.MapsTo fb (Set.range f) (Set.range f)

full_name: Function.Semiconj.surjOn_image
code: theorem surjOn_image (h : Semiconj f fa fb) (ha : SurjOn fa s t) : SurjOn fb (f '' s) (f '' t) 
goal: Set.SurjOn fb (f '' s) (f '' t)

full_name: Function.Semiconj.surjOn_range
code: theorem surjOn_range (h : Semiconj f fa fb) (ha : Surjective fa) :
    SurjOn fb (range f) (range f) 
goal: Set.SurjOn fb (Set.range f) (Set.range f)

full_name: Function.Semiconj.injOn_image
code: theorem injOn_image (h : Semiconj f fa fb) (ha : InjOn fa s) (hf : InjOn f (fa '' s)) :
    InjOn fb (f '' s) 
goal: Set.InjOn fb (f '' s)

full_name: Function.Semiconj.injOn_range
code: theorem injOn_range (h : Semiconj f fa fb) (ha : Injective fa) (hf : InjOn f (range fa)) :
    InjOn fb (range f) 
goal: Set.InjOn fb (Set.range f)

full_name: Function.Semiconj.bijOn_image
code: theorem bijOn_image (h : Semiconj f fa fb) (ha : BijOn fa s t) (hf : InjOn f t) :
    BijOn fb (f '' s) (f '' t) 
goal: Set.BijOn fb (f '' s) (f '' t)

full_name: Function.Semiconj.bijOn_range
code: theorem bijOn_range (h : Semiconj f fa fb) (ha : Bijective fa) (hf : Injective f) :
    BijOn fb (range f) (range f) 
goal: Set.BijOn fb (Set.range f) (Set.range f)

full_name: Function.Semiconj.mapsTo_preimage
code: theorem mapsTo_preimage (h : Semiconj f fa fb) {s t : Set β} (hb : MapsTo fb s t) :
    MapsTo fa (f ⁻¹' s) (f ⁻¹' t) 
goal: Set.MapsTo fa (f ⁻¹' s) (f ⁻¹' t)

full_name: Function.Semiconj.injOn_preimage
code: theorem injOn_preimage (h : Semiconj f fa fb) {s : Set β} (hb : InjOn fb s)
    (hf : InjOn f (f ⁻¹' s)) : InjOn fa (f ⁻¹' s) 
goal: Set.InjOn fa (f ⁻¹' s)

full_name: Function.update_comp_eq_of_not_mem_range'
code: theorem update_comp_eq_of_not_mem_range' {α : Sort*} {β : Type*} {γ : β → Sort*} [DecidableEq β]
    (g : ∀ b, γ b) {f : α → β} {i : β} (a : γ i) (h : i ∉ Set.range f) :
    (fun j => update g i a (f j)) = fun j => g (f j) 
goal: (fun j => Function.update g i a (f j)) = fun j => g (f j)

full_name: Function.update_comp_eq_of_not_mem_range
code: /-- Non-dependent version of `Function.update_comp_eq_of_not_mem_range'` -/
theorem update_comp_eq_of_not_mem_range {α : Sort*} {β : Type*} {γ : Sort*} [DecidableEq β]
    (g : β → γ) {f : α → β} {i : β} (a : γ) (h : i ∉ Set.range f) : update g i a ∘ f = g ∘ f 
goal: Function.update g i a ∘ f = g ∘ f

full_name: Function.insert_injOn
code: theorem insert_injOn (s : Set α) : sᶜ.InjOn fun a => insert a s 
goal: Set.InjOn (fun a => insert a s) sᶜ

full_name: Function.monotoneOn_of_rightInvOn_of_mapsTo
code: theorem monotoneOn_of_rightInvOn_of_mapsTo {α β : Type*} [PartialOrder α] [LinearOrder β]
    {φ : β → α} {ψ : α → β} {t : Set β} {s : Set α} (hφ : MonotoneOn φ t)
    (φψs : Set.RightInvOn ψ φ s) (ψts : Set.MapsTo ψ s t) : MonotoneOn ψ s 
goal: MonotoneOn ψ s

full_name: Function.antitoneOn_of_rightInvOn_of_mapsTo
code: theorem antitoneOn_of_rightInvOn_of_mapsTo [PartialOrder α] [LinearOrder β]
    {φ : β → α} {ψ : α → β} {t : Set β} {s : Set α} (hφ : AntitoneOn φ t)
    (φψs : Set.RightInvOn ψ φ s) (ψts : Set.MapsTo ψ s t) : AntitoneOn ψ s 
goal: AntitoneOn ψ s

full_name: Set.MapsTo.extendDomain
code: protected lemma MapsTo.extendDomain (h : MapsTo g s t) :
    MapsTo (g.extendDomain f) ((↑) ∘ f '' s) ((↑) ∘ f '' t) 
goal: Set.MapsTo (⇑(g.extendDomain f)) (Subtype.val ∘ ⇑f '' s) (Subtype.val ∘ ⇑f '' t)

full_name: Set.SurjOn.extendDomain
code: protected lemma SurjOn.extendDomain (h : SurjOn g s t) :
    SurjOn (g.extendDomain f) ((↑) ∘ f '' s) ((↑) ∘ f '' t) 
goal: Set.SurjOn (⇑(g.extendDomain f)) (Subtype.val ∘ ⇑f '' s) (Subtype.val ∘ ⇑f '' t)

full_name: Set.BijOn.extendDomain
code: protected lemma BijOn.extendDomain (h : BijOn g s t) :
    BijOn (g.extendDomain f) ((↑) ∘ f '' s) ((↑) ∘ f '' t) 
goal: Set.BijOn (⇑(g.extendDomain f)) (Subtype.val ∘ ⇑f '' s) (Subtype.val ∘ ⇑f '' t)

full_name: Set.LeftInvOn.extendDomain
code: protected lemma LeftInvOn.extendDomain (h : LeftInvOn g₁ g₂ s) :
    LeftInvOn (g₁.extendDomain f) (g₂.extendDomain f) ((↑) ∘ f '' s) 
goal: Set.LeftInvOn (⇑(g₁.extendDomain f)) (⇑(g₂.extendDomain f)) (Subtype.val ∘ ⇑f '' s)

full_name: Set.RightInvOn.extendDomain
code: protected lemma RightInvOn.extendDomain (h : RightInvOn g₁ g₂ t) :
    RightInvOn (g₁.extendDomain f) (g₂.extendDomain f) ((↑) ∘ f '' t) 
goal: Set.RightInvOn (⇑(g₁.extendDomain f)) (⇑(g₂.extendDomain f)) (Subtype.val ∘ ⇑f '' t)

full_name: Set.InvOn.extendDomain
code: protected lemma InvOn.extendDomain (h : InvOn g₁ g₂ s t) :
    InvOn (g₁.extendDomain f) (g₂.extendDomain f) ((↑) ∘ f '' s) ((↑) ∘ f '' t) 
goal: Set.InvOn (⇑(g₁.extendDomain f)) (⇑(g₂.extendDomain f)) (Subtype.val ∘ ⇑f '' s) (Subtype.val ∘ ⇑f '' t)

full_name: Set.InjOn.prodMap
code: lemma InjOn.prodMap (h₁ : s₁.InjOn f₁) (h₂ : s₂.InjOn f₂) :
    (s₁ ×ˢ s₂).InjOn fun x ↦ (f₁ x.1, f₂ x.2) 
goal: Set.InjOn (fun x => (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂)

full_name: Set.SurjOn.prodMap
code: lemma SurjOn.prodMap (h₁ : SurjOn f₁ s₁ t₁) (h₂ : SurjOn f₂ s₂ t₂) :
    SurjOn (fun x ↦ (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂) (t₁ ×ˢ t₂) 
goal: Set.SurjOn (fun x => (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂) (t₁ ×ˢ t₂)

full_name: Set.MapsTo.prodMap
code: lemma MapsTo.prodMap (h₁ : MapsTo f₁ s₁ t₁) (h₂ : MapsTo f₂ s₂ t₂) :
    MapsTo (fun x ↦ (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂) (t₁ ×ˢ t₂) 
goal: Set.MapsTo (fun x => (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂) (t₁ ×ˢ t₂)

full_name: Set.BijOn.prodMap
code: lemma BijOn.prodMap (h₁ : BijOn f₁ s₁ t₁) (h₂ : BijOn f₂ s₂ t₂) :
    BijOn (fun x ↦ (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂) (t₁ ×ˢ t₂) 
goal: Set.BijOn (fun x => (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂) (t₁ ×ˢ t₂)

full_name: Set.LeftInvOn.prodMap
code: lemma LeftInvOn.prodMap (h₁ : LeftInvOn g₁ f₁ s₁) (h₂ : LeftInvOn g₂ f₂ s₂) :
    LeftInvOn (fun x ↦ (g₁ x.1, g₂ x.2)) (fun x ↦ (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂) 
goal: Set.LeftInvOn (fun x => (g₁ x.1, g₂ x.2)) (fun x => (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂)

full_name: Set.RightInvOn.prodMap
code: lemma RightInvOn.prodMap (h₁ : RightInvOn g₁ f₁ t₁) (h₂ : RightInvOn g₂ f₂ t₂) :
    RightInvOn (fun x ↦ (g₁ x.1, g₂ x.2)) (fun x ↦ (f₁ x.1, f₂ x.2)) (t₁ ×ˢ t₂) 
goal: Set.RightInvOn (fun x => (g₁ x.1, g₂ x.2)) (fun x => (f₁ x.1, f₂ x.2)) (t₁ ×ˢ t₂)

full_name: Set.InvOn.prodMap
code: lemma InvOn.prodMap (h₁ : InvOn g₁ f₁ s₁ t₁) (h₂ : InvOn g₂ f₂ s₂ t₂) :
    InvOn (fun x ↦ (g₁ x.1, g₂ x.2)) (fun x ↦ (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂) (t₁ ×ˢ t₂) 
goal: Set.InvOn (fun x => (g₁ x.1, g₂ x.2)) (fun x => (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂) (t₁ ×ˢ t₂)

full_name: Equiv.bijOn'
code: lemma bijOn' (h₁ : MapsTo e s t) (h₂ : MapsTo e.symm t s) : BijOn e s t 
goal: Set.BijOn (⇑e) s t

full_name: Equiv.bijOn
code: protected lemma bijOn (h : ∀ a, e a ∈ t ↔ a ∈ s) : BijOn e s t 
goal: Set.BijOn (⇑e) s t

full_name: Equiv.invOn
code: lemma invOn : InvOn e e.symm t s 
goal: Set.InvOn (⇑e) (⇑e.symm) t s

full_name: Equiv.bijOn_image
code: lemma bijOn_image : BijOn e s (e '' s) 
goal: Set.BijOn (⇑e) s (⇑e '' s)

full_name: Equiv.bijOn_symm_image
code: lemma bijOn_symm_image : BijOn e.symm (e '' s) s 
goal: Set.BijOn (⇑e.symm) (⇑e '' s) s

full_name: Equiv.bijOn_symm
code: @[simp] lemma bijOn_symm : BijOn e.symm t s ↔ BijOn e s t 
goal: Set.BijOn (⇑e.symm) t s ↔ Set.BijOn (⇑e) s t

full_name: Equiv.bijOn_swap
code: lemma bijOn_swap (ha : a ∈ s) (hb : b ∈ s) : BijOn (swap a b) s s 
goal: Set.BijOn (⇑(Equiv.swap a b)) s s