File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

full_name: Complex.arg
code: /-- `arg` returns values in the range (-π, π], such that for `x ≠ 0`,
  `sin (arg x) = x.im / x.abs` and `cos (arg x) = x.re / x.abs`,
  `arg 0` defaults to `0` -/
noncomputable def arg (x : ℂ) : ℝ 
goal: ℝ

full_name: Complex.sin_arg
code: theorem sin_arg (x : ℂ) : Real.sin (arg x) = x.im / abs x 
goal: Real.sin x.arg = x.im / Complex.abs x

full_name: Complex.cos_arg
code: theorem cos_arg {x : ℂ} (hx : x ≠ 0) : Real.cos (arg x) = x.re / abs x 
goal: Real.cos x.arg = x.re / Complex.abs x

full_name: Complex.abs_mul_exp_arg_mul_I
code: @[simp]
theorem abs_mul_exp_arg_mul_I (x : ℂ) : ↑(abs x) * exp (arg x * I) = x 
goal: ↑(Complex.abs x) * Complex.exp (↑x.arg * Complex.I) = x

full_name: Complex.abs_mul_cos_add_sin_mul_I
code: @[simp]
theorem abs_mul_cos_add_sin_mul_I (x : ℂ) : (abs x * (cos (arg x) + sin (arg x) * I) : ℂ) = x 
goal: ↑(Complex.abs x) * (Complex.cos ↑x.arg + Complex.sin ↑x.arg * Complex.I) = x

full_name: Complex.abs_mul_cos_arg
code: @[simp]
lemma abs_mul_cos_arg (x : ℂ) : abs x * Real.cos (arg x) = x.re 
goal: Complex.abs x * Real.cos x.arg = x.re

full_name: Complex.abs_mul_sin_arg
code: @[simp]
lemma abs_mul_sin_arg (x : ℂ) : abs x * Real.sin (arg x) = x.im 
goal: Complex.abs x * Real.sin x.arg = x.im

full_name: Complex.abs_eq_one_iff
code: theorem abs_eq_one_iff (z : ℂ) : abs z = 1 ↔ ∃ θ : ℝ, exp (θ * I) = z 
goal: Complex.abs z = 1 ↔ ∃ θ, Complex.exp (↑θ * Complex.I) = z

full_name: Complex.range_exp_mul_I
code: @[simp]
theorem range_exp_mul_I : (Set.range fun x : ℝ => exp (x * I)) = Metric.sphere 0 1 
goal: (Set.range fun x => Complex.exp (↑x * Complex.I)) = Metric.sphere 0 1

full_name: Complex.arg_mul_cos_add_sin_mul_I
code: theorem arg_mul_cos_add_sin_mul_I {r : ℝ} (hr : 0 < r) {θ : ℝ} (hθ : θ ∈ Set.Ioc (-π) π) :
    arg (r * (cos θ + sin θ * I)) = θ 
goal: (↑r * (Complex.cos ↑θ + Complex.sin ↑θ * Complex.I)).arg = θ

full_name: Complex.arg_cos_add_sin_mul_I
code: theorem arg_cos_add_sin_mul_I {θ : ℝ} (hθ : θ ∈ Set.Ioc (-π) π) : arg (cos θ + sin θ * I) = θ 
goal: (Complex.cos ↑θ + Complex.sin ↑θ * Complex.I).arg = θ

full_name: Complex.arg_exp_mul_I
code: lemma arg_exp_mul_I (θ : ℝ) :
    arg (exp (θ * I)) = toIocMod (mul_pos two_pos Real.pi_pos) (-π) θ 
goal: (Complex.exp (↑θ * Complex.I)).arg = toIocMod ⋯ (-π) θ

full_name: Complex.arg_zero
code: @[simp]
theorem arg_zero : arg 0 = 0 
goal: Complex.arg 0 = 0

full_name: Complex.ext_abs_arg
code: theorem ext_abs_arg {x y : ℂ} (h₁ : abs x = abs y) (h₂ : x.arg = y.arg) : x = y 
goal: x = y

full_name: Complex.ext_abs_arg_iff
code: theorem ext_abs_arg_iff {x y : ℂ} : x = y ↔ abs x = abs y ∧ arg x = arg y 
goal: x = y ↔ Complex.abs x = Complex.abs y ∧ x.arg = y.arg

full_name: Complex.arg_mem_Ioc
code: theorem arg_mem_Ioc (z : ℂ) : arg z ∈ Set.Ioc (-π) π 
goal: z.arg ∈ Set.Ioc (-π) π

full_name: Complex.range_arg
code: @[simp]
theorem range_arg : Set.range arg = Set.Ioc (-π) π 
goal: Set.range Complex.arg = Set.Ioc (-π) π

full_name: Complex.arg_le_pi
code: theorem arg_le_pi (x : ℂ) : arg x ≤ π 
goal: x.arg ≤ π

full_name: Complex.neg_pi_lt_arg
code: theorem neg_pi_lt_arg (x : ℂ) : -π < arg x 
goal: -π < x.arg

full_name: Complex.abs_arg_le_pi
code: theorem abs_arg_le_pi (z : ℂ) : |arg z| ≤ π 
goal: |z.arg| ≤ π

full_name: Complex.arg_nonneg_iff
code: @[simp]
theorem arg_nonneg_iff {z : ℂ} : 0 ≤ arg z ↔ 0 ≤ z.im 
goal: 0 ≤ z.arg ↔ 0 ≤ z.im

full_name: Complex.arg_neg_iff
code: @[simp]
theorem arg_neg_iff {z : ℂ} : arg z < 0 ↔ z.im < 0 
goal: z.arg < 0 ↔ z.im < 0

full_name: Complex.arg_real_mul
code: theorem arg_real_mul (x : ℂ) {r : ℝ} (hr : 0 < r) : arg (r * x) = arg x 
goal: (↑r * x).arg = x.arg

full_name: Complex.arg_mul_real
code: theorem arg_mul_real {r : ℝ} (hr : 0 < r) (x : ℂ) : arg (x * r) = arg x 
goal: (x * ↑r).arg = x.arg

full_name: Complex.arg_eq_arg_iff
code: theorem arg_eq_arg_iff {x y : ℂ} (hx : x ≠ 0) (hy : y ≠ 0) :
    arg x = arg y ↔ (abs y / abs x : ℂ) * x = y 
goal: x.arg = y.arg ↔ ↑(Complex.abs y) / ↑(Complex.abs x) * x = y

full_name: Complex.arg_one
code: @[simp]
theorem arg_one : arg 1 = 0 
goal: Complex.arg 1 = 0

full_name: Complex.arg_neg_one
code: @[simp]
theorem arg_neg_one : arg (-1) = π 
goal: (-1).arg = π

full_name: Complex.arg_I
code: @[simp]
theorem arg_I : arg I = π / 2 
goal: Complex.I.arg = π / 2

full_name: Complex.arg_neg_I
code: @[simp]
theorem arg_neg_I : arg (-I) = -(π / 2) 
goal: (-Complex.I).arg = -(π / 2)

full_name: Complex.tan_arg
code: @[simp]
theorem tan_arg (x : ℂ) : Real.tan (arg x) = x.im / x.re 
goal: Real.tan x.arg = x.im / x.re

full_name: Complex.arg_ofReal_of_nonneg
code: theorem arg_ofReal_of_nonneg {x : ℝ} (hx : 0 ≤ x) : arg x = 0 
goal: (↑x).arg = 0

full_name: Complex.natCast_arg
code: @[simp, norm_cast]
lemma natCast_arg {n : ℕ} : arg n = 0 
goal: (↑n).arg = 0

full_name: Complex.ofNat_arg
code: @[simp]
lemma ofNat_arg {n : ℕ} [n.AtLeastTwo] : arg (no_index (OfNat.ofNat n)) = 0 
goal: (OfNat.ofNat n).arg = 0

full_name: Complex.arg_eq_zero_iff
code: theorem arg_eq_zero_iff {z : ℂ} : arg z = 0 ↔ 0 ≤ z.re ∧ z.im = 0 
goal: z.arg = 0 ↔ 0 ≤ z.re ∧ z.im = 0

full_name: Complex.arg_eq_zero_iff_zero_le
code: lemma arg_eq_zero_iff_zero_le {z : ℂ} : arg z = 0 ↔ 0 ≤ z 
goal: z.arg = 0 ↔ 0 ≤ z

full_name: Complex.arg_eq_pi_iff
code: theorem arg_eq_pi_iff {z : ℂ} : arg z = π ↔ z.re < 0 ∧ z.im = 0 
goal: z.arg = π ↔ z.re < 0 ∧ z.im = 0

full_name: Complex.arg_eq_pi_iff_lt_zero
code: lemma arg_eq_pi_iff_lt_zero {z : ℂ} : arg z = π ↔ z < 0 
goal: z.arg = π ↔ z < 0

full_name: Complex.arg_lt_pi_iff
code: theorem arg_lt_pi_iff {z : ℂ} : arg z < π ↔ 0 ≤ z.re ∨ z.im ≠ 0 
goal: z.arg < π ↔ 0 ≤ z.re ∨ z.im ≠ 0

full_name: Complex.arg_ofReal_of_neg
code: theorem arg_ofReal_of_neg {x : ℝ} (hx : x < 0) : arg x = π 
goal: (↑x).arg = π

full_name: Complex.arg_eq_pi_div_two_iff
code: theorem arg_eq_pi_div_two_iff {z : ℂ} : arg z = π / 2 ↔ z.re = 0 ∧ 0 < z.im 
goal: z.arg = π / 2 ↔ z.re = 0 ∧ 0 < z.im

full_name: Complex.arg_eq_neg_pi_div_two_iff
code: theorem arg_eq_neg_pi_div_two_iff {z : ℂ} : arg z = -(π / 2) ↔ z.re = 0 ∧ z.im < 0 
goal: z.arg = -(π / 2) ↔ z.re = 0 ∧ z.im < 0

full_name: Complex.arg_of_re_nonneg
code: theorem arg_of_re_nonneg {x : ℂ} (hx : 0 ≤ x.re) : arg x = Real.arcsin (x.im / abs x) 
goal: x.arg = Real.arcsin (x.im / Complex.abs x)

full_name: Complex.arg_of_re_neg_of_im_nonneg
code: theorem arg_of_re_neg_of_im_nonneg {x : ℂ} (hx_re : x.re < 0) (hx_im : 0 ≤ x.im) :
    arg x = Real.arcsin ((-x).im / abs x) + π 
goal: x.arg = Real.arcsin ((-x).im / Complex.abs x) + π

full_name: Complex.arg_of_re_neg_of_im_neg
code: theorem arg_of_re_neg_of_im_neg {x : ℂ} (hx_re : x.re < 0) (hx_im : x.im < 0) :
    arg x = Real.arcsin ((-x).im / abs x) - π 
goal: x.arg = Real.arcsin ((-x).im / Complex.abs x) - π

full_name: Complex.arg_of_im_nonneg_of_ne_zero
code: theorem arg_of_im_nonneg_of_ne_zero {z : ℂ} (h₁ : 0 ≤ z.im) (h₂ : z ≠ 0) :
    arg z = Real.arccos (z.re / abs z) 
goal: z.arg = Real.arccos (z.re / Complex.abs z)

full_name: Complex.arg_of_im_pos
code: theorem arg_of_im_pos {z : ℂ} (hz : 0 < z.im) : arg z = Real.arccos (z.re / abs z) 
goal: z.arg = Real.arccos (z.re / Complex.abs z)

full_name: Complex.arg_of_im_neg
code: theorem arg_of_im_neg {z : ℂ} (hz : z.im < 0) : arg z = -Real.arccos (z.re / abs z) 
goal: z.arg = -Real.arccos (z.re / Complex.abs z)

full_name: Complex.arg_conj
code: theorem arg_conj (x : ℂ) : arg (conj x) = if arg x = π then π else -arg x 
goal: ((starRingEnd ℂ) x).arg = if x.arg = π then π else -x.arg

full_name: Complex.arg_inv
code: theorem arg_inv (x : ℂ) : arg x⁻¹ = if arg x = π then π else -arg x 
goal: x⁻¹.arg = if x.arg = π then π else -x.arg

full_name: Complex.abs_arg_inv
code: @[simp] lemma abs_arg_inv (x : ℂ) : |x⁻¹.arg| = |x.arg| 
goal: |x⁻¹.arg| = |x.arg|

full_name: Complex.abs_eq_one_iff'
code: lemma abs_eq_one_iff' : abs x = 1 ↔ ∃ θ ∈ Set.Ioc (-π) π, exp (θ * I) = x 
goal: Complex.abs x = 1 ↔ ∃ θ ∈ Set.Ioc (-π) π, Complex.exp (↑θ * Complex.I) = x

full_name: Complex.image_exp_Ioc_eq_sphere
code: lemma image_exp_Ioc_eq_sphere : (fun θ : ℝ ↦ exp (θ * I)) '' Set.Ioc (-π) π = sphere 0 1 
goal: (fun θ => Complex.exp (↑θ * Complex.I)) '' Set.Ioc (-π) π = Metric.sphere 0 1

full_name: Complex.arg_le_pi_div_two_iff
code: theorem arg_le_pi_div_two_iff {z : ℂ} : arg z ≤ π / 2 ↔ 0 ≤ re z ∨ im z < 0 
goal: z.arg ≤ π / 2 ↔ 0 ≤ z.re ∨ z.im < 0

full_name: Complex.neg_pi_div_two_le_arg_iff
code: theorem neg_pi_div_two_le_arg_iff {z : ℂ} : -(π / 2) ≤ arg z ↔ 0 ≤ re z ∨ 0 ≤ im z 
goal: -(π / 2) ≤ z.arg ↔ 0 ≤ z.re ∨ 0 ≤ z.im

full_name: Complex.neg_pi_div_two_lt_arg_iff
code: lemma neg_pi_div_two_lt_arg_iff {z : ℂ} : -(π / 2) < arg z ↔ 0 < re z ∨ 0 ≤ im z 
goal: -(π / 2) < z.arg ↔ 0 < z.re ∨ 0 ≤ z.im

full_name: Complex.arg_lt_pi_div_two_iff
code: lemma arg_lt_pi_div_two_iff {z : ℂ} : arg z < π / 2 ↔ 0 < re z ∨ im z < 0 ∨ z = 0 
goal: z.arg < π / 2 ↔ 0 < z.re ∨ z.im < 0 ∨ z = 0

full_name: Complex.abs_arg_le_pi_div_two_iff
code: @[simp]
theorem abs_arg_le_pi_div_two_iff {z : ℂ} : |arg z| ≤ π / 2 ↔ 0 ≤ re z 
goal: |z.arg| ≤ π / 2 ↔ 0 ≤ z.re

full_name: Complex.abs_arg_lt_pi_div_two_iff
code: @[simp]
theorem abs_arg_lt_pi_div_two_iff {z : ℂ} : |arg z| < π / 2 ↔ 0 < re z ∨ z = 0 
goal: |z.arg| < π / 2 ↔ 0 < z.re ∨ z = 0

full_name: Complex.arg_conj_coe_angle
code: @[simp]
theorem arg_conj_coe_angle (x : ℂ) : (arg (conj x) : Real.Angle) = -arg x 
goal: ↑((starRingEnd ℂ) x).arg = -↑x.arg

full_name: Complex.arg_inv_coe_angle
code: @[simp]
theorem arg_inv_coe_angle (x : ℂ) : (arg x⁻¹ : Real.Angle) = -arg x 
goal: ↑x⁻¹.arg = -↑x.arg

full_name: Complex.arg_neg_eq_arg_sub_pi_of_im_pos
code: theorem arg_neg_eq_arg_sub_pi_of_im_pos {x : ℂ} (hi : 0 < x.im) : arg (-x) = arg x - π 
goal: (-x).arg = x.arg - π

full_name: Complex.arg_neg_eq_arg_add_pi_of_im_neg
code: theorem arg_neg_eq_arg_add_pi_of_im_neg {x : ℂ} (hi : x.im < 0) : arg (-x) = arg x + π 
goal: (-x).arg = x.arg + π

full_name: Complex.arg_neg_eq_arg_sub_pi_iff
code: theorem arg_neg_eq_arg_sub_pi_iff {x : ℂ} :
    arg (-x) = arg x - π ↔ 0 < x.im ∨ x.im = 0 ∧ x.re < 0 
goal: (-x).arg = x.arg - π ↔ 0 < x.im ∨ x.im = 0 ∧ x.re < 0

full_name: Complex.arg_neg_eq_arg_add_pi_iff
code: theorem arg_neg_eq_arg_add_pi_iff {x : ℂ} :
    arg (-x) = arg x + π ↔ x.im < 0 ∨ x.im = 0 ∧ 0 < x.re 
goal: (-x).arg = x.arg + π ↔ x.im < 0 ∨ x.im = 0 ∧ 0 < x.re

full_name: Complex.arg_neg_coe_angle
code: theorem arg_neg_coe_angle {x : ℂ} (hx : x ≠ 0) : (arg (-x) : Real.Angle) = arg x + π 
goal: ↑(-x).arg = ↑x.arg + ↑π

full_name: Complex.arg_mul_cos_add_sin_mul_I_eq_toIocMod
code: theorem arg_mul_cos_add_sin_mul_I_eq_toIocMod {r : ℝ} (hr : 0 < r) (θ : ℝ) :
    arg (r * (cos θ + sin θ * I)) = toIocMod Real.two_pi_pos (-π) θ 
goal: (↑r * (Complex.cos ↑θ + Complex.sin ↑θ * Complex.I)).arg = toIocMod Real.two_pi_pos (-π) θ

full_name: Complex.arg_cos_add_sin_mul_I_eq_toIocMod
code: theorem arg_cos_add_sin_mul_I_eq_toIocMod (θ : ℝ) :
    arg (cos θ + sin θ * I) = toIocMod Real.two_pi_pos (-π) θ 
goal: (Complex.cos ↑θ + Complex.sin ↑θ * Complex.I).arg = toIocMod Real.two_pi_pos (-π) θ

full_name: Complex.arg_mul_cos_add_sin_mul_I_sub
code: theorem arg_mul_cos_add_sin_mul_I_sub {r : ℝ} (hr : 0 < r) (θ : ℝ) :
    arg (r * (cos θ + sin θ * I)) - θ = 2 * π * ⌊(π - θ) / (2 * π)⌋ 
goal: (↑r * (Complex.cos ↑θ + Complex.sin ↑θ * Complex.I)).arg - θ = 2 * π * ↑⌊(π - θ) / (2 * π)⌋

full_name: Complex.arg_cos_add_sin_mul_I_sub
code: theorem arg_cos_add_sin_mul_I_sub (θ : ℝ) :
    arg (cos θ + sin θ * I) - θ = 2 * π * ⌊(π - θ) / (2 * π)⌋ 
goal: (Complex.cos ↑θ + Complex.sin ↑θ * Complex.I).arg - θ = 2 * π * ↑⌊(π - θ) / (2 * π)⌋

full_name: Complex.arg_mul_cos_add_sin_mul_I_coe_angle
code: theorem arg_mul_cos_add_sin_mul_I_coe_angle {r : ℝ} (hr : 0 < r) (θ : Real.Angle) :
    (arg (r * (Real.Angle.cos θ + Real.Angle.sin θ * I)) : Real.Angle) = θ 
goal: ↑(↑r * (↑θ.cos + ↑θ.sin * Complex.I)).arg = θ

full_name: Complex.arg_cos_add_sin_mul_I_coe_angle
code: theorem arg_cos_add_sin_mul_I_coe_angle (θ : Real.Angle) :
    (arg (Real.Angle.cos θ + Real.Angle.sin θ * I) : Real.Angle) = θ 
goal: ↑(↑θ.cos + ↑θ.sin * Complex.I).arg = θ

full_name: Complex.arg_mul_coe_angle
code: theorem arg_mul_coe_angle {x y : ℂ} (hx : x ≠ 0) (hy : y ≠ 0) :
    (arg (x * y) : Real.Angle) = arg x + arg y 
goal: ↑(x * y).arg = ↑x.arg + ↑y.arg

full_name: Complex.arg_div_coe_angle
code: theorem arg_div_coe_angle {x y : ℂ} (hx : x ≠ 0) (hy : y ≠ 0) :
    (arg (x / y) : Real.Angle) = arg x - arg y 
goal: ↑(x / y).arg = ↑x.arg - ↑y.arg

full_name: Complex.arg_coe_angle_toReal_eq_arg
code: @[simp]
theorem arg_coe_angle_toReal_eq_arg (z : ℂ) : (arg z : Real.Angle).toReal = arg z 
goal: (↑z.arg).toReal = z.arg

full_name: Complex.arg_coe_angle_eq_iff_eq_toReal
code: theorem arg_coe_angle_eq_iff_eq_toReal {z : ℂ} {θ : Real.Angle} :
    (arg z : Real.Angle) = θ ↔ arg z = θ.toReal 
goal: ↑z.arg = θ ↔ z.arg = θ.toReal

full_name: Complex.arg_coe_angle_eq_iff
code: @[simp]
theorem arg_coe_angle_eq_iff {x y : ℂ} : (arg x : Real.Angle) = arg y ↔ arg x = arg y 
goal: ↑x.arg = ↑y.arg ↔ x.arg = y.arg

full_name: Complex.arg_mul_eq_add_arg_iff
code: lemma arg_mul_eq_add_arg_iff {x y : ℂ} (hx₀ : x ≠ 0) (hy₀ : y ≠ 0) :
    (x * y).arg = x.arg + y.arg ↔ arg x + arg y ∈ Set.Ioc (-π) π 
goal: (x * y).arg = x.arg + y.arg ↔ x.arg + y.arg ∈ Set.Ioc (-π) π

full_name: Complex.mem_slitPlane_iff_arg
code: /-- An alternative description of the slit plane as consisting of nonzero complex numbers
whose argument is not π. -/
lemma mem_slitPlane_iff_arg {z : ℂ} : z ∈ slitPlane ↔ z.arg ≠ π ∧ z ≠ 0 
goal: z ∈ Complex.slitPlane ↔ z.arg ≠ π ∧ z ≠ 0

full_name: Complex.slitPlane_arg_ne_pi
code: lemma slitPlane_arg_ne_pi {z : ℂ} (hz : z ∈ slitPlane) : z.arg ≠ Real.pi 
goal: z.arg ≠ π

full_name: Complex.arg_eq_nhds_of_re_pos
code: theorem arg_eq_nhds_of_re_pos (hx : 0 < x.re) : arg =ᶠ[𝓝 x] fun x => Real.arcsin (x.im / abs x) 
goal: Complex.arg =ᶠ[𝓝 x] fun x => Real.arcsin (x.im / Complex.abs x)

full_name: Complex.arg_eq_nhds_of_re_neg_of_im_pos
code: theorem arg_eq_nhds_of_re_neg_of_im_pos (hx_re : x.re < 0) (hx_im : 0 < x.im) :
    arg =ᶠ[𝓝 x] fun x => Real.arcsin ((-x).im / abs x) + π 
goal: Complex.arg =ᶠ[𝓝 x] fun x => Real.arcsin ((-x).im / Complex.abs x) + π

full_name: Complex.arg_eq_nhds_of_re_neg_of_im_neg
code: theorem arg_eq_nhds_of_re_neg_of_im_neg (hx_re : x.re < 0) (hx_im : x.im < 0) :
    arg =ᶠ[𝓝 x] fun x => Real.arcsin ((-x).im / abs x) - π 
goal: Complex.arg =ᶠ[𝓝 x] fun x => Real.arcsin ((-x).im / Complex.abs x) - π

full_name: Complex.arg_eq_nhds_of_im_pos
code: theorem arg_eq_nhds_of_im_pos (hz : 0 < im z) : arg =ᶠ[𝓝 z] fun x => Real.arccos (x.re / abs x) 
goal: Complex.arg =ᶠ[𝓝 z] fun x => Real.arccos (x.re / Complex.abs x)

full_name: Complex.arg_eq_nhds_of_im_neg
code: theorem arg_eq_nhds_of_im_neg (hz : im z < 0) : arg =ᶠ[𝓝 z] fun x => -Real.arccos (x.re / abs x) 
goal: Complex.arg =ᶠ[𝓝 z] fun x => -Real.arccos (x.re / Complex.abs x)

full_name: Complex.continuousAt_arg
code: theorem continuousAt_arg (h : x ∈ slitPlane) : ContinuousAt arg x 
goal: ContinuousAt Complex.arg x

full_name: Complex.tendsto_arg_nhdsWithin_im_neg_of_re_neg_of_im_zero
code: theorem tendsto_arg_nhdsWithin_im_neg_of_re_neg_of_im_zero {z : ℂ} (hre : z.re < 0)
    (him : z.im = 0) : Tendsto arg (𝓝[{ z : ℂ | z.im < 0 }] z) (𝓝 (-π)) 
goal: Filter.Tendsto Complex.arg (𝓝[{z | z.im < 0}] z) (𝓝 (-π))

full_name: Complex.continuousWithinAt_arg_of_re_neg_of_im_zero
code: theorem continuousWithinAt_arg_of_re_neg_of_im_zero {z : ℂ} (hre : z.re < 0) (him : z.im = 0) :
    ContinuousWithinAt arg { z : ℂ | 0 ≤ z.im } z 
goal: ContinuousWithinAt Complex.arg {z | 0 ≤ z.im} z

full_name: Complex.tendsto_arg_nhdsWithin_im_nonneg_of_re_neg_of_im_zero
code: theorem tendsto_arg_nhdsWithin_im_nonneg_of_re_neg_of_im_zero {z : ℂ} (hre : z.re < 0)
    (him : z.im = 0) : Tendsto arg (𝓝[{ z : ℂ | 0 ≤ z.im }] z) (𝓝 π) 
goal: Filter.Tendsto Complex.arg (𝓝[{z | 0 ≤ z.im}] z) (𝓝 π)

full_name: Complex.continuousAt_arg_coe_angle
code: theorem continuousAt_arg_coe_angle (h : x ≠ 0) : ContinuousAt ((↑) ∘ arg : ℂ → Real.Angle) x 
goal: ContinuousAt (Real.Angle.coe ∘ Complex.arg) x