File: Mathlib/Order/Interval/Set/ProjIcc.lean

full_name: Set.projIci
code: /-- Projection of `α` to the closed interval `[a, ∞)`. -/
def projIci (a x : α) : Ici a 
goal: ↑(Set.Ici a)

full_name: Set.projIic
code: /-- Projection of `α` to the closed interval `(-∞, b]`. -/
def projIic (b x : α) : Iic b 
goal: ↑(Set.Iic b)

full_name: Set.projIcc
code: /-- Projection of `α` to the closed interval `[a, b]`. -/
def projIcc (a b : α) (h : a ≤ b) (x : α) : Icc a b 
goal: ↑(Set.Icc a b)

full_name: Set.coe_projIci
code: @[norm_cast]
theorem coe_projIci (a x : α) : (projIci a x : α) = max a x 
goal: ↑(Set.projIci a x) = max a x

full_name: Set.coe_projIic
code: @[norm_cast]
theorem coe_projIic (b x : α) : (projIic b x : α) = min b x 
goal: ↑(Set.projIic b x) = min b x

full_name: Set.coe_projIcc
code: @[norm_cast]
theorem coe_projIcc (a b : α) (h : a ≤ b) (x : α) : (projIcc a b h x : α) = max a (min b x) 
goal: ↑(Set.projIcc a b h x) = max a (min b x)

full_name: Set.projIci_of_le
code: theorem projIci_of_le (hx : x ≤ a) : projIci a x = ⟨a, le_rfl⟩ 
goal: Set.projIci a x = ⟨a, ⋯⟩

full_name: Set.projIic_of_le
code: theorem projIic_of_le (hx : b ≤ x) : projIic b x = ⟨b, le_rfl⟩ 
goal: Set.projIic b x = ⟨b, ⋯⟩

full_name: Set.projIcc_of_le_left
code: theorem projIcc_of_le_left (hx : x ≤ a) : projIcc a b h x = ⟨a, left_mem_Icc.2 h⟩ 
goal: Set.projIcc a b h x = ⟨a, ⋯⟩

full_name: Set.projIcc_of_right_le
code: theorem projIcc_of_right_le (hx : b ≤ x) : projIcc a b h x = ⟨b, right_mem_Icc.2 h⟩ 
goal: Set.projIcc a b h x = ⟨b, ⋯⟩

full_name: Set.projIci_self
code: @[simp]
theorem projIci_self (a : α) : projIci a a = ⟨a, le_rfl⟩ 
goal: Set.projIci a a = ⟨a, ⋯⟩

full_name: Set.projIic_self
code: @[simp]
theorem projIic_self (b : α) : projIic b b = ⟨b, le_rfl⟩ 
goal: Set.projIic b b = ⟨b, ⋯⟩

full_name: Set.projIcc_left
code: @[simp]
theorem projIcc_left : projIcc a b h a = ⟨a, left_mem_Icc.2 h⟩ 
goal: Set.projIcc a b h a = ⟨a, ⋯⟩

full_name: Set.projIcc_right
code: @[simp]
theorem projIcc_right : projIcc a b h b = ⟨b, right_mem_Icc.2 h⟩ 
goal: Set.projIcc a b h b = ⟨b, ⋯⟩

full_name: Set.projIci_eq_self
code: theorem projIci_eq_self : projIci a x = ⟨a, le_rfl⟩ ↔ x ≤ a 
goal: Set.projIci a x = ⟨a, ⋯⟩ ↔ x ≤ a

full_name: Set.projIic_eq_self
code: theorem projIic_eq_self : projIic b x = ⟨b, le_rfl⟩ ↔ b ≤ x 
goal: Set.projIic b x = ⟨b, ⋯⟩ ↔ b ≤ x

full_name: Set.projIcc_eq_left
code: theorem projIcc_eq_left (h : a < b) : projIcc a b h.le x = ⟨a, left_mem_Icc.mpr h.le⟩ ↔ x ≤ a 
goal: Set.projIcc a b ⋯ x = ⟨a, ⋯⟩ ↔ x ≤ a

full_name: Set.projIcc_eq_right
code: theorem projIcc_eq_right (h : a < b) : projIcc a b h.le x = ⟨b, right_mem_Icc.2 h.le⟩ ↔ b ≤ x 
goal: Set.projIcc a b ⋯ x = ⟨b, ⋯⟩ ↔ b ≤ x

full_name: Set.projIci_of_mem
code: theorem projIci_of_mem (hx : x ∈ Ici a) : projIci a x = ⟨x, hx⟩ 
goal: Set.projIci a x = ⟨x, hx⟩

full_name: Set.projIic_of_mem
code: theorem projIic_of_mem (hx : x ∈ Iic b) : projIic b x = ⟨x, hx⟩ 
goal: Set.projIic b x = ⟨x, hx⟩

full_name: Set.projIcc_of_mem
code: theorem projIcc_of_mem (hx : x ∈ Icc a b) : projIcc a b h x = ⟨x, hx⟩ 
goal: Set.projIcc a b h x = ⟨x, hx⟩

full_name: Set.projIci_coe
code: @[simp]
theorem projIci_coe (x : Ici a) : projIci a x = x 
goal: Set.projIci a ↑x = x

full_name: Set.projIic_coe
code: @[simp]
theorem projIic_coe (x : Iic b) : projIic b x = x 
goal: Set.projIic b ↑x = x

full_name: Set.projIcc_val
code: @[simp]
theorem projIcc_val (x : Icc a b) : projIcc a b h x = x 
goal: Set.projIcc a b h ↑x = x

full_name: Set.projIci_surjOn
code: theorem projIci_surjOn : SurjOn (projIci a) (Ici a) univ 
goal: Set.SurjOn (Set.projIci a) (Set.Ici a) Set.univ

full_name: Set.projIic_surjOn
code: theorem projIic_surjOn : SurjOn (projIic b) (Iic b) univ 
goal: Set.SurjOn (Set.projIic b) (Set.Iic b) Set.univ

full_name: Set.projIcc_surjOn
code: theorem projIcc_surjOn : SurjOn (projIcc a b h) (Icc a b) univ 
goal: Set.SurjOn (Set.projIcc a b h) (Set.Icc a b) Set.univ

full_name: Set.projIci_surjective
code: theorem projIci_surjective : Surjective (projIci a) 
goal: Function.Surjective (Set.projIci a)

full_name: Set.projIic_surjective
code: theorem projIic_surjective : Surjective (projIic b) 
goal: Function.Surjective (Set.projIic b)

full_name: Set.projIcc_surjective
code: theorem projIcc_surjective : Surjective (projIcc a b h) 
goal: Function.Surjective (Set.projIcc a b h)

full_name: Set.range_projIci
code: @[simp]
theorem range_projIci : range (projIci a) = univ 
goal: Set.range (Set.projIci a) = Set.univ

full_name: Set.range_projIic
code: @[simp]
theorem range_projIic : range (projIic a) = univ 
goal: Set.range (Set.projIic a) = Set.univ

full_name: Set.range_projIcc
code: @[simp]
theorem range_projIcc : range (projIcc a b h) = univ 
goal: Set.range (Set.projIcc a b h) = Set.univ

full_name: Set.monotone_projIci
code: theorem monotone_projIci : Monotone (projIci a) 
goal: Monotone (Set.projIci a)

full_name: Set.monotone_projIic
code: theorem monotone_projIic : Monotone (projIic a) 
goal: Monotone (Set.projIic a)

full_name: Set.monotone_projIcc
code: theorem monotone_projIcc : Monotone (projIcc a b h) 
goal: Monotone (Set.projIcc a b h)

full_name: Set.strictMonoOn_projIci
code: theorem strictMonoOn_projIci : StrictMonoOn (projIci a) (Ici a) 
goal: StrictMonoOn (Set.projIci a) (Set.Ici a)

full_name: Set.strictMonoOn_projIic
code: theorem strictMonoOn_projIic : StrictMonoOn (projIic b) (Iic b) 
goal: StrictMonoOn (Set.projIic b) (Set.Iic b)

full_name: Set.strictMonoOn_projIcc
code: theorem strictMonoOn_projIcc : StrictMonoOn (projIcc a b h) (Icc a b) 
goal: StrictMonoOn (Set.projIcc a b h) (Set.Icc a b)

full_name: Set.IciExtend
code: /-- Extend a function `[a, ∞) → β` to a map `α → β`. -/
def IciExtend (f : Ici a → β) : α → β 
goal: α → β

full_name: Set.IicExtend
code: /-- Extend a function `(-∞, b] → β` to a map `α → β`. -/
def IicExtend (f : Iic b → β) : α → β 
goal: α → β

full_name: Set.IccExtend
code: /-- Extend a function `[a, b] → β` to a map `α → β`. -/
def IccExtend {a b : α} (h : a ≤ b) (f : Icc a b → β) : α → β 
goal: α → β

full_name: Set.IciExtend_apply
code: theorem IciExtend_apply (f : Ici a → β) (x : α) : IciExtend f x = f ⟨max a x, le_max_left _ _⟩ 
goal: Set.IciExtend f x = f ⟨max a x, ⋯⟩

full_name: Set.IicExtend_apply
code: theorem IicExtend_apply (f : Iic b → β) (x : α) : IicExtend f x = f ⟨min b x, min_le_left _ _⟩ 
goal: Set.IicExtend f x = f ⟨min b x, ⋯⟩

full_name: Set.IccExtend_apply
code: theorem IccExtend_apply (h : a ≤ b) (f : Icc a b → β) (x : α) :
    IccExtend h f x = f ⟨max a (min b x), le_max_left _ _, max_le h (min_le_left _ _)⟩ 
goal: Set.IccExtend h f x = f ⟨max a (min b x), ⋯⟩

full_name: Set.range_IciExtend
code: @[simp]
theorem range_IciExtend (f : Ici a → β) : range (IciExtend f) = range f 
goal: Set.range (Set.IciExtend f) = Set.range f

full_name: Set.range_IicExtend
code: @[simp]
theorem range_IicExtend (f : Iic b → β) : range (IicExtend f) = range f 
goal: Set.range (Set.IicExtend f) = Set.range f

full_name: Set.IccExtend_range
code: @[simp]
theorem IccExtend_range (f : Icc a b → β) : range (IccExtend h f) = range f 
goal: Set.range (Set.IccExtend h f) = Set.range f

full_name: Set.IciExtend_of_le
code: theorem IciExtend_of_le (f : Ici a → β) (hx : x ≤ a) : IciExtend f x = f ⟨a, le_rfl⟩ 
goal: Set.IciExtend f x = f ⟨a, ⋯⟩

full_name: Set.IicExtend_of_le
code: theorem IicExtend_of_le (f : Iic b → β) (hx : b ≤ x) : IicExtend f x = f ⟨b, le_rfl⟩ 
goal: Set.IicExtend f x = f ⟨b, ⋯⟩

full_name: Set.IccExtend_of_le_left
code: theorem IccExtend_of_le_left (f : Icc a b → β) (hx : x ≤ a) :
    IccExtend h f x = f ⟨a, left_mem_Icc.2 h⟩ 
goal: Set.IccExtend h f x = f ⟨a, ⋯⟩

full_name: Set.IccExtend_of_right_le
code: theorem IccExtend_of_right_le (f : Icc a b → β) (hx : b ≤ x) :
    IccExtend h f x = f ⟨b, right_mem_Icc.2 h⟩ 
goal: Set.IccExtend h f x = f ⟨b, ⋯⟩

full_name: Set.IciExtend_self
code: @[simp]
theorem IciExtend_self (f : Ici a → β) : IciExtend f a = f ⟨a, le_rfl⟩ 
goal: Set.IciExtend f a = f ⟨a, ⋯⟩

full_name: Set.IicExtend_self
code: @[simp]
theorem IicExtend_self (f : Iic b → β) : IicExtend f b = f ⟨b, le_rfl⟩ 
goal: Set.IicExtend f b = f ⟨b, ⋯⟩

full_name: Set.IccExtend_left
code: @[simp]
theorem IccExtend_left (f : Icc a b → β) : IccExtend h f a = f ⟨a, left_mem_Icc.2 h⟩ 
goal: Set.IccExtend h f a = f ⟨a, ⋯⟩

full_name: Set.IccExtend_right
code: @[simp]
theorem IccExtend_right (f : Icc a b → β) : IccExtend h f b = f ⟨b, right_mem_Icc.2 h⟩ 
goal: Set.IccExtend h f b = f ⟨b, ⋯⟩

full_name: Set.IciExtend_of_mem
code: theorem IciExtend_of_mem (f : Ici a → β) (hx : x ∈ Ici a) : IciExtend f x = f ⟨x, hx⟩ 
goal: Set.IciExtend f x = f ⟨x, hx⟩

full_name: Set.IicExtend_of_mem
code: theorem IicExtend_of_mem (f : Iic b → β) (hx : x ∈ Iic b) : IicExtend f x = f ⟨x, hx⟩ 
goal: Set.IicExtend f x = f ⟨x, hx⟩

full_name: Set.IccExtend_of_mem
code: theorem IccExtend_of_mem (f : Icc a b → β) (hx : x ∈ Icc a b) : IccExtend h f x = f ⟨x, hx⟩ 
goal: Set.IccExtend h f x = f ⟨x, hx⟩

full_name: Set.IciExtend_coe
code: @[simp]
theorem IciExtend_coe (f : Ici a → β) (x : Ici a) : IciExtend f x = f x 
goal: Set.IciExtend f ↑x = f x

full_name: Set.IicExtend_coe
code: @[simp]
theorem IicExtend_coe (f : Iic b → β) (x : Iic b) : IicExtend f x = f x 
goal: Set.IicExtend f ↑x = f x

full_name: Set.IccExtend_val
code: @[simp]
theorem IccExtend_val (f : Icc a b → β) (x : Icc a b) : IccExtend h f x = f x 
goal: Set.IccExtend h f ↑x = f x

full_name: Set.IccExtend_eq_self
code: /-- If `f : α → β` is a constant both on $(-∞, a]$ and on $[b, +∞)$, then the extension of this
function from $[a, b]$ to the whole line is equal to the original function. -/
theorem IccExtend_eq_self (f : α → β) (ha : ∀ x < a, f x = f a) (hb : ∀ x, b < x → f x = f b) :
    IccExtend h (f ∘ (↑)) = f 
goal: Set.IccExtend h (f ∘ Subtype.val) = f

full_name: Monotone.IciExtend
code: protected theorem Monotone.IciExtend {f : Ici a → β} (hf : Monotone f) : Monotone (IciExtend f) 
goal: Monotone (Set.IciExtend f)

full_name: Monotone.IicExtend
code: protected theorem Monotone.IicExtend {f : Iic b → β} (hf : Monotone f) : Monotone (IicExtend f) 
goal: Monotone (Set.IicExtend f)

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

full_name: StrictMono.strictMonoOn_IciExtend
code: theorem StrictMono.strictMonoOn_IciExtend {f : Ici a → β} (hf : StrictMono f) :
    StrictMonoOn (IciExtend f) (Ici a) 
goal: StrictMonoOn (Set.IciExtend f) (Set.Ici a)

full_name: StrictMono.strictMonoOn_IicExtend
code: theorem StrictMono.strictMonoOn_IicExtend {f : Iic b → β} (hf : StrictMono f) :
    StrictMonoOn (IicExtend f) (Iic b) 
goal: StrictMonoOn (Set.IicExtend f) (Set.Iic b)

full_name: StrictMono.strictMonoOn_IccExtend
code: theorem StrictMono.strictMonoOn_IccExtend (hf : StrictMono f) :
    StrictMonoOn (IccExtend h f) (Icc a b) 
goal: StrictMonoOn (Set.IccExtend h f) (Set.Icc a b)

full_name: Set.OrdConnected.IciExtend
code: protected theorem Set.OrdConnected.IciExtend {s : Set (Ici a)} (hs : s.OrdConnected) :
    {x | IciExtend (· ∈ s) x}.OrdConnected 
goal: {x | Set.IciExtend (fun x => x ∈ s) x}.OrdConnected

full_name: Set.OrdConnected.IicExtend
code: protected theorem Set.OrdConnected.IicExtend {s : Set (Iic b)} (hs : s.OrdConnected) :
    {x | IicExtend (· ∈ s) x}.OrdConnected 
goal: {x | Set.IicExtend (fun x => x ∈ s) x}.OrdConnected

full_name: Set.OrdConnected.restrict
code: protected theorem Set.OrdConnected.restrict (hs : s.OrdConnected) :
    {x | restrict t (· ∈ s) x}.OrdConnected 
goal: {x | t.restrict (fun x => x ∈ s) x}.OrdConnected