File: Mathlib/Data/Set/Pointwise/Interval.lean

full_name: Set.Icc_mul_Icc_subset'
code: @[to_additive Icc_add_Icc_subset]
theorem Icc_mul_Icc_subset' (a b c d : α) : Icc a b * Icc c d ⊆ Icc (a * c) (b * d) 
goal: Set.Icc a b * Set.Icc c d ⊆ Set.Icc (a * c) (b * d)

full_name: Set.Icc_add_Icc_subset
code: @[to_additive Icc_add_Icc_subset]
theorem Icc_mul_Icc_subset' (a b c d : α) : Icc a b * Icc c d ⊆ Icc (a * c) (b * d) 
goal: Set.Icc a b + Set.Icc c d ⊆ Set.Icc (a + c) (b + d)

full_name: Set.Iic_mul_Iic_subset'
code: @[to_additive Iic_add_Iic_subset]
theorem Iic_mul_Iic_subset' (a b : α) : Iic a * Iic b ⊆ Iic (a * b) 
goal: Set.Iic a * Set.Iic b ⊆ Set.Iic (a * b)

full_name: Set.Iic_add_Iic_subset
code: @[to_additive Iic_add_Iic_subset]
theorem Iic_mul_Iic_subset' (a b : α) : Iic a * Iic b ⊆ Iic (a * b) 
goal: Set.Iic a + Set.Iic b ⊆ Set.Iic (a + b)

full_name: Set.Ici_mul_Ici_subset'
code: @[to_additive Ici_add_Ici_subset]
theorem Ici_mul_Ici_subset' (a b : α) : Ici a * Ici b ⊆ Ici (a * b) 
goal: Set.Ici a * Set.Ici b ⊆ Set.Ici (a * b)

full_name: Set.Ici_add_Ici_subset
code: @[to_additive Ici_add_Ici_subset]
theorem Ici_mul_Ici_subset' (a b : α) : Ici a * Ici b ⊆ Ici (a * b) 
goal: Set.Ici a + Set.Ici b ⊆ Set.Ici (a + b)

full_name: Set.Icc_mul_Ico_subset'
code: @[to_additive Icc_add_Ico_subset]
theorem Icc_mul_Ico_subset' (a b c d : α) : Icc a b * Ico c d ⊆ Ico (a * c) (b * d) 
goal: Set.Icc a b * Set.Ico c d ⊆ Set.Ico (a * c) (b * d)

full_name: Set.Icc_add_Ico_subset
code: @[to_additive Icc_add_Ico_subset]
theorem Icc_mul_Ico_subset' (a b c d : α) : Icc a b * Ico c d ⊆ Ico (a * c) (b * d) 
goal: Set.Icc a b + Set.Ico c d ⊆ Set.Ico (a + c) (b + d)

full_name: Set.Ico_add_Icc_subset
code: @[to_additive Ico_add_Icc_subset]
theorem Ico_mul_Icc_subset' (a b c d : α) : Ico a b * Icc c d ⊆ Ico (a * c) (b * d) 
goal: Set.Ico a b + Set.Icc c d ⊆ Set.Ico (a + c) (b + d)

full_name: Set.Ico_mul_Icc_subset'
code: @[to_additive Ico_add_Icc_subset]
theorem Ico_mul_Icc_subset' (a b c d : α) : Ico a b * Icc c d ⊆ Ico (a * c) (b * d) 
goal: Set.Ico a b * Set.Icc c d ⊆ Set.Ico (a * c) (b * d)

full_name: Set.Ioc_add_Ico_subset
code: @[to_additive Ioc_add_Ico_subset]
theorem Ioc_mul_Ico_subset' (a b c d : α) : Ioc a b * Ico c d ⊆ Ioo (a * c) (b * d) 
goal: Set.Ioc a b + Set.Ico c d ⊆ Set.Ioo (a + c) (b + d)

full_name: Set.Ioc_mul_Ico_subset'
code: @[to_additive Ioc_add_Ico_subset]
theorem Ioc_mul_Ico_subset' (a b c d : α) : Ioc a b * Ico c d ⊆ Ioo (a * c) (b * d) 
goal: Set.Ioc a b * Set.Ico c d ⊆ Set.Ioo (a * c) (b * d)

full_name: Set.Ico_mul_Ioc_subset'
code: @[to_additive Ico_add_Ioc_subset]
theorem Ico_mul_Ioc_subset' (a b c d : α) : Ico a b * Ioc c d ⊆ Ioo (a * c) (b * d) 
goal: Set.Ico a b * Set.Ioc c d ⊆ Set.Ioo (a * c) (b * d)

full_name: Set.Ico_add_Ioc_subset
code: @[to_additive Ico_add_Ioc_subset]
theorem Ico_mul_Ioc_subset' (a b c d : α) : Ico a b * Ioc c d ⊆ Ioo (a * c) (b * d) 
goal: Set.Ico a b + Set.Ioc c d ⊆ Set.Ioo (a + c) (b + d)

full_name: Set.Iic_mul_Iio_subset'
code: @[to_additive Iic_add_Iio_subset]
theorem Iic_mul_Iio_subset' (a b : α) : Iic a * Iio b ⊆ Iio (a * b) 
goal: Set.Iic a * Set.Iio b ⊆ Set.Iio (a * b)

full_name: Set.Iic_add_Iio_subset
code: @[to_additive Iic_add_Iio_subset]
theorem Iic_mul_Iio_subset' (a b : α) : Iic a * Iio b ⊆ Iio (a * b) 
goal: Set.Iic a + Set.Iio b ⊆ Set.Iio (a + b)

full_name: Set.Iio_add_Iic_subset
code: @[to_additive Iio_add_Iic_subset]
theorem Iio_mul_Iic_subset' (a b : α) : Iio a * Iic b ⊆ Iio (a * b) 
goal: Set.Iio a + Set.Iic b ⊆ Set.Iio (a + b)

full_name: Set.Iio_mul_Iic_subset'
code: @[to_additive Iio_add_Iic_subset]
theorem Iio_mul_Iic_subset' (a b : α) : Iio a * Iic b ⊆ Iio (a * b) 
goal: Set.Iio a * Set.Iic b ⊆ Set.Iio (a * b)

full_name: Set.Ioi_add_Ici_subset
code: @[to_additive Ioi_add_Ici_subset]
theorem Ioi_mul_Ici_subset' (a b : α) : Ioi a * Ici b ⊆ Ioi (a * b) 
goal: Set.Ioi a + Set.Ici b ⊆ Set.Ioi (a + b)

full_name: Set.Ioi_mul_Ici_subset'
code: @[to_additive Ioi_add_Ici_subset]
theorem Ioi_mul_Ici_subset' (a b : α) : Ioi a * Ici b ⊆ Ioi (a * b) 
goal: Set.Ioi a * Set.Ici b ⊆ Set.Ioi (a * b)

full_name: Set.Ici_mul_Ioi_subset'
code: @[to_additive Ici_add_Ioi_subset]
theorem Ici_mul_Ioi_subset' (a b : α) : Ici a * Ioi b ⊆ Ioi (a * b) 
goal: Set.Ici a * Set.Ioi b ⊆ Set.Ioi (a * b)

full_name: Set.Ici_add_Ioi_subset
code: @[to_additive Ici_add_Ioi_subset]
theorem Ici_mul_Ioi_subset' (a b : α) : Ici a * Ioi b ⊆ Ioi (a * b) 
goal: Set.Ici a + Set.Ioi b ⊆ Set.Ioi (a + b)

full_name: Set.preimage_const_add_Ici
code: @[simp]
theorem preimage_const_add_Ici : (fun x => a + x) ⁻¹' Ici b = Ici (b - a) 
goal: (fun x => a + x) ⁻¹' Set.Ici b = Set.Ici (b - a)

full_name: Set.preimage_const_add_Ioi
code: @[simp]
theorem preimage_const_add_Ioi : (fun x => a + x) ⁻¹' Ioi b = Ioi (b - a) 
goal: (fun x => a + x) ⁻¹' Set.Ioi b = Set.Ioi (b - a)

full_name: Set.preimage_const_add_Iic
code: @[simp]
theorem preimage_const_add_Iic : (fun x => a + x) ⁻¹' Iic b = Iic (b - a) 
goal: (fun x => a + x) ⁻¹' Set.Iic b = Set.Iic (b - a)

full_name: Set.preimage_const_add_Iio
code: @[simp]
theorem preimage_const_add_Iio : (fun x => a + x) ⁻¹' Iio b = Iio (b - a) 
goal: (fun x => a + x) ⁻¹' Set.Iio b = Set.Iio (b - a)

full_name: Set.preimage_const_add_Icc
code: @[simp]
theorem preimage_const_add_Icc : (fun x => a + x) ⁻¹' Icc b c = Icc (b - a) (c - a) 
goal: (fun x => a + x) ⁻¹' Set.Icc b c = Set.Icc (b - a) (c - a)

full_name: Set.preimage_const_add_Ico
code: @[simp]
theorem preimage_const_add_Ico : (fun x => a + x) ⁻¹' Ico b c = Ico (b - a) (c - a) 
goal: (fun x => a + x) ⁻¹' Set.Ico b c = Set.Ico (b - a) (c - a)

full_name: Set.preimage_const_add_Ioc
code: @[simp]
theorem preimage_const_add_Ioc : (fun x => a + x) ⁻¹' Ioc b c = Ioc (b - a) (c - a) 
goal: (fun x => a + x) ⁻¹' Set.Ioc b c = Set.Ioc (b - a) (c - a)

full_name: Set.preimage_const_add_Ioo
code: @[simp]
theorem preimage_const_add_Ioo : (fun x => a + x) ⁻¹' Ioo b c = Ioo (b - a) (c - a) 
goal: (fun x => a + x) ⁻¹' Set.Ioo b c = Set.Ioo (b - a) (c - a)

full_name: Set.preimage_add_const_Ici
code: @[simp]
theorem preimage_add_const_Ici : (fun x => x + a) ⁻¹' Ici b = Ici (b - a) 
goal: (fun x => x + a) ⁻¹' Set.Ici b = Set.Ici (b - a)

full_name: Set.preimage_add_const_Ioi
code: @[simp]
theorem preimage_add_const_Ioi : (fun x => x + a) ⁻¹' Ioi b = Ioi (b - a) 
goal: (fun x => x + a) ⁻¹' Set.Ioi b = Set.Ioi (b - a)

full_name: Set.preimage_add_const_Iic
code: @[simp]
theorem preimage_add_const_Iic : (fun x => x + a) ⁻¹' Iic b = Iic (b - a) 
goal: (fun x => x + a) ⁻¹' Set.Iic b = Set.Iic (b - a)

full_name: Set.preimage_add_const_Iio
code: @[simp]
theorem preimage_add_const_Iio : (fun x => x + a) ⁻¹' Iio b = Iio (b - a) 
goal: (fun x => x + a) ⁻¹' Set.Iio b = Set.Iio (b - a)

full_name: Set.preimage_add_const_Icc
code: @[simp]
theorem preimage_add_const_Icc : (fun x => x + a) ⁻¹' Icc b c = Icc (b - a) (c - a) 
goal: (fun x => x + a) ⁻¹' Set.Icc b c = Set.Icc (b - a) (c - a)

full_name: Set.preimage_add_const_Ico
code: @[simp]
theorem preimage_add_const_Ico : (fun x => x + a) ⁻¹' Ico b c = Ico (b - a) (c - a) 
goal: (fun x => x + a) ⁻¹' Set.Ico b c = Set.Ico (b - a) (c - a)

full_name: Set.preimage_add_const_Ioc
code: @[simp]
theorem preimage_add_const_Ioc : (fun x => x + a) ⁻¹' Ioc b c = Ioc (b - a) (c - a) 
goal: (fun x => x + a) ⁻¹' Set.Ioc b c = Set.Ioc (b - a) (c - a)

full_name: Set.preimage_add_const_Ioo
code: @[simp]
theorem preimage_add_const_Ioo : (fun x => x + a) ⁻¹' Ioo b c = Ioo (b - a) (c - a) 
goal: (fun x => x + a) ⁻¹' Set.Ioo b c = Set.Ioo (b - a) (c - a)

full_name: Set.preimage_neg_Ici
code: @[simp]
theorem preimage_neg_Ici : -Ici a = Iic (-a) 
goal: -Set.Ici a = Set.Iic (-a)

full_name: Set.preimage_neg_Iic
code: @[simp]
theorem preimage_neg_Iic : -Iic a = Ici (-a) 
goal: -Set.Iic a = Set.Ici (-a)

full_name: Set.preimage_neg_Ioi
code: @[simp]
theorem preimage_neg_Ioi : -Ioi a = Iio (-a) 
goal: -Set.Ioi a = Set.Iio (-a)

full_name: Set.preimage_neg_Iio
code: @[simp]
theorem preimage_neg_Iio : -Iio a = Ioi (-a) 
goal: -Set.Iio a = Set.Ioi (-a)

full_name: Set.preimage_neg_Icc
code: @[simp]
theorem preimage_neg_Icc : -Icc a b = Icc (-b) (-a) 
goal: -Set.Icc a b = Set.Icc (-b) (-a)

full_name: Set.preimage_neg_Ico
code: @[simp]
theorem preimage_neg_Ico : -Ico a b = Ioc (-b) (-a) 
goal: -Set.Ico a b = Set.Ioc (-b) (-a)

full_name: Set.preimage_neg_Ioc
code: @[simp]
theorem preimage_neg_Ioc : -Ioc a b = Ico (-b) (-a) 
goal: -Set.Ioc a b = Set.Ico (-b) (-a)

full_name: Set.preimage_neg_Ioo
code: @[simp]
theorem preimage_neg_Ioo : -Ioo a b = Ioo (-b) (-a) 
goal: -Set.Ioo a b = Set.Ioo (-b) (-a)

full_name: Set.preimage_sub_const_Ici
code: @[simp]
theorem preimage_sub_const_Ici : (fun x => x - a) ⁻¹' Ici b = Ici (b + a) 
goal: (fun x => x - a) ⁻¹' Set.Ici b = Set.Ici (b + a)

full_name: Set.preimage_sub_const_Ioi
code: @[simp]
theorem preimage_sub_const_Ioi : (fun x => x - a) ⁻¹' Ioi b = Ioi (b + a) 
goal: (fun x => x - a) ⁻¹' Set.Ioi b = Set.Ioi (b + a)

full_name: Set.preimage_sub_const_Iic
code: @[simp]
theorem preimage_sub_const_Iic : (fun x => x - a) ⁻¹' Iic b = Iic (b + a) 
goal: (fun x => x - a) ⁻¹' Set.Iic b = Set.Iic (b + a)

full_name: Set.preimage_sub_const_Iio
code: @[simp]
theorem preimage_sub_const_Iio : (fun x => x - a) ⁻¹' Iio b = Iio (b + a) 
goal: (fun x => x - a) ⁻¹' Set.Iio b = Set.Iio (b + a)

full_name: Set.preimage_sub_const_Icc
code: @[simp]
theorem preimage_sub_const_Icc : (fun x => x - a) ⁻¹' Icc b c = Icc (b + a) (c + a) 
goal: (fun x => x - a) ⁻¹' Set.Icc b c = Set.Icc (b + a) (c + a)

full_name: Set.preimage_sub_const_Ico
code: @[simp]
theorem preimage_sub_const_Ico : (fun x => x - a) ⁻¹' Ico b c = Ico (b + a) (c + a) 
goal: (fun x => x - a) ⁻¹' Set.Ico b c = Set.Ico (b + a) (c + a)

full_name: Set.preimage_sub_const_Ioc
code: @[simp]
theorem preimage_sub_const_Ioc : (fun x => x - a) ⁻¹' Ioc b c = Ioc (b + a) (c + a) 
goal: (fun x => x - a) ⁻¹' Set.Ioc b c = Set.Ioc (b + a) (c + a)

full_name: Set.preimage_sub_const_Ioo
code: @[simp]
theorem preimage_sub_const_Ioo : (fun x => x - a) ⁻¹' Ioo b c = Ioo (b + a) (c + a) 
goal: (fun x => x - a) ⁻¹' Set.Ioo b c = Set.Ioo (b + a) (c + a)

full_name: Set.preimage_const_sub_Ici
code: @[simp]
theorem preimage_const_sub_Ici : (fun x => a - x) ⁻¹' Ici b = Iic (a - b) 
goal: (fun x => a - x) ⁻¹' Set.Ici b = Set.Iic (a - b)

full_name: Set.preimage_const_sub_Iic
code: @[simp]
theorem preimage_const_sub_Iic : (fun x => a - x) ⁻¹' Iic b = Ici (a - b) 
goal: (fun x => a - x) ⁻¹' Set.Iic b = Set.Ici (a - b)

full_name: Set.preimage_const_sub_Ioi
code: @[simp]
theorem preimage_const_sub_Ioi : (fun x => a - x) ⁻¹' Ioi b = Iio (a - b) 
goal: (fun x => a - x) ⁻¹' Set.Ioi b = Set.Iio (a - b)

full_name: Set.preimage_const_sub_Iio
code: @[simp]
theorem preimage_const_sub_Iio : (fun x => a - x) ⁻¹' Iio b = Ioi (a - b) 
goal: (fun x => a - x) ⁻¹' Set.Iio b = Set.Ioi (a - b)

full_name: Set.preimage_const_sub_Icc
code: @[simp]
theorem preimage_const_sub_Icc : (fun x => a - x) ⁻¹' Icc b c = Icc (a - c) (a - b) 
goal: (fun x => a - x) ⁻¹' Set.Icc b c = Set.Icc (a - c) (a - b)

full_name: Set.preimage_const_sub_Ico
code: @[simp]
theorem preimage_const_sub_Ico : (fun x => a - x) ⁻¹' Ico b c = Ioc (a - c) (a - b) 
goal: (fun x => a - x) ⁻¹' Set.Ico b c = Set.Ioc (a - c) (a - b)

full_name: Set.preimage_const_sub_Ioc
code: @[simp]
theorem preimage_const_sub_Ioc : (fun x => a - x) ⁻¹' Ioc b c = Ico (a - c) (a - b) 
goal: (fun x => a - x) ⁻¹' Set.Ioc b c = Set.Ico (a - c) (a - b)

full_name: Set.preimage_const_sub_Ioo
code: @[simp]
theorem preimage_const_sub_Ioo : (fun x => a - x) ⁻¹' Ioo b c = Ioo (a - c) (a - b) 
goal: (fun x => a - x) ⁻¹' Set.Ioo b c = Set.Ioo (a - c) (a - b)

full_name: Set.image_const_add_Iic
code: theorem image_const_add_Iic : (fun x => a + x) '' Iic b = Iic (a + b) 
goal: (fun x => a + x) '' Set.Iic b = Set.Iic (a + b)

full_name: Set.image_const_add_Iio
code: theorem image_const_add_Iio : (fun x => a + x) '' Iio b = Iio (a + b) 
goal: (fun x => a + x) '' Set.Iio b = Set.Iio (a + b)

full_name: Set.image_add_const_Iic
code: theorem image_add_const_Iic : (fun x => x + a) '' Iic b = Iic (b + a) 
goal: (fun x => x + a) '' Set.Iic b = Set.Iic (b + a)

full_name: Set.image_add_const_Iio
code: theorem image_add_const_Iio : (fun x => x + a) '' Iio b = Iio (b + a) 
goal: (fun x => x + a) '' Set.Iio b = Set.Iio (b + a)

full_name: Set.image_neg_Ici
code: theorem image_neg_Ici : Neg.neg '' Ici a = Iic (-a) 
goal: Neg.neg '' Set.Ici a = Set.Iic (-a)

full_name: Set.image_neg_Iic
code: theorem image_neg_Iic : Neg.neg '' Iic a = Ici (-a) 
goal: Neg.neg '' Set.Iic a = Set.Ici (-a)

full_name: Set.image_neg_Ioi
code: theorem image_neg_Ioi : Neg.neg '' Ioi a = Iio (-a) 
goal: Neg.neg '' Set.Ioi a = Set.Iio (-a)

full_name: Set.image_neg_Iio
code: theorem image_neg_Iio : Neg.neg '' Iio a = Ioi (-a) 
goal: Neg.neg '' Set.Iio a = Set.Ioi (-a)

full_name: Set.image_neg_Icc
code: theorem image_neg_Icc : Neg.neg '' Icc a b = Icc (-b) (-a) 
goal: Neg.neg '' Set.Icc a b = Set.Icc (-b) (-a)

full_name: Set.image_neg_Ico
code: theorem image_neg_Ico : Neg.neg '' Ico a b = Ioc (-b) (-a) 
goal: Neg.neg '' Set.Ico a b = Set.Ioc (-b) (-a)

full_name: Set.image_neg_Ioc
code: theorem image_neg_Ioc : Neg.neg '' Ioc a b = Ico (-b) (-a) 
goal: Neg.neg '' Set.Ioc a b = Set.Ico (-b) (-a)

full_name: Set.image_neg_Ioo
code: theorem image_neg_Ioo : Neg.neg '' Ioo a b = Ioo (-b) (-a) 
goal: Neg.neg '' Set.Ioo a b = Set.Ioo (-b) (-a)

full_name: Set.image_const_sub_Ici
code: @[simp]
theorem image_const_sub_Ici : (fun x => a - x) '' Ici b = Iic (a - b) 
goal: (fun x => a - x) '' Set.Ici b = Set.Iic (a - b)

full_name: Set.image_const_sub_Iic
code: @[simp]
theorem image_const_sub_Iic : (fun x => a - x) '' Iic b = Ici (a - b) 
goal: (fun x => a - x) '' Set.Iic b = Set.Ici (a - b)

full_name: Set.image_const_sub_Ioi
code: @[simp]
theorem image_const_sub_Ioi : (fun x => a - x) '' Ioi b = Iio (a - b) 
goal: (fun x => a - x) '' Set.Ioi b = Set.Iio (a - b)

full_name: Set.image_const_sub_Iio
code: @[simp]
theorem image_const_sub_Iio : (fun x => a - x) '' Iio b = Ioi (a - b) 
goal: (fun x => a - x) '' Set.Iio b = Set.Ioi (a - b)

full_name: Set.image_const_sub_Icc
code: @[simp]
theorem image_const_sub_Icc : (fun x => a - x) '' Icc b c = Icc (a - c) (a - b) 
goal: (fun x => a - x) '' Set.Icc b c = Set.Icc (a - c) (a - b)

full_name: Set.image_const_sub_Ico
code: @[simp]
theorem image_const_sub_Ico : (fun x => a - x) '' Ico b c = Ioc (a - c) (a - b) 
goal: (fun x => a - x) '' Set.Ico b c = Set.Ioc (a - c) (a - b)

full_name: Set.image_const_sub_Ioc
code: @[simp]
theorem image_const_sub_Ioc : (fun x => a - x) '' Ioc b c = Ico (a - c) (a - b) 
goal: (fun x => a - x) '' Set.Ioc b c = Set.Ico (a - c) (a - b)

full_name: Set.image_const_sub_Ioo
code: @[simp]
theorem image_const_sub_Ioo : (fun x => a - x) '' Ioo b c = Ioo (a - c) (a - b) 
goal: (fun x => a - x) '' Set.Ioo b c = Set.Ioo (a - c) (a - b)

full_name: Set.image_sub_const_Ici
code: @[simp]
theorem image_sub_const_Ici : (fun x => x - a) '' Ici b = Ici (b - a) 
goal: (fun x => x - a) '' Set.Ici b = Set.Ici (b - a)

full_name: Set.image_sub_const_Iic
code: @[simp]
theorem image_sub_const_Iic : (fun x => x - a) '' Iic b = Iic (b - a) 
goal: (fun x => x - a) '' Set.Iic b = Set.Iic (b - a)

full_name: Set.image_sub_const_Ioi
code: @[simp]
theorem image_sub_const_Ioi : (fun x => x - a) '' Ioi b = Ioi (b - a) 
goal: (fun x => x - a) '' Set.Ioi b = Set.Ioi (b - a)

full_name: Set.image_sub_const_Iio
code: @[simp]
theorem image_sub_const_Iio : (fun x => x - a) '' Iio b = Iio (b - a) 
goal: (fun x => x - a) '' Set.Iio b = Set.Iio (b - a)

full_name: Set.image_sub_const_Icc
code: @[simp]
theorem image_sub_const_Icc : (fun x => x - a) '' Icc b c = Icc (b - a) (c - a) 
goal: (fun x => x - a) '' Set.Icc b c = Set.Icc (b - a) (c - a)

full_name: Set.image_sub_const_Ico
code: @[simp]
theorem image_sub_const_Ico : (fun x => x - a) '' Ico b c = Ico (b - a) (c - a) 
goal: (fun x => x - a) '' Set.Ico b c = Set.Ico (b - a) (c - a)

full_name: Set.image_sub_const_Ioc
code: @[simp]
theorem image_sub_const_Ioc : (fun x => x - a) '' Ioc b c = Ioc (b - a) (c - a) 
goal: (fun x => x - a) '' Set.Ioc b c = Set.Ioc (b - a) (c - a)

full_name: Set.image_sub_const_Ioo
code: @[simp]
theorem image_sub_const_Ioo : (fun x => x - a) '' Ioo b c = Ioo (b - a) (c - a) 
goal: (fun x => x - a) '' Set.Ioo b c = Set.Ioo (b - a) (c - a)

full_name: Set.Iic_add_bij
code: theorem Iic_add_bij : BijOn (· + a) (Iic b) (Iic (b + a)) 
goal: Set.BijOn (fun x => x + a) (Set.Iic b) (Set.Iic (b + a))

full_name: Set.Iio_add_bij
code: theorem Iio_add_bij : BijOn (· + a) (Iio b) (Iio (b + a)) 
goal: Set.BijOn (fun x => x + a) (Set.Iio b) (Set.Iio (b + a))

full_name: Set.preimage_const_add_uIcc
code: @[simp]
theorem preimage_const_add_uIcc : (fun x => a + x) ⁻¹' [[b, c]] = [[b - a, c - a]] 
goal: (fun x => a + x) ⁻¹' [[b, c]] = [[b - a, c - a]]

full_name: Set.preimage_add_const_uIcc
code: @[simp]
theorem preimage_add_const_uIcc : (fun x => x + a) ⁻¹' [[b, c]] = [[b - a, c - a]] 
goal: (fun x => x + a) ⁻¹' [[b, c]] = [[b - a, c - a]]

full_name: Set.preimage_neg_uIcc
code: @[simp]
theorem preimage_neg_uIcc : @Neg.neg (Set α) Set.neg [[a, b]] = [[-a, -b]] 
goal: -[[a, b]] = [[-a, -b]]

full_name: Set.preimage_sub_const_uIcc
code: @[simp]
theorem preimage_sub_const_uIcc : (fun x => x - a) ⁻¹' [[b, c]] = [[b + a, c + a]] 
goal: (fun x => x - a) ⁻¹' [[b, c]] = [[b + a, c + a]]

full_name: Set.preimage_const_sub_uIcc
code: @[simp]
theorem preimage_const_sub_uIcc : (fun x => a - x) ⁻¹' [[b, c]] = [[a - b, a - c]] 
goal: (fun x => a - x) ⁻¹' [[b, c]] = [[a - b, a - c]]

full_name: Set.image_const_add_uIcc
code: theorem image_const_add_uIcc : (fun x => a + x) '' [[b, c]] = [[a + b, a + c]] 
goal: (fun x => a + x) '' [[b, c]] = [[a + b, a + c]]

full_name: Set.image_add_const_uIcc
code: theorem image_add_const_uIcc : (fun x => x + a) '' [[b, c]] = [[b + a, c + a]] 
goal: (fun x => x + a) '' [[b, c]] = [[b + a, c + a]]

full_name: Set.image_const_sub_uIcc
code: @[simp]
theorem image_const_sub_uIcc : (fun x => a - x) '' [[b, c]] = [[a - b, a - c]] 
goal: (fun x => a - x) '' [[b, c]] = [[a - b, a - c]]

full_name: Set.image_sub_const_uIcc
code: @[simp]
theorem image_sub_const_uIcc : (fun x => x - a) '' [[b, c]] = [[b - a, c - a]] 
goal: (fun x => x - a) '' [[b, c]] = [[b - a, c - a]]

full_name: Set.image_neg_uIcc
code: theorem image_neg_uIcc : Neg.neg '' [[a, b]] = [[-a, -b]] 
goal: Neg.neg '' [[a, b]] = [[-a, -b]]

full_name: Set.abs_sub_le_of_uIcc_subset_uIcc
code: /-- If `[c, d]` is a subinterval of `[a, b]`, then the distance between `c` and `d` is less than or
equal to that of `a` and `b` -/
theorem abs_sub_le_of_uIcc_subset_uIcc (h : [[c, d]] ⊆ [[a, b]]) : |d - c| ≤ |b - a| 
goal: |d - c| ≤ |b - a|

full_name: Set.abs_sub_left_of_mem_uIcc
code: /-- If `c ∈ [a, b]`, then the distance between `a` and `c` is less than or equal to
that of `a` and `b`  -/
theorem abs_sub_left_of_mem_uIcc (h : c ∈ [[a, b]]) : |c - a| ≤ |b - a| 
goal: |c - a| ≤ |b - a|

full_name: Set.abs_sub_right_of_mem_uIcc
code: /-- If `x ∈ [a, b]`, then the distance between `c` and `b` is less than or equal to
that of `a` and `b`  -/
theorem abs_sub_right_of_mem_uIcc (h : c ∈ [[a, b]]) : |b - c| ≤ |b - a| 
goal: |b - c| ≤ |b - a|

full_name: Set.preimage_mul_const_Iio
code: @[simp]
theorem preimage_mul_const_Iio (a : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Iio a = Iio (a / c) 
goal: (fun x => x * c) ⁻¹' Set.Iio a = Set.Iio (a / c)

full_name: Set.preimage_mul_const_Ioi
code: @[simp]
theorem preimage_mul_const_Ioi (a : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Ioi a = Ioi (a / c) 
goal: (fun x => x * c) ⁻¹' Set.Ioi a = Set.Ioi (a / c)

full_name: Set.preimage_mul_const_Iic
code: @[simp]
theorem preimage_mul_const_Iic (a : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Iic a = Iic (a / c) 
goal: (fun x => x * c) ⁻¹' Set.Iic a = Set.Iic (a / c)

full_name: Set.preimage_mul_const_Ici
code: @[simp]
theorem preimage_mul_const_Ici (a : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Ici a = Ici (a / c) 
goal: (fun x => x * c) ⁻¹' Set.Ici a = Set.Ici (a / c)

full_name: Set.preimage_mul_const_Ioo
code: @[simp]
theorem preimage_mul_const_Ioo (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Ioo a b = Ioo (a / c) (b / c) 
goal: (fun x => x * c) ⁻¹' Set.Ioo a b = Set.Ioo (a / c) (b / c)

full_name: Set.preimage_mul_const_Ioc
code: @[simp]
theorem preimage_mul_const_Ioc (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Ioc a b = Ioc (a / c) (b / c) 
goal: (fun x => x * c) ⁻¹' Set.Ioc a b = Set.Ioc (a / c) (b / c)

full_name: Set.preimage_mul_const_Ico
code: @[simp]
theorem preimage_mul_const_Ico (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Ico a b = Ico (a / c) (b / c) 
goal: (fun x => x * c) ⁻¹' Set.Ico a b = Set.Ico (a / c) (b / c)

full_name: Set.preimage_mul_const_Icc
code: @[simp]
theorem preimage_mul_const_Icc (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) ⁻¹' Icc a b = Icc (a / c) (b / c) 
goal: (fun x => x * c) ⁻¹' Set.Icc a b = Set.Icc (a / c) (b / c)

full_name: Set.preimage_mul_const_Iio_of_neg
code: @[simp]
theorem preimage_mul_const_Iio_of_neg (a : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Iio a = Ioi (a / c) 
goal: (fun x => x * c) ⁻¹' Set.Iio a = Set.Ioi (a / c)

full_name: Set.preimage_mul_const_Ioi_of_neg
code: @[simp]
theorem preimage_mul_const_Ioi_of_neg (a : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Ioi a = Iio (a / c) 
goal: (fun x => x * c) ⁻¹' Set.Ioi a = Set.Iio (a / c)

full_name: Set.preimage_mul_const_Iic_of_neg
code: @[simp]
theorem preimage_mul_const_Iic_of_neg (a : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Iic a = Ici (a / c) 
goal: (fun x => x * c) ⁻¹' Set.Iic a = Set.Ici (a / c)

full_name: Set.preimage_mul_const_Ici_of_neg
code: @[simp]
theorem preimage_mul_const_Ici_of_neg (a : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Ici a = Iic (a / c) 
goal: (fun x => x * c) ⁻¹' Set.Ici a = Set.Iic (a / c)

full_name: Set.preimage_mul_const_Ioo_of_neg
code: @[simp]
theorem preimage_mul_const_Ioo_of_neg (a b : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Ioo a b = Ioo (b / c) (a / c) 
goal: (fun x => x * c) ⁻¹' Set.Ioo a b = Set.Ioo (b / c) (a / c)

full_name: Set.preimage_mul_const_Ioc_of_neg
code: @[simp]
theorem preimage_mul_const_Ioc_of_neg (a b : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Ioc a b = Ico (b / c) (a / c) 
goal: (fun x => x * c) ⁻¹' Set.Ioc a b = Set.Ico (b / c) (a / c)

full_name: Set.preimage_mul_const_Ico_of_neg
code: @[simp]
theorem preimage_mul_const_Ico_of_neg (a b : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Ico a b = Ioc (b / c) (a / c) 
goal: (fun x => x * c) ⁻¹' Set.Ico a b = Set.Ioc (b / c) (a / c)

full_name: Set.preimage_mul_const_Icc_of_neg
code: @[simp]
theorem preimage_mul_const_Icc_of_neg (a b : α) {c : α} (h : c < 0) :
    (fun x => x * c) ⁻¹' Icc a b = Icc (b / c) (a / c) 
goal: (fun x => x * c) ⁻¹' Set.Icc a b = Set.Icc (b / c) (a / c)

full_name: Set.preimage_const_mul_Iio
code: @[simp]
theorem preimage_const_mul_Iio (a : α) {c : α} (h : 0 < c) : (c * ·) ⁻¹' Iio a = Iio (a / c) 
goal: (fun x => c * x) ⁻¹' Set.Iio a = Set.Iio (a / c)

full_name: Set.preimage_const_mul_Ioi
code: @[simp]
theorem preimage_const_mul_Ioi (a : α) {c : α} (h : 0 < c) : (c * ·) ⁻¹' Ioi a = Ioi (a / c) 
goal: (fun x => c * x) ⁻¹' Set.Ioi a = Set.Ioi (a / c)

full_name: Set.preimage_const_mul_Iic
code: @[simp]
theorem preimage_const_mul_Iic (a : α) {c : α} (h : 0 < c) : (c * ·) ⁻¹' Iic a = Iic (a / c) 
goal: (fun x => c * x) ⁻¹' Set.Iic a = Set.Iic (a / c)

full_name: Set.preimage_const_mul_Ici
code: @[simp]
theorem preimage_const_mul_Ici (a : α) {c : α} (h : 0 < c) : (c * ·) ⁻¹' Ici a = Ici (a / c) 
goal: (fun x => c * x) ⁻¹' Set.Ici a = Set.Ici (a / c)

full_name: Set.preimage_const_mul_Ioo
code: @[simp]
theorem preimage_const_mul_Ioo (a b : α) {c : α} (h : 0 < c) :
    (c * ·) ⁻¹' Ioo a b = Ioo (a / c) (b / c) 
goal: (fun x => c * x) ⁻¹' Set.Ioo a b = Set.Ioo (a / c) (b / c)

full_name: Set.preimage_const_mul_Ioc
code: @[simp]
theorem preimage_const_mul_Ioc (a b : α) {c : α} (h : 0 < c) :
    (c * ·) ⁻¹' Ioc a b = Ioc (a / c) (b / c) 
goal: (fun x => c * x) ⁻¹' Set.Ioc a b = Set.Ioc (a / c) (b / c)

full_name: Set.preimage_const_mul_Ico
code: @[simp]
theorem preimage_const_mul_Ico (a b : α) {c : α} (h : 0 < c) :
    (c * ·) ⁻¹' Ico a b = Ico (a / c) (b / c) 
goal: (fun x => c * x) ⁻¹' Set.Ico a b = Set.Ico (a / c) (b / c)

full_name: Set.preimage_const_mul_Icc
code: @[simp]
theorem preimage_const_mul_Icc (a b : α) {c : α} (h : 0 < c) :
    (c * ·) ⁻¹' Icc a b = Icc (a / c) (b / c) 
goal: (fun x => c * x) ⁻¹' Set.Icc a b = Set.Icc (a / c) (b / c)

full_name: Set.preimage_const_mul_Iio_of_neg
code: @[simp]
theorem preimage_const_mul_Iio_of_neg (a : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Iio a = Ioi (a / c) 
goal: (fun x => c * x) ⁻¹' Set.Iio a = Set.Ioi (a / c)

full_name: Set.preimage_const_mul_Ioi_of_neg
code: @[simp]
theorem preimage_const_mul_Ioi_of_neg (a : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Ioi a = Iio (a / c) 
goal: (fun x => c * x) ⁻¹' Set.Ioi a = Set.Iio (a / c)

full_name: Set.preimage_const_mul_Iic_of_neg
code: @[simp]
theorem preimage_const_mul_Iic_of_neg (a : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Iic a = Ici (a / c) 
goal: (fun x => c * x) ⁻¹' Set.Iic a = Set.Ici (a / c)

full_name: Set.preimage_const_mul_Ici_of_neg
code: @[simp]
theorem preimage_const_mul_Ici_of_neg (a : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Ici a = Iic (a / c) 
goal: (fun x => c * x) ⁻¹' Set.Ici a = Set.Iic (a / c)

full_name: Set.preimage_const_mul_Ioo_of_neg
code: @[simp]
theorem preimage_const_mul_Ioo_of_neg (a b : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Ioo a b = Ioo (b / c) (a / c) 
goal: (fun x => c * x) ⁻¹' Set.Ioo a b = Set.Ioo (b / c) (a / c)

full_name: Set.preimage_const_mul_Ioc_of_neg
code: @[simp]
theorem preimage_const_mul_Ioc_of_neg (a b : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Ioc a b = Ico (b / c) (a / c) 
goal: (fun x => c * x) ⁻¹' Set.Ioc a b = Set.Ico (b / c) (a / c)

full_name: Set.preimage_const_mul_Ico_of_neg
code: @[simp]
theorem preimage_const_mul_Ico_of_neg (a b : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Ico a b = Ioc (b / c) (a / c) 
goal: (fun x => c * x) ⁻¹' Set.Ico a b = Set.Ioc (b / c) (a / c)

full_name: Set.preimage_const_mul_Icc_of_neg
code: @[simp]
theorem preimage_const_mul_Icc_of_neg (a b : α) {c : α} (h : c < 0) :
    (c * ·) ⁻¹' Icc a b = Icc (b / c) (a / c) 
goal: (fun x => c * x) ⁻¹' Set.Icc a b = Set.Icc (b / c) (a / c)

full_name: Set.preimage_mul_const_uIcc
code: @[simp]
theorem preimage_mul_const_uIcc (ha : a ≠ 0) (b c : α) :
    (· * a) ⁻¹' [[b, c]] = [[b / a, c / a]] 
goal: (fun x => x * a) ⁻¹' [[b, c]] = [[b / a, c / a]]

full_name: Set.preimage_const_mul_uIcc
code: @[simp]
theorem preimage_const_mul_uIcc (ha : a ≠ 0) (b c : α) :
    (a * ·) ⁻¹' [[b, c]] = [[b / a, c / a]] 
goal: (fun x => a * x) ⁻¹' [[b, c]] = [[b / a, c / a]]

full_name: Set.preimage_div_const_uIcc
code: @[simp]
theorem preimage_div_const_uIcc (ha : a ≠ 0) (b c : α) :
    (fun x => x / a) ⁻¹' [[b, c]] = [[b * a, c * a]] 
goal: (fun x => x / a) ⁻¹' [[b, c]] = [[b * a, c * a]]

full_name: Set.image_mul_const_uIcc
code: @[simp]
theorem image_mul_const_uIcc (a b c : α) : (· * a) '' [[b, c]] = [[b * a, c * a]] 
goal: (fun x => x * a) '' [[b, c]] = [[b * a, c * a]]

full_name: Set.image_const_mul_uIcc
code: @[simp]
theorem image_const_mul_uIcc (a b c : α) : (a * ·) '' [[b, c]] = [[a * b, a * c]] 
goal: (fun x => a * x) '' [[b, c]] = [[a * b, a * c]]

full_name: Set.image_div_const_uIcc
code: @[simp]
theorem image_div_const_uIcc (a b c : α) : (fun x => x / a) '' [[b, c]] = [[b / a, c / a]] 
goal: (fun x => x / a) '' [[b, c]] = [[b / a, c / a]]

full_name: Set.image_mul_right_Icc'
code: theorem image_mul_right_Icc' (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) '' Icc a b = Icc (a * c) (b * c) 
goal: (fun x => x * c) '' Set.Icc a b = Set.Icc (a * c) (b * c)

full_name: Set.image_mul_right_Icc
code: theorem image_mul_right_Icc {a b c : α} (hab : a ≤ b) (hc : 0 ≤ c) :
    (fun x => x * c) '' Icc a b = Icc (a * c) (b * c) 
goal: (fun x => x * c) '' Set.Icc a b = Set.Icc (a * c) (b * c)

full_name: Set.image_mul_left_Icc'
code: theorem image_mul_left_Icc' {a : α} (h : 0 < a) (b c : α) :
    (a * ·) '' Icc b c = Icc (a * b) (a * c) 
goal: (fun x => a * x) '' Set.Icc b c = Set.Icc (a * b) (a * c)

full_name: Set.image_mul_left_Icc
code: theorem image_mul_left_Icc {a b c : α} (ha : 0 ≤ a) (hbc : b ≤ c) :
    (a * ·) '' Icc b c = Icc (a * b) (a * c) 
goal: (fun x => a * x) '' Set.Icc b c = Set.Icc (a * b) (a * c)

full_name: Set.image_mul_right_Ioo
code: theorem image_mul_right_Ioo (a b : α) {c : α} (h : 0 < c) :
    (fun x => x * c) '' Ioo a b = Ioo (a * c) (b * c) 
goal: (fun x => x * c) '' Set.Ioo a b = Set.Ioo (a * c) (b * c)

full_name: Set.image_mul_left_Ioo
code: theorem image_mul_left_Ioo {a : α} (h : 0 < a) (b c : α) :
    (a * ·) '' Ioo b c = Ioo (a * b) (a * c) 
goal: (fun x => a * x) '' Set.Ioo b c = Set.Ioo (a * b) (a * c)

full_name: Set.inv_Ioo_0_left
code: /-- The (pre)image under `inv` of `Ioo 0 a` is `Ioi a⁻¹`. -/
theorem inv_Ioo_0_left {a : α} (ha : 0 < a) : (Ioo 0 a)⁻¹ = Ioi a⁻¹ 
goal: (Set.Ioo 0 a)⁻¹ = Set.Ioi a⁻¹

full_name: Set.inv_Ioi
code: theorem inv_Ioi {a : α} (ha : 0 < a) : (Ioi a)⁻¹ = Ioo 0 a⁻¹ 
goal: (Set.Ioi a)⁻¹ = Set.Ioo 0 a⁻¹

full_name: Set.image_const_mul_Ioi_zero
code: theorem image_const_mul_Ioi_zero {k : Type*} [LinearOrderedField k] {x : k} (hx : 0 < x) :
    (fun y => x * y) '' Ioi (0 : k) = Ioi 0 
goal: (fun y => x * y) '' Set.Ioi 0 = Set.Ioi 0

full_name: Set.image_affine_Icc'
code: @[simp]
theorem image_affine_Icc' {a : α} (h : 0 < a) (b c d : α) :
    (a * · + b) '' Icc c d = Icc (a * c + b) (a * d + b) 
goal: (fun x => a * x + b) '' Set.Icc c d = Set.Icc (a * c + b) (a * d + b)