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

full_name: circle.injective_arg
code: theorem injective_arg : Injective fun z : circle => arg z 
goal: Function.Injective fun z => (↑z).arg

full_name: circle.arg_eq_arg
code: @[simp]
theorem arg_eq_arg {z w : circle} : arg z = arg w ↔ z = w 
goal: (↑z).arg = (↑w).arg ↔ z = w

full_name: arg_expMapCircle
code: theorem arg_expMapCircle {x : ℝ} (h₁ : -π < x) (h₂ : x ≤ π) : arg (expMapCircle x) = x 
goal: (↑(expMapCircle x)).arg = x

full_name: expMapCircle_arg
code: @[simp]
theorem expMapCircle_arg (z : circle) : expMapCircle (arg z) = z 
goal: expMapCircle (↑z).arg = z

full_name: circle.argPartialEquiv
code: /-- `Complex.arg ∘ (↑)` and `expMapCircle` define a partial equivalence between `circle` and `ℝ`
with `source = Set.univ` and `target = Set.Ioc (-π) π`. -/
@[simps (config := .asFn)]
noncomputable def argPartialEquiv : PartialEquiv circle ℝ 
goal: PartialEquiv ↥circle ℝ

full_name: circle.argPartialEquiv_source
code: /-- `Complex.arg ∘ (↑)` and `expMapCircle` define a partial equivalence between `circle` and `ℝ`
with `source = Set.univ` and `target = Set.Ioc (-π) π`. -/
@[simps (config := .asFn)]
noncomputable def argPartialEquiv : PartialEquiv circle ℝ 
goal: circle.argPartialEquiv.source = Set.univ

full_name: circle.argPartialEquiv_target
code: /-- `Complex.arg ∘ (↑)` and `expMapCircle` define a partial equivalence between `circle` and `ℝ`
with `source = Set.univ` and `target = Set.Ioc (-π) π`. -/
@[simps (config := .asFn)]
noncomputable def argPartialEquiv : PartialEquiv circle ℝ 
goal: circle.argPartialEquiv.target = Set.Ioc (-π) π

full_name: circle.argPartialEquiv_symm_apply
code: /-- `Complex.arg ∘ (↑)` and `expMapCircle` define a partial equivalence between `circle` and `ℝ`
with `source = Set.univ` and `target = Set.Ioc (-π) π`. -/
@[simps (config := .asFn)]
noncomputable def argPartialEquiv : PartialEquiv circle ℝ 
goal: ↑circle.argPartialEquiv.symm = ⇑expMapCircle

full_name: circle.argPartialEquiv_apply
code: /-- `Complex.arg ∘ (↑)` and `expMapCircle` define a partial equivalence between `circle` and `ℝ`
with `source = Set.univ` and `target = Set.Ioc (-π) π`. -/
@[simps (config := .asFn)]
noncomputable def argPartialEquiv : PartialEquiv circle ℝ 
goal: ↑circle.argPartialEquiv = Complex.arg ∘ Subtype.val

full_name: circle.argEquiv_apply_coe
code: /-- `Complex.arg` and `expMapCircle` define an equivalence between `circle` and `(-π, π]`. -/
@[simps (config := .asFn)]
noncomputable def argEquiv : circle ≃ Ioc (-π) π 
goal: ↑(circle.argEquiv z) = (↑z).arg

full_name: circle.argEquiv
code: /-- `Complex.arg` and `expMapCircle` define an equivalence between `circle` and `(-π, π]`. -/
@[simps (config := .asFn)]
noncomputable def argEquiv : circle ≃ Ioc (-π) π 
goal: ↥circle ≃ ↑(Set.Ioc (-π) π)

full_name: circle.argEquiv_symm_apply
code: /-- `Complex.arg` and `expMapCircle` define an equivalence between `circle` and `(-π, π]`. -/
@[simps (config := .asFn)]
noncomputable def argEquiv : circle ≃ Ioc (-π) π 
goal: ⇑circle.argEquiv.symm = ⇑expMapCircle ∘ Subtype.val

full_name: leftInverse_expMapCircle_arg
code: theorem leftInverse_expMapCircle_arg : LeftInverse expMapCircle (arg ∘ (↑)) 
goal: Function.LeftInverse (⇑expMapCircle) (Complex.arg ∘ Subtype.val)

full_name: invOn_arg_expMapCircle
code: theorem invOn_arg_expMapCircle : InvOn (arg ∘ (↑)) expMapCircle (Ioc (-π) π) univ 
goal: Set.InvOn (Complex.arg ∘ Subtype.val) (⇑expMapCircle) (Set.Ioc (-π) π) Set.univ

full_name: surjOn_expMapCircle_neg_pi_pi
code: theorem surjOn_expMapCircle_neg_pi_pi : SurjOn expMapCircle (Ioc (-π) π) univ 
goal: Set.SurjOn (⇑expMapCircle) (Set.Ioc (-π) π) Set.univ

full_name: expMapCircle_eq_expMapCircle
code: theorem expMapCircle_eq_expMapCircle {x y : ℝ} :
    expMapCircle x = expMapCircle y ↔ ∃ m : ℤ, x = y + m * (2 * π) 
goal: expMapCircle x = expMapCircle y ↔ ∃ m, x = y + ↑m * (2 * π)

full_name: periodic_expMapCircle
code: theorem periodic_expMapCircle : Periodic expMapCircle (2 * π) 
goal: Function.Periodic (⇑expMapCircle) (2 * π)

full_name: expMapCircle_two_pi
code: @[simp]
theorem expMapCircle_two_pi : expMapCircle (2 * π) = 1 
goal: expMapCircle (2 * π) = 1

full_name: expMapCircle_sub_two_pi
code: theorem expMapCircle_sub_two_pi (x : ℝ) : expMapCircle (x - 2 * π) = expMapCircle x 
goal: expMapCircle (x - 2 * π) = expMapCircle x

full_name: expMapCircle_add_two_pi
code: theorem expMapCircle_add_two_pi (x : ℝ) : expMapCircle (x + 2 * π) = expMapCircle x 
goal: expMapCircle (x + 2 * π) = expMapCircle x

full_name: Real.Angle.expMapCircle
code: /-- `expMapCircle`, applied to a `Real.Angle`. -/
noncomputable def Real.Angle.expMapCircle (θ : Real.Angle) : circle 
goal: ↥circle

full_name: Real.Angle.expMapCircle_coe
code: @[simp]
theorem Real.Angle.expMapCircle_coe (x : ℝ) : Real.Angle.expMapCircle x = _root_.expMapCircle x 
goal: (↑x).expMapCircle = expMapCircle x

full_name: Real.Angle.coe_expMapCircle
code: theorem Real.Angle.coe_expMapCircle (θ : Real.Angle) :
    (θ.expMapCircle : ℂ) = θ.cos + θ.sin * I 
goal: ↑θ.expMapCircle = ↑θ.cos + ↑θ.sin * Complex.I

full_name: Real.Angle.expMapCircle_zero
code: @[simp]
theorem Real.Angle.expMapCircle_zero : Real.Angle.expMapCircle 0 = 1 
goal: Real.Angle.expMapCircle 0 = 1

full_name: Real.Angle.expMapCircle_neg
code: @[simp]
theorem Real.Angle.expMapCircle_neg (θ : Real.Angle) :
    Real.Angle.expMapCircle (-θ) = (Real.Angle.expMapCircle θ)⁻¹ 
goal: (-θ).expMapCircle = θ.expMapCircle⁻¹

full_name: Real.Angle.expMapCircle_add
code: @[simp]
theorem Real.Angle.expMapCircle_add (θ₁ θ₂ : Real.Angle) : Real.Angle.expMapCircle (θ₁ + θ₂) =
    Real.Angle.expMapCircle θ₁ * Real.Angle.expMapCircle θ₂ 
goal: (θ₁ + θ₂).expMapCircle = θ₁.expMapCircle * θ₂.expMapCircle

full_name: Real.Angle.arg_expMapCircle
code: @[simp]
theorem Real.Angle.arg_expMapCircle (θ : Real.Angle) :
    (arg (Real.Angle.expMapCircle θ) : Real.Angle) = θ 
goal: ↑(↑θ.expMapCircle).arg = θ

full_name: AddCircle.scaled_exp_map_periodic
code: theorem scaled_exp_map_periodic : Function.Periodic (fun x => expMapCircle (2 * π / T * x)) T 
goal: Function.Periodic (fun x => expMapCircle (2 * π / T * x)) T

full_name: AddCircle.toCircle
code: /-- The canonical map `fun x => exp (2 π i x / T)` from `ℝ / ℤ • T` to the unit circle in `ℂ`.
If `T = 0` we understand this as the constant function 1. -/
noncomputable def toCircle : AddCircle T → circle 
goal: AddCircle T → ↥circle

full_name: AddCircle.toCircle_apply_mk
code: theorem toCircle_apply_mk (x : ℝ) : @toCircle T x = expMapCircle (2 * π / T * x) 
goal: AddCircle.toCircle ↑x = expMapCircle (2 * π / T * x)

full_name: AddCircle.toCircle_add
code: theorem toCircle_add (x : AddCircle T) (y : AddCircle T) :
    @toCircle T (x + y) = toCircle x * toCircle y 
goal: (x + y).toCircle = x.toCircle * y.toCircle

full_name: AddCircle.continuous_toCircle
code: theorem continuous_toCircle : Continuous (@toCircle T) 
goal: Continuous AddCircle.toCircle

full_name: AddCircle.injective_toCircle
code: theorem injective_toCircle (hT : T ≠ 0) : Function.Injective (@toCircle T) 
goal: Function.Injective AddCircle.toCircle

full_name: AddCircle.homeomorphCircle'_apply
code: /-- The homeomorphism between `AddCircle (2 * π)` and `circle`. -/
@[simps] noncomputable def homeomorphCircle' : AddCircle (2 * π) ≃ₜ circle 
goal: AddCircle.homeomorphCircle' θ = θ.expMapCircle

full_name: AddCircle.homeomorphCircle'
code: /-- The homeomorphism between `AddCircle (2 * π)` and `circle`. -/
@[simps] noncomputable def homeomorphCircle' : AddCircle (2 * π) ≃ₜ circle 
goal: AddCircle (2 * π) ≃ₜ ↥circle

full_name: AddCircle.homeomorphCircle'_symm_apply
code: /-- The homeomorphism between `AddCircle (2 * π)` and `circle`. -/
@[simps] noncomputable def homeomorphCircle' : AddCircle (2 * π) ≃ₜ circle 
goal: AddCircle.homeomorphCircle'.symm x = ↑(↑x).arg

full_name: AddCircle.homeomorphCircle'_apply_mk
code: theorem homeomorphCircle'_apply_mk (x : ℝ) : homeomorphCircle' x = expMapCircle x 
goal: AddCircle.homeomorphCircle' ↑x = expMapCircle x

full_name: AddCircle.homeomorphCircle
code: /-- The homeomorphism between `AddCircle` and `circle`. -/
noncomputable def homeomorphCircle (hT : T ≠ 0) : AddCircle T ≃ₜ circle 
goal: AddCircle T ≃ₜ ↥circle

full_name: AddCircle.homeomorphCircle_apply
code: theorem homeomorphCircle_apply (hT : T ≠ 0) (x : AddCircle T) :
    homeomorphCircle hT x = toCircle x 
goal: (AddCircle.homeomorphCircle hT) x = x.toCircle

full_name: isLocalHomeomorph_expMapCircle
code: lemma isLocalHomeomorph_expMapCircle : IsLocalHomeomorph expMapCircle 
goal: IsLocalHomeomorph ⇑expMapCircle

full_name: ZMod.toCircle
code: /-- The additive character from `ZMod N` to the unit circle in `ℂ`, sending `j mod N` to
`exp (2 * π * I * j / N)`. -/
noncomputable def toCircle : AddChar (ZMod N) circle 
goal: AddChar (ZMod N) ↥circle

full_name: ZMod.toCircle_intCast
code: lemma toCircle_intCast (j : ℤ) :
    toCircle (j : ZMod N) = exp (2 * π * I * j / N) 
goal: ↑(ZMod.toCircle ↑j) = cexp (2 * ↑π * Complex.I * ↑j / ↑N)

full_name: ZMod.toCircle_natCast
code: lemma toCircle_natCast (j : ℕ) :
    toCircle (j : ZMod N) = exp (2 * π * I * j / N) 
goal: ↑(ZMod.toCircle ↑j) = cexp (2 * ↑π * Complex.I * ↑j / ↑N)

full_name: ZMod.toCircle_apply
code: /--
Explicit formula for `toCircle j`. Note that this is "evil" because it uses `ZMod.val`. Where
possible, it is recommended to lift `j` to `ℤ` and use `toCircle_intCast` instead.
-/
lemma toCircle_apply (j : ZMod N) :
    toCircle j = exp (2 * π * I * j.val / N) 
goal: ↑(ZMod.toCircle j) = cexp (2 * ↑π * Complex.I * ↑j.val / ↑N)

full_name: ZMod.stdAddChar
code: /-- The additive character from `ZMod N` to `ℂ`, sending `j mod N` to `exp (2 * π * I * j / N)`. -/
noncomputable def stdAddChar : AddChar (ZMod N) ℂ 
goal: AddChar (ZMod N) ℂ

full_name: ZMod.stdAddChar_coe
code: lemma stdAddChar_coe (j : ℤ) :
    stdAddChar (j : ZMod N) = exp (2 * π * I * j / N) 
goal: ZMod.stdAddChar ↑j = cexp (2 * ↑π * Complex.I * ↑j / ↑N)

full_name: ZMod.stdAddChar_apply
code: lemma stdAddChar_apply (j : ZMod N) : stdAddChar j = ↑(toCircle j) 
goal: ZMod.stdAddChar j = ↑(ZMod.toCircle j)