File: Mathlib/Data/ZMod/Quotient.lean

full_name: Int.quotientZMultiplesNatEquivZMod
code: /-- `ℤ` modulo multiples of `n : ℕ` is `ZMod n`. -/
def quotientZMultiplesNatEquivZMod : ℤ ⧸ AddSubgroup.zmultiples (n : ℤ) ≃+ ZMod n 
goal: ℤ ⧸ AddSubgroup.zmultiples ↑n ≃+ ZMod n

full_name: Int.quotientZMultiplesEquivZMod
code: /-- `ℤ` modulo multiples of `a : ℤ` is `ZMod a.natAbs`. -/
def quotientZMultiplesEquivZMod (a : ℤ) : ℤ ⧸ AddSubgroup.zmultiples a ≃+ ZMod a.natAbs 
goal: ℤ ⧸ AddSubgroup.zmultiples a ≃+ ZMod a.natAbs

full_name: Int.quotientSpanNatEquivZMod
code: /-- `ℤ` modulo the ideal generated by `n : ℕ` is `ZMod n`. -/
def quotientSpanNatEquivZMod : ℤ ⧸ Ideal.span {(n : ℤ)} ≃+* ZMod n 
goal: ℤ ⧸ Ideal.span {↑n} ≃+* ZMod n

full_name: Int.quotientSpanEquivZMod
code: /-- `ℤ` modulo the ideal generated by `a : ℤ` is `ZMod a.natAbs`. -/
def quotientSpanEquivZMod (a : ℤ) : ℤ ⧸ Ideal.span ({a} : Set ℤ) ≃+* ZMod a.natAbs 
goal: ℤ ⧸ Ideal.span {a} ≃+* ZMod a.natAbs

full_name: ZMod.prodEquivPi
code: /-- The **Chinese remainder theorem**, elementary version for `ZMod`. See also
`Mathlib.Data.ZMod.Basic` for versions involving only two numbers. -/
def ZMod.prodEquivPi {ι : Type*} [Fintype ι] (a : ι → ℕ)
    (coprime : Pairwise fun i j => Nat.Coprime (a i) (a j)) : ZMod (∏ i, a i) ≃+* Π i, ZMod (a i) 
goal: ZMod (∏ i : ι, a i) ≃+* ((i : ι) → ZMod (a i))

full_name: AddAction.zmultiplesQuotientStabilizerEquiv
code: /-- The quotient `(ℤ ∙ a) ⧸ (stabilizer b)` is cyclic of order `minimalPeriod (a +ᵥ ·) b`. -/
noncomputable def zmultiplesQuotientStabilizerEquiv :
    zmultiples a ⧸ stabilizer (zmultiples a) b ≃+ ZMod (minimalPeriod (a +ᵥ ·) b) 
goal: ↥(AddSubgroup.zmultiples a) ⧸ AddAction.stabilizer (↥(AddSubgroup.zmultiples a)) b ≃+
  ZMod (Function.minimalPeriod (fun x => a +ᵥ x) b)

full_name: AddAction.zmultiplesQuotientStabilizerEquiv_symm_apply
code: theorem zmultiplesQuotientStabilizerEquiv_symm_apply (n : ZMod (minimalPeriod (a +ᵥ ·) b)) :
    (zmultiplesQuotientStabilizerEquiv a b).symm n =
      (cast n : ℤ) • (⟨a, mem_zmultiples a⟩ : zmultiples a) 
goal: (AddAction.zmultiplesQuotientStabilizerEquiv a b).symm n = n.cast • ↑⟨a, ⋯⟩

full_name: MulAction.zpowersQuotientStabilizerEquiv
code: /-- The quotient `(a ^ ℤ) ⧸ (stabilizer b)` is cyclic of order `minimalPeriod ((•) a) b`. -/
noncomputable def zpowersQuotientStabilizerEquiv :
    zpowers a ⧸ stabilizer (zpowers a) b ≃* Multiplicative (ZMod (minimalPeriod (a • ·) b)) 
goal: ↥(Subgroup.zpowers a) ⧸ MulAction.stabilizer (↥(Subgroup.zpowers a)) b ≃*
  Multiplicative (ZMod (Function.minimalPeriod (fun x => a • x) b))

full_name: MulAction.zpowersQuotientStabilizerEquiv_symm_apply
code: theorem zpowersQuotientStabilizerEquiv_symm_apply (n : ZMod (minimalPeriod (a • ·) b)) :
    (zpowersQuotientStabilizerEquiv a b).symm n = (⟨a, mem_zpowers a⟩ : zpowers a) ^ (cast n : ℤ) 
goal: (MulAction.zpowersQuotientStabilizerEquiv a b).symm n = ↑⟨a, ⋯⟩ ^ n.cast

full_name: MulAction.orbitZPowersEquiv
code: /-- The orbit `(a ^ ℤ) • b` is a cycle of order `minimalPeriod ((•) a) b`. -/
noncomputable def orbitZPowersEquiv : orbit (zpowers a) b ≃ ZMod (minimalPeriod (a • ·) b) 
goal: ↑(MulAction.orbit (↥(Subgroup.zpowers a)) b) ≃ ZMod (Function.minimalPeriod (fun x => a • x) b)

full_name: AddAction.orbitZMultiplesEquiv
code: /-- The orbit `(ℤ • a) +ᵥ b` is a cycle of order `minimalPeriod (a +ᵥ ·) b`. -/
noncomputable def _root_.AddAction.orbitZMultiplesEquiv {α β : Type*} [AddGroup α] (a : α)
    [AddAction α β] (b : β) :
    AddAction.orbit (zmultiples a) b ≃ ZMod (minimalPeriod (a +ᵥ ·) b) 
goal: ↑(AddAction.orbit (↥(AddSubgroup.zmultiples a)) b) ≃ ZMod (Function.minimalPeriod (fun x => a +ᵥ x) b)

full_name: MulAction.orbitZPowersEquiv_symm_apply
code: @[to_additive]
theorem orbitZPowersEquiv_symm_apply (k : ZMod (minimalPeriod (a • ·) b)) :
    (orbitZPowersEquiv a b).symm k =
      (⟨a, mem_zpowers a⟩ : zpowers a) ^ (cast k : ℤ) • ⟨b, mem_orbit_self b⟩ 
goal: (MulAction.orbitZPowersEquiv a b).symm k = ⟨a, ⋯⟩ ^ k.cast • ⟨b, ⋯⟩

full_name: AddAction.orbitZMultiplesEquiv_symm_apply
code: @[to_additive]
theorem orbitZPowersEquiv_symm_apply (k : ZMod (minimalPeriod (a • ·) b)) :
    (orbitZPowersEquiv a b).symm k =
      (⟨a, mem_zpowers a⟩ : zpowers a) ^ (cast k : ℤ) • ⟨b, mem_orbit_self b⟩ 
goal: (AddAction.orbitZMultiplesEquiv a b).symm k = k.cast • ⟨a, ⋯⟩ +ᵥ ⟨b, ⋯⟩

full_name: MulAction.orbitZPowersEquiv_symm_apply'
code: theorem orbitZPowersEquiv_symm_apply' (k : ℤ) :
    (orbitZPowersEquiv a b).symm k =
      (⟨a, mem_zpowers a⟩ : zpowers a) ^ k • ⟨b, mem_orbit_self b⟩ 
goal: (MulAction.orbitZPowersEquiv a b).symm ↑k = ⟨a, ⋯⟩ ^ k • ⟨b, ⋯⟩

full_name: AddAction.orbitZMultiplesEquiv_symm_apply'
code: theorem _root_.AddAction.orbitZMultiplesEquiv_symm_apply' {α β : Type*} [AddGroup α] (a : α)
    [AddAction α β] (b : β) (k : ℤ) :
    (AddAction.orbitZMultiplesEquiv a b).symm k =
      k • (⟨a, mem_zmultiples a⟩ : zmultiples a) +ᵥ ⟨b, AddAction.mem_orbit_self b⟩ 
goal: (AddAction.orbitZMultiplesEquiv a b).symm ↑k = k • ⟨a, ⋯⟩ +ᵥ ⟨b, ⋯⟩

full_name: AddAction.minimalPeriod_eq_card
code: @[to_additive]
theorem minimalPeriod_eq_card [Fintype (orbit (zpowers a) b)] :
    minimalPeriod (a • ·) b = Fintype.card (orbit (zpowers a) b) 
goal: Function.minimalPeriod (fun x => a +ᵥ x) b = Fintype.card ↑(AddAction.orbit (↥(AddSubgroup.zmultiples a)) b)

full_name: MulAction.minimalPeriod_eq_card
code: @[to_additive]
theorem minimalPeriod_eq_card [Fintype (orbit (zpowers a) b)] :
    minimalPeriod (a • ·) b = Fintype.card (orbit (zpowers a) b) 
goal: Function.minimalPeriod (fun x => a • x) b = Fintype.card ↑(MulAction.orbit (↥(Subgroup.zpowers a)) b)

full_name: MulAction.minimalPeriod_pos
code: @[to_additive]
instance minimalPeriod_pos [Finite <| orbit (zpowers a) b] :
    NeZero <| minimalPeriod (a • ·) b 
goal: NeZero (Function.minimalPeriod (fun x => a • x) b)

full_name: AddAction.minimalPeriod_pos
code: @[to_additive]
instance minimalPeriod_pos [Finite <| orbit (zpowers a) b] :
    NeZero <| minimalPeriod (a • ·) b 
goal: NeZero (Function.minimalPeriod (fun x => a +ᵥ x) b)

full_name: Nat.card_zpowers
code: /-- See also `Fintype.card_zpowers`. -/
@[to_additive (attr := simp) "See also `Fintype.card_zmultiples`."]
theorem Nat.card_zpowers : Nat.card (zpowers a) = orderOf a 
goal: Nat.card ↥(Subgroup.zpowers a) = orderOf a

full_name: Nat.card_zmultiples
code: /-- See also `Fintype.card_zpowers`. -/
@[to_additive (attr := simp) "See also `Fintype.card_zmultiples`."]
theorem Nat.card_zpowers : Nat.card (zpowers a) = orderOf a 
goal: Nat.card ↥(AddSubgroup.zmultiples a) = addOrderOf a

full_name: finite_zmultiples
code: @[to_additive (attr := simp)]
lemma finite_zpowers : (zpowers a : Set α).Finite ↔ IsOfFinOrder a 
goal: (↑(AddSubgroup.zmultiples a)).Finite ↔ IsOfFinAddOrder a

full_name: finite_zpowers
code: @[to_additive (attr := simp)]
lemma finite_zpowers : (zpowers a : Set α).Finite ↔ IsOfFinOrder a 
goal: (↑(Subgroup.zpowers a)).Finite ↔ IsOfFinOrder a

full_name: infinite_zpowers
code: @[to_additive (attr := simp)]
lemma infinite_zpowers : (zpowers a : Set α).Infinite ↔ ¬IsOfFinOrder a 
goal: (↑(Subgroup.zpowers a)).Infinite ↔ ¬IsOfFinOrder a

full_name: infinite_zmultiples
code: @[to_additive (attr := simp)]
lemma infinite_zpowers : (zpowers a : Set α).Infinite ↔ ¬IsOfFinOrder a 
goal: (↑(AddSubgroup.zmultiples a)).Infinite ↔ ¬IsOfFinAddOrder a