File: Mathlib/Topology/Instances/AddCircle.lean

full_name: continuous_right_toIcoMod
code: theorem continuous_right_toIcoMod : ContinuousWithinAt (toIcoMod hp a) (Ici x) x 
goal: ContinuousWithinAt (toIcoMod hp a) (Set.Ici x) x

full_name: continuous_left_toIocMod
code: theorem continuous_left_toIocMod : ContinuousWithinAt (toIocMod hp a) (Iic x) x 
goal: ContinuousWithinAt (toIocMod hp a) (Set.Iic x) x

full_name: toIcoMod_eventuallyEq_toIocMod
code: theorem toIcoMod_eventuallyEq_toIocMod : toIcoMod hp a =ᶠ[𝓝 x] toIocMod hp a 
goal: toIcoMod hp a =ᶠ[𝓝 x] toIocMod hp a

full_name: continuousAt_toIcoMod
code: theorem continuousAt_toIcoMod : ContinuousAt (toIcoMod hp a) x 
goal: ContinuousAt (toIcoMod hp a) x

full_name: continuousAt_toIocMod
code: theorem continuousAt_toIocMod : ContinuousAt (toIocMod hp a) x 
goal: ContinuousAt (toIocMod hp a) x

full_name: AddCircle
code: /-- The "additive circle": `𝕜 ⧸ (ℤ ∙ p)`. See also `Circle` and `Real.angle`. -/
@[nolint unusedArguments]
abbrev AddCircle [LinearOrderedAddCommGroup 𝕜] [TopologicalSpace 𝕜] [OrderTopology 𝕜] (p : 𝕜) 
goal: Type u_1

full_name: AddCircle.coe_nsmul
code: theorem coe_nsmul {n : ℕ} {x : 𝕜} : (↑(n • x) : AddCircle p) = n • (x : AddCircle p) 
goal: ↑(n • x) = n • ↑x

full_name: AddCircle.coe_zsmul
code: theorem coe_zsmul {n : ℤ} {x : 𝕜} : (↑(n • x) : AddCircle p) = n • (x : AddCircle p) 
goal: ↑(n • x) = n • ↑x

full_name: AddCircle.coe_add
code: theorem coe_add (x y : 𝕜) : (↑(x + y) : AddCircle p) = (x : AddCircle p) + (y : AddCircle p) 
goal: ↑(x + y) = ↑x + ↑y

full_name: AddCircle.coe_sub
code: theorem coe_sub (x y : 𝕜) : (↑(x - y) : AddCircle p) = (x : AddCircle p) - (y : AddCircle p) 
goal: ↑(x - y) = ↑x - ↑y

full_name: AddCircle.coe_neg
code: theorem coe_neg {x : 𝕜} : (↑(-x) : AddCircle p) = -(x : AddCircle p) 
goal: ↑(-x) = -↑x

full_name: AddCircle.coe_eq_zero_iff
code: theorem coe_eq_zero_iff {x : 𝕜} : (x : AddCircle p) = 0 ↔ ∃ n : ℤ, n • p = x 
goal: ↑x = 0 ↔ ∃ n, n • p = x

full_name: AddCircle.coe_eq_zero_of_pos_iff
code: theorem coe_eq_zero_of_pos_iff (hp : 0 < p) {x : 𝕜} (hx : 0 < x) :
    (x : AddCircle p) = 0 ↔ ∃ n : ℕ, n • p = x 
goal: ↑x = 0 ↔ ∃ n, n • p = x

full_name: AddCircle.coe_period
code: theorem coe_period : (p : AddCircle p) = 0 
goal: ↑p = 0

full_name: AddCircle.coe_add_period
code: theorem coe_add_period (x : 𝕜) : ((x + p : 𝕜) : AddCircle p) = x 
goal: ↑(x + p) = ↑x

full_name: AddCircle.continuous_mk'
code: @[continuity, nolint unusedArguments]
protected theorem continuous_mk' :
    Continuous (QuotientAddGroup.mk' (zmultiples p) : 𝕜 → AddCircle p) 
goal: Continuous ⇑(QuotientAddGroup.mk' (AddSubgroup.zmultiples p))

full_name: AddCircle.equivIco
code: /-- The equivalence between `AddCircle p` and the half-open interval `[a, a + p)`, whose inverse
is the natural quotient map. -/
def equivIco : AddCircle p ≃ Ico a (a + p) 
goal: AddCircle p ≃ ↑(Set.Ico a (a + p))

full_name: AddCircle.equivIoc
code: /-- The equivalence between `AddCircle p` and the half-open interval `(a, a + p]`, whose inverse
is the natural quotient map. -/
def equivIoc : AddCircle p ≃ Ioc a (a + p) 
goal: AddCircle p ≃ ↑(Set.Ioc a (a + p))

full_name: AddCircle.liftIco
code: /-- Given a function on `𝕜`, return the unique function on `AddCircle p` agreeing with `f` on
`[a, a + p)`. -/
def liftIco (f : 𝕜 → B) : AddCircle p → B 
goal: AddCircle p → B

full_name: AddCircle.liftIoc
code: /-- Given a function on `𝕜`, return the unique function on `AddCircle p` agreeing with `f` on
`(a, a + p]`. -/
def liftIoc (f : 𝕜 → B) : AddCircle p → B 
goal: AddCircle p → B

full_name: AddCircle.coe_eq_coe_iff_of_mem_Ico
code: theorem coe_eq_coe_iff_of_mem_Ico {x y : 𝕜} (hx : x ∈ Ico a (a + p)) (hy : y ∈ Ico a (a + p)) :
    (x : AddCircle p) = y ↔ x = y 
goal: ↑x = ↑y ↔ x = y

full_name: AddCircle.liftIco_coe_apply
code: theorem liftIco_coe_apply {f : 𝕜 → B} {x : 𝕜} (hx : x ∈ Ico a (a + p)) :
    liftIco p a f ↑x = f x 
goal: AddCircle.liftIco p a f ↑x = f x

full_name: AddCircle.liftIoc_coe_apply
code: theorem liftIoc_coe_apply {f : 𝕜 → B} {x : 𝕜} (hx : x ∈ Ioc a (a + p)) :
    liftIoc p a f ↑x = f x 
goal: AddCircle.liftIoc p a f ↑x = f x

full_name: AddCircle.eq_coe_Ico
code: lemma eq_coe_Ico (a : AddCircle p) : ∃ b, b ∈ Ico 0 p ∧ ↑b = a 
goal: ∃ b ∈ Set.Ico 0 p, ↑b = a

full_name: AddCircle.coe_eq_zero_iff_of_mem_Ico
code: lemma coe_eq_zero_iff_of_mem_Ico (ha : a ∈ Ico 0 p) :
    (a : AddCircle p) = 0 ↔ a = 0 
goal: ↑a = 0 ↔ a = 0

full_name: AddCircle.continuous_equivIco_symm
code: @[continuity]
theorem continuous_equivIco_symm : Continuous (equivIco p a).symm 
goal: Continuous ⇑(AddCircle.equivIco p a).symm

full_name: AddCircle.continuous_equivIoc_symm
code: @[continuity]
theorem continuous_equivIoc_symm : Continuous (equivIoc p a).symm 
goal: Continuous ⇑(AddCircle.equivIoc p a).symm

full_name: AddCircle.continuousAt_equivIco
code: theorem continuousAt_equivIco : ContinuousAt (equivIco p a) x 
goal: ContinuousAt (⇑(AddCircle.equivIco p a)) x

full_name: AddCircle.continuousAt_equivIoc
code: theorem continuousAt_equivIoc : ContinuousAt (equivIoc p a) x 
goal: ContinuousAt (⇑(AddCircle.equivIoc p a)) x

full_name: AddCircle.partialHomeomorphCoe_target
code: /-- The quotient map `𝕜 → AddCircle p` as a partial homeomorphism. -/
@[simps] def partialHomeomorphCoe [DiscreteTopology (zmultiples p)] :
    PartialHomeomorph 𝕜 (AddCircle p) 
goal: (AddCircle.partialHomeomorphCoe p a).target = {↑a}ᶜ

full_name: AddCircle.partialHomeomorphCoe_symm_apply
code: /-- The quotient map `𝕜 → AddCircle p` as a partial homeomorphism. -/
@[simps] def partialHomeomorphCoe [DiscreteTopology (zmultiples p)] :
    PartialHomeomorph 𝕜 (AddCircle p) 
goal: ↑(AddCircle.partialHomeomorphCoe p a).symm x = ↑((AddCircle.equivIco p a) x)

full_name: AddCircle.partialHomeomorphCoe_source
code: /-- The quotient map `𝕜 → AddCircle p` as a partial homeomorphism. -/
@[simps] def partialHomeomorphCoe [DiscreteTopology (zmultiples p)] :
    PartialHomeomorph 𝕜 (AddCircle p) 
goal: (AddCircle.partialHomeomorphCoe p a).source = Set.Ioo a (a + p)

full_name: AddCircle.partialHomeomorphCoe
code: /-- The quotient map `𝕜 → AddCircle p` as a partial homeomorphism. -/
@[simps] def partialHomeomorphCoe [DiscreteTopology (zmultiples p)] :
    PartialHomeomorph 𝕜 (AddCircle p) 
goal: PartialHomeomorph 𝕜 (AddCircle p)

full_name: AddCircle.partialHomeomorphCoe_apply
code: /-- The quotient map `𝕜 → AddCircle p` as a partial homeomorphism. -/
@[simps] def partialHomeomorphCoe [DiscreteTopology (zmultiples p)] :
    PartialHomeomorph 𝕜 (AddCircle p) 
goal: ∀ (a_1 : 𝕜), ↑(AddCircle.partialHomeomorphCoe p a) a_1 = ↑a_1

full_name: AddCircle.isLocalHomeomorph_coe
code: lemma isLocalHomeomorph_coe [DiscreteTopology (zmultiples p)] [DenselyOrdered 𝕜] :
    IsLocalHomeomorph ((↑) : 𝕜 → AddCircle p) 
goal: IsLocalHomeomorph QuotientAddGroup.mk

full_name: AddCircle.coe_image_Ico_eq
code: /-- The image of the closed-open interval `[a, a + p)` under the quotient map `𝕜 → AddCircle p` is
the entire space. -/
@[simp]
theorem coe_image_Ico_eq : ((↑) : 𝕜 → AddCircle p) '' Ico a (a + p) = univ 
goal: QuotientAddGroup.mk '' Set.Ico a (a + p) = Set.univ

full_name: AddCircle.coe_image_Ioc_eq
code: /-- The image of the closed-open interval `[a, a + p)` under the quotient map `𝕜 → AddCircle p` is
the entire space. -/
@[simp]
theorem coe_image_Ioc_eq : ((↑) : 𝕜 → AddCircle p) '' Ioc a (a + p) = univ 
goal: QuotientAddGroup.mk '' Set.Ioc a (a + p) = Set.univ

full_name: AddCircle.coe_image_Icc_eq
code: /-- The image of the closed interval `[0, p]` under the quotient map `𝕜 → AddCircle p` is the
entire space. -/
@[simp]
theorem coe_image_Icc_eq : ((↑) : 𝕜 → AddCircle p) '' Icc a (a + p) = univ 
goal: QuotientAddGroup.mk '' Set.Icc a (a + p) = Set.univ

full_name: AddCircle.equivAddCircle
code: /-- The rescaling equivalence between additive circles with different periods. -/
def equivAddCircle (hp : p ≠ 0) (hq : q ≠ 0) : AddCircle p ≃+ AddCircle q 
goal: AddCircle p ≃+ AddCircle q

full_name: AddCircle.equivAddCircle_apply_mk
code: @[simp]
theorem equivAddCircle_apply_mk (hp : p ≠ 0) (hq : q ≠ 0) (x : 𝕜) :
    equivAddCircle p q hp hq (x : 𝕜) = (x * (p⁻¹ * q) : 𝕜) 
goal: (AddCircle.equivAddCircle p q hp hq) ↑x = ↑(x * (p⁻¹ * q))

full_name: AddCircle.equivAddCircle_symm_apply_mk
code: @[simp]
theorem equivAddCircle_symm_apply_mk (hp : p ≠ 0) (hq : q ≠ 0) (x : 𝕜) :
    (equivAddCircle p q hp hq).symm (x : 𝕜) = (x * (q⁻¹ * p) : 𝕜) 
goal: (AddCircle.equivAddCircle p q hp hq).symm ↑x = ↑(x * (q⁻¹ * p))

full_name: AddCircle.homeomorphAddCircle
code: /-- The rescaling homeomorphism between additive circles with different periods. -/
def homeomorphAddCircle (hp : p ≠ 0) (hq : q ≠ 0) : AddCircle p ≃ₜ AddCircle q 
goal: AddCircle p ≃ₜ AddCircle q

full_name: AddCircle.homeomorphAddCircle_apply_mk
code: @[simp]
theorem homeomorphAddCircle_apply_mk (hp : p ≠ 0) (hq : q ≠ 0) (x : 𝕜) :
    homeomorphAddCircle p q hp hq (x : 𝕜) = (x * (p⁻¹ * q) : 𝕜) 
goal: (AddCircle.homeomorphAddCircle p q hp hq) ↑x = ↑(x * (p⁻¹ * q))

full_name: AddCircle.homeomorphAddCircle_symm_apply_mk
code: @[simp]
theorem homeomorphAddCircle_symm_apply_mk (hp : p ≠ 0) (hq : q ≠ 0) (x : 𝕜) :
    (homeomorphAddCircle p q hp hq).symm (x : 𝕜) = (x * (q⁻¹ * p) : 𝕜) 
goal: (AddCircle.homeomorphAddCircle p q hp hq).symm ↑x = ↑(x * (q⁻¹ * p))

full_name: AddCircle.coe_equivIco_mk_apply
code: @[simp]
theorem coe_equivIco_mk_apply (x : 𝕜) :
    (equivIco p 0 <| QuotientAddGroup.mk x : 𝕜) = Int.fract (x / p) * p 
goal: ↑((AddCircle.equivIco p 0) ↑x) = Int.fract (x / p) * p

full_name: AddCircle.instDivisibleByInt
code: instance : DivisibleBy (AddCircle p) ℤ 
goal: DivisibleBy (AddCircle p) ℤ

full_name: AddCircle.addOrderOf_period_div
code: theorem addOrderOf_period_div {n : ℕ} (h : 0 < n) : addOrderOf ((p / n : 𝕜) : AddCircle p) = n 
goal: addOrderOf ↑(p / ↑n) = n

full_name: AddCircle.gcd_mul_addOrderOf_div_eq
code: theorem gcd_mul_addOrderOf_div_eq {n : ℕ} (m : ℕ) (hn : 0 < n) :
    m.gcd n * addOrderOf (↑(↑m / ↑n * p) : AddCircle p) = n 
goal: m.gcd n * addOrderOf ↑(↑m / ↑n * p) = n

full_name: AddCircle.addOrderOf_div_of_gcd_eq_one
code: theorem addOrderOf_div_of_gcd_eq_one {m n : ℕ} (hn : 0 < n) (h : m.gcd n = 1) :
    addOrderOf (↑(↑m / ↑n * p) : AddCircle p) = n 
goal: addOrderOf ↑(↑m / ↑n * p) = n

full_name: AddCircle.addOrderOf_div_of_gcd_eq_one'
code: theorem addOrderOf_div_of_gcd_eq_one' {m : ℤ} {n : ℕ} (hn : 0 < n) (h : m.natAbs.gcd n = 1) :
    addOrderOf (↑(↑m / ↑n * p) : AddCircle p) = n 
goal: addOrderOf ↑(↑m / ↑n * p) = n

full_name: AddCircle.addOrderOf_coe_rat
code: theorem addOrderOf_coe_rat {q : ℚ} : addOrderOf (↑(↑q * p) : AddCircle p) = q.den 
goal: addOrderOf ↑(↑q * p) = q.den

full_name: AddCircle.addOrderOf_eq_pos_iff
code: theorem addOrderOf_eq_pos_iff {u : AddCircle p} {n : ℕ} (h : 0 < n) :
    addOrderOf u = n ↔ ∃ m < n, m.gcd n = 1 ∧ ↑(↑m / ↑n * p) = u 
goal: addOrderOf u = n ↔ ∃ m < n, m.gcd n = 1 ∧ ↑(↑m / ↑n * p) = u

full_name: AddCircle.exists_gcd_eq_one_of_isOfFinAddOrder
code: theorem exists_gcd_eq_one_of_isOfFinAddOrder {u : AddCircle p} (h : IsOfFinAddOrder u) :
    ∃ m : ℕ, m.gcd (addOrderOf u) = 1 ∧ m < addOrderOf u ∧ ↑((m : 𝕜) / addOrderOf u * p) = u 
goal: ∃ m, m.gcd (addOrderOf u) = 1 ∧ m < addOrderOf u ∧ ↑(↑m / ↑(addOrderOf u) * p) = u

full_name: AddCircle.setAddOrderOfEquiv
code: /-- The natural bijection between points of order `n` and natural numbers less than and coprime to
`n`. The inverse of the map sends `m ↦ (m/n * p : AddCircle p)` where `m` is coprime to `n` and
satisfies `0 ≤ m < n`. -/
def setAddOrderOfEquiv {n : ℕ} (hn : 0 < n) :
    { u : AddCircle p | addOrderOf u = n } ≃ { m | m < n ∧ m.gcd n = 1 } 
goal: ↑{u | addOrderOf u = n} ≃ ↑{m | m < n ∧ m.gcd n = 1}

full_name: AddCircle.card_addOrderOf_eq_totient
code: @[simp]
theorem card_addOrderOf_eq_totient {n : ℕ} :
    Nat.card { u : AddCircle p // addOrderOf u = n } = n.totient 
goal: Nat.card { u // addOrderOf u = n } = n.totient

full_name: AddCircle.finite_setOf_add_order_eq
code: theorem finite_setOf_add_order_eq {n : ℕ} (hn : 0 < n) :
    { u : AddCircle p | addOrderOf u = n }.Finite 
goal: {u | addOrderOf u = n}.Finite

full_name: AddCircle.pathConnectedSpace
code: instance pathConnectedSpace : PathConnectedSpace <| AddCircle p 
goal: PathConnectedSpace (AddCircle p)

full_name: AddCircle.compactSpace
code: /-- The "additive circle" `ℝ ⧸ (ℤ ∙ p)` is compact. -/
instance compactSpace [Fact (0 < p)] : CompactSpace <| AddCircle p 
goal: CompactSpace (AddCircle p)

full_name: AddCircle.instProperlyDiscontinuousVAddSubtypeAddOppositeRealMemAddSubgroupOpZmultiples
code: /-- The action on `ℝ` by right multiplication of its the subgroup `zmultiples p` (the multiples of
`p:ℝ`) is properly discontinuous. -/
instance : ProperlyDiscontinuousVAdd (zmultiples p).op ℝ 
goal: ProperlyDiscontinuousVAdd ↥(AddSubgroup.zmultiples p).op ℝ

full_name: instZeroLTOne
code: instance instZeroLTOne [StrictOrderedSemiring 𝕜] : Fact ((0 : 𝕜) < 1) 
goal: Fact (0 < 1)

full_name: UnitAddCircle
code: /-- The unit circle `ℝ ⧸ ℤ`. -/
abbrev UnitAddCircle 
goal: Type

full_name: AddCircle._aux_Mathlib_Topology_Instances_AddCircle___unexpand_AddCircle_1
code: local notation "𝕋" => AddCircle p
goal: Lean.PrettyPrinter.Unexpander

full_name: AddCircle._aux_Mathlib_Topology_Instances_AddCircle___macroRules_AddCircle_term𝕋_1
code: local notation "𝕋" => AddCircle p
goal: Lean.Macro

full_name: AddCircle.EndpointIdent
code: /-- The relation identifying the endpoints of `Icc a (a + p)`. -/
inductive EndpointIdent : Icc a (a + p) → Icc a (a + p) → Prop
  | mk :
    EndpointIdent ⟨a, left_mem_Icc.mpr <| le_add_of_nonneg_right hp.out.le⟩
      ⟨a + p, right_mem_Icc.mpr <| le_add_of_nonneg_right hp.out.le⟩
goal: ↑(Set.Icc a (a + p)) → ↑(Set.Icc a (a + p)) → Prop

full_name: AddCircle.EndpointIdent.mk
code: /-- The relation identifying the endpoints of `Icc a (a + p)`. -/
inductive EndpointIdent : Icc a (a + p) → Icc a (a + p) → Prop
  | mk :
    EndpointIdent ⟨a, left_mem_Icc.mpr <| le_add_of_nonneg_right hp.out.le⟩
      ⟨a + p, right_mem_Icc.mpr <| le_add_of_nonneg_right hp.out.le⟩
goal: AddCircle.EndpointIdent p a ⟨a, ⋯⟩ ⟨a + p, ⋯⟩

full_name: AddCircle.equivIccQuot
code: /-- The equivalence between `AddCircle p` and the quotient of `[a, a + p]` by the relation
identifying the endpoints. -/
def equivIccQuot : 𝕋 ≃ Quot (EndpointIdent p a) 
goal: AddCircle p ≃ Quot (AddCircle.EndpointIdent p a)

full_name: AddCircle.equivIccQuot_comp_mk_eq_toIcoMod
code: theorem equivIccQuot_comp_mk_eq_toIcoMod :
    equivIccQuot p a ∘ Quotient.mk'' = fun x =>
      Quot.mk _ ⟨toIcoMod hp.out a x, Ico_subset_Icc_self <| toIcoMod_mem_Ico _ _ x⟩ 
goal: ⇑(AddCircle.equivIccQuot p a) ∘ Quotient.mk'' = fun x => Quot.mk (AddCircle.EndpointIdent p a) ⟨toIcoMod ⋯ a x, ⋯⟩

full_name: AddCircle.equivIccQuot_comp_mk_eq_toIocMod
code: theorem equivIccQuot_comp_mk_eq_toIocMod :
    equivIccQuot p a ∘ Quotient.mk'' = fun x =>
      Quot.mk _ ⟨toIocMod hp.out a x, Ioc_subset_Icc_self <| toIocMod_mem_Ioc _ _ x⟩ 
goal: ⇑(AddCircle.equivIccQuot p a) ∘ Quotient.mk'' = fun x => Quot.mk (AddCircle.EndpointIdent p a) ⟨toIocMod ⋯ a x, ⋯⟩

full_name: AddCircle.homeoIccQuot
code: /-- The natural map from `[a, a + p] ⊂ 𝕜` with endpoints identified to `𝕜 / ℤ • p`, as a
homeomorphism of topological spaces. -/
def homeoIccQuot : 𝕋 ≃ₜ Quot (EndpointIdent p a) 
goal: AddCircle p ≃ₜ Quot (AddCircle.EndpointIdent p a)

full_name: AddCircle.liftIco_eq_lift_Icc
code: theorem liftIco_eq_lift_Icc {f : 𝕜 → B} (h : f a = f (a + p)) :
    liftIco p a f =
      Quot.lift (restrict (Icc a <| a + p) f)
          (by
            rintro _ _ ⟨_⟩
            exact h) ∘
        equivIccQuot p a 
goal: AddCircle.liftIco p a f = Quot.lift ((Set.Icc a (a + p)).restrict f) ⋯ ∘ ⇑(AddCircle.equivIccQuot p a)

full_name: AddCircle.liftIco_continuous
code: theorem liftIco_continuous [TopologicalSpace B] {f : 𝕜 → B} (hf : f a = f (a + p))
    (hc : ContinuousOn f <| Icc a (a + p)) : Continuous (liftIco p a f) 
goal: Continuous (AddCircle.liftIco p a f)

full_name: AddCircle.liftIco_zero_coe_apply
code: theorem liftIco_zero_coe_apply {f : 𝕜 → B} {x : 𝕜} (hx : x ∈ Ico 0 p) : liftIco p 0 f ↑x = f x 
goal: AddCircle.liftIco p 0 f ↑x = f x

full_name: AddCircle.liftIco_zero_continuous
code: theorem liftIco_zero_continuous [TopologicalSpace B] {f : 𝕜 → B} (hf : f 0 = f p)
    (hc : ContinuousOn f <| Icc 0 p) : Continuous (liftIco p 0 f) 
goal: Continuous (AddCircle.liftIco p 0 f)

full_name: ZMod.toAddCircle
code: /-- The `AddMonoidHom` from `ZMod N` to `ℝ / ℤ` sending `j mod N` to `j / N mod 1`. -/
noncomputable def toAddCircle : ZMod N →+ UnitAddCircle 
goal: ZMod N →+ UnitAddCircle

full_name: ZMod.toAddCircle_intCast
code: lemma toAddCircle_intCast (j : ℤ) :
    toAddCircle (j : ZMod N) = ↑(j / N : ℝ) 
goal: ZMod.toAddCircle ↑j = ↑(↑j / ↑N)

full_name: ZMod.toAddCircle_natCast
code: lemma toAddCircle_natCast (j : ℕ) :
    toAddCircle (j : ZMod N) = ↑(j / N : ℝ) 
goal: ZMod.toAddCircle ↑j = ↑(↑j / ↑N)

full_name: ZMod.toAddCircle_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 `toAddCircle_intCast` instead.
-/
lemma toAddCircle_apply (j : ZMod N) :
    toAddCircle j = ↑(j.val / N : ℝ) 
goal: ZMod.toAddCircle j = ↑(↑j.val / ↑N)

full_name: ZMod.toAddCircle_injective
code: lemma toAddCircle_injective : Function.Injective (toAddCircle : ZMod N → _) 
goal: Function.Injective ⇑ZMod.toAddCircle

full_name: ZMod.toAddCircle_inj
code: @[simp] lemma toAddCircle_inj {j k : ZMod N} : toAddCircle j = toAddCircle k ↔ j = k 
goal: ZMod.toAddCircle j = ZMod.toAddCircle k ↔ j = k

full_name: ZMod.toAddCircle_eq_zero
code: @[simp] lemma toAddCircle_eq_zero {j : ZMod N} : toAddCircle j = 0 ↔ j = 0 
goal: ZMod.toAddCircle j = 0 ↔ j = 0