File: Mathlib/Analysis/Complex/ReImTopology.lean

full_name: Complex.isHomeomorphicTrivialFiberBundle_re
code: /-- `Complex.re` turns `ℂ` into a trivial topological fiber bundle over `ℝ`. -/
theorem isHomeomorphicTrivialFiberBundle_re : IsHomeomorphicTrivialFiberBundle ℝ re 
goal: IsHomeomorphicTrivialFiberBundle ℝ Complex.re

full_name: Complex.isHomeomorphicTrivialFiberBundle_im
code: /-- `Complex.im` turns `ℂ` into a trivial topological fiber bundle over `ℝ`. -/
theorem isHomeomorphicTrivialFiberBundle_im : IsHomeomorphicTrivialFiberBundle ℝ im 
goal: IsHomeomorphicTrivialFiberBundle ℝ Complex.im

full_name: Complex.isOpenMap_re
code: theorem isOpenMap_re : IsOpenMap re 
goal: IsOpenMap Complex.re

full_name: Complex.isOpenMap_im
code: theorem isOpenMap_im : IsOpenMap im 
goal: IsOpenMap Complex.im

full_name: Complex.quotientMap_re
code: theorem quotientMap_re : QuotientMap re 
goal: QuotientMap Complex.re

full_name: Complex.quotientMap_im
code: theorem quotientMap_im : QuotientMap im 
goal: QuotientMap Complex.im

full_name: Complex.interior_preimage_re
code: theorem interior_preimage_re (s : Set ℝ) : interior (re ⁻¹' s) = re ⁻¹' interior s 
goal: interior (Complex.re ⁻¹' s) = Complex.re ⁻¹' interior s

full_name: Complex.interior_preimage_im
code: theorem interior_preimage_im (s : Set ℝ) : interior (im ⁻¹' s) = im ⁻¹' interior s 
goal: interior (Complex.im ⁻¹' s) = Complex.im ⁻¹' interior s

full_name: Complex.closure_preimage_re
code: theorem closure_preimage_re (s : Set ℝ) : closure (re ⁻¹' s) = re ⁻¹' closure s 
goal: closure (Complex.re ⁻¹' s) = Complex.re ⁻¹' closure s

full_name: Complex.closure_preimage_im
code: theorem closure_preimage_im (s : Set ℝ) : closure (im ⁻¹' s) = im ⁻¹' closure s 
goal: closure (Complex.im ⁻¹' s) = Complex.im ⁻¹' closure s

full_name: Complex.frontier_preimage_re
code: theorem frontier_preimage_re (s : Set ℝ) : frontier (re ⁻¹' s) = re ⁻¹' frontier s 
goal: frontier (Complex.re ⁻¹' s) = Complex.re ⁻¹' frontier s

full_name: Complex.frontier_preimage_im
code: theorem frontier_preimage_im (s : Set ℝ) : frontier (im ⁻¹' s) = im ⁻¹' frontier s 
goal: frontier (Complex.im ⁻¹' s) = Complex.im ⁻¹' frontier s

full_name: Complex.interior_setOf_re_le
code: @[simp]
theorem interior_setOf_re_le (a : ℝ) : interior { z : ℂ | z.re ≤ a } = { z | z.re < a } 
goal: interior {z | z.re ≤ a} = {z | z.re < a}

full_name: Complex.interior_setOf_im_le
code: @[simp]
theorem interior_setOf_im_le (a : ℝ) : interior { z : ℂ | z.im ≤ a } = { z | z.im < a } 
goal: interior {z | z.im ≤ a} = {z | z.im < a}

full_name: Complex.interior_setOf_le_re
code: @[simp]
theorem interior_setOf_le_re (a : ℝ) : interior { z : ℂ | a ≤ z.re } = { z | a < z.re } 
goal: interior {z | a ≤ z.re} = {z | a < z.re}

full_name: Complex.interior_setOf_le_im
code: @[simp]
theorem interior_setOf_le_im (a : ℝ) : interior { z : ℂ | a ≤ z.im } = { z | a < z.im } 
goal: interior {z | a ≤ z.im} = {z | a < z.im}

full_name: Complex.closure_setOf_re_lt
code: @[simp]
theorem closure_setOf_re_lt (a : ℝ) : closure { z : ℂ | z.re < a } = { z | z.re ≤ a } 
goal: closure {z | z.re < a} = {z | z.re ≤ a}

full_name: Complex.closure_setOf_im_lt
code: @[simp]
theorem closure_setOf_im_lt (a : ℝ) : closure { z : ℂ | z.im < a } = { z | z.im ≤ a } 
goal: closure {z | z.im < a} = {z | z.im ≤ a}

full_name: Complex.closure_setOf_lt_re
code: @[simp]
theorem closure_setOf_lt_re (a : ℝ) : closure { z : ℂ | a < z.re } = { z | a ≤ z.re } 
goal: closure {z | a < z.re} = {z | a ≤ z.re}

full_name: Complex.closure_setOf_lt_im
code: @[simp]
theorem closure_setOf_lt_im (a : ℝ) : closure { z : ℂ | a < z.im } = { z | a ≤ z.im } 
goal: closure {z | a < z.im} = {z | a ≤ z.im}

full_name: Complex.frontier_setOf_re_le
code: @[simp]
theorem frontier_setOf_re_le (a : ℝ) : frontier { z : ℂ | z.re ≤ a } = { z | z.re = a } 
goal: frontier {z | z.re ≤ a} = {z | z.re = a}

full_name: Complex.frontier_setOf_im_le
code: @[simp]
theorem frontier_setOf_im_le (a : ℝ) : frontier { z : ℂ | z.im ≤ a } = { z | z.im = a } 
goal: frontier {z | z.im ≤ a} = {z | z.im = a}

full_name: Complex.frontier_setOf_le_re
code: @[simp]
theorem frontier_setOf_le_re (a : ℝ) : frontier { z : ℂ | a ≤ z.re } = { z | z.re = a } 
goal: frontier {z | a ≤ z.re} = {z | z.re = a}

full_name: Complex.frontier_setOf_le_im
code: @[simp]
theorem frontier_setOf_le_im (a : ℝ) : frontier { z : ℂ | a ≤ z.im } = { z | z.im = a } 
goal: frontier {z | a ≤ z.im} = {z | z.im = a}

full_name: Complex.frontier_setOf_re_lt
code: @[simp]
theorem frontier_setOf_re_lt (a : ℝ) : frontier { z : ℂ | z.re < a } = { z | z.re = a } 
goal: frontier {z | z.re < a} = {z | z.re = a}

full_name: Complex.frontier_setOf_im_lt
code: @[simp]
theorem frontier_setOf_im_lt (a : ℝ) : frontier { z : ℂ | z.im < a } = { z | z.im = a } 
goal: frontier {z | z.im < a} = {z | z.im = a}

full_name: Complex.frontier_setOf_lt_re
code: @[simp]
theorem frontier_setOf_lt_re (a : ℝ) : frontier { z : ℂ | a < z.re } = { z | z.re = a } 
goal: frontier {z | a < z.re} = {z | z.re = a}

full_name: Complex.frontier_setOf_lt_im
code: @[simp]
theorem frontier_setOf_lt_im (a : ℝ) : frontier { z : ℂ | a < z.im } = { z | z.im = a } 
goal: frontier {z | a < z.im} = {z | z.im = a}

full_name: Complex.closure_reProdIm
code: theorem closure_reProdIm (s t : Set ℝ) : closure (s ×ℂ t) = closure s ×ℂ closure t 
goal: closure (s ×ℂ t) = closure s ×ℂ closure t

full_name: Complex.interior_reProdIm
code: theorem interior_reProdIm (s t : Set ℝ) : interior (s ×ℂ t) = interior s ×ℂ interior t 
goal: interior (s ×ℂ t) = interior s ×ℂ interior t

full_name: Complex.frontier_reProdIm
code: theorem frontier_reProdIm (s t : Set ℝ) :
    frontier (s ×ℂ t) = closure s ×ℂ frontier t ∪ frontier s ×ℂ closure t 
goal: frontier (s ×ℂ t) = closure s ×ℂ frontier t ∪ frontier s ×ℂ closure t

full_name: Complex.frontier_setOf_le_re_and_le_im
code: theorem frontier_setOf_le_re_and_le_im (a b : ℝ) :
    frontier { z | a ≤ re z ∧ b ≤ im z } = { z | a ≤ re z ∧ im z = b ∨ re z = a ∧ b ≤ im z } 
goal: frontier {z | a ≤ z.re ∧ b ≤ z.im} = {z | a ≤ z.re ∧ z.im = b ∨ z.re = a ∧ b ≤ z.im}

full_name: Complex.frontier_setOf_le_re_and_im_le
code: theorem frontier_setOf_le_re_and_im_le (a b : ℝ) :
    frontier { z | a ≤ re z ∧ im z ≤ b } = { z | a ≤ re z ∧ im z = b ∨ re z = a ∧ im z ≤ b } 
goal: frontier {z | a ≤ z.re ∧ z.im ≤ b} = {z | a ≤ z.re ∧ z.im = b ∨ z.re = a ∧ z.im ≤ b}

full_name: IsOpen.reProdIm
code: theorem IsOpen.reProdIm (hs : IsOpen s) (ht : IsOpen t) : IsOpen (s ×ℂ t) 
goal: IsOpen (s ×ℂ t)

full_name: IsClosed.reProdIm
code: theorem IsClosed.reProdIm (hs : IsClosed s) (ht : IsClosed t) : IsClosed (s ×ℂ t) 
goal: IsClosed (s ×ℂ t)

full_name: Bornology.IsBounded.reProdIm
code: theorem Bornology.IsBounded.reProdIm (hs : IsBounded s) (ht : IsBounded t) : IsBounded (s ×ℂ t) 
goal: Bornology.IsBounded (s ×ℂ t)