Module docstring
{"# Characteristic zero rings "}
{"# Characteristic zero rings "}
Nat.castEmbedding
      definition
     : ℕ ↪ R
        /-- `Nat.cast` as an embedding into monoids of characteristic `0`. -/
@[simps]
def Nat.castEmbedding : ℕℕ ↪ R := ⟨Nat.cast, cast_injective⟩
        CharZero.NeZero.two
      instance
     : NeZero (2 : R)
        instance CharZero.NeZero.two : NeZero (2 : R) where
  out := by rw [← Nat.cast_two, Nat.cast_ne_zero]; decide
        Function.support_natCast
      theorem
     (hn : n ≠ 0) : support (n : α → R) = univ
        lemma support_natCast (hn : n ≠ 0) : support (n : α → R) = univ :=
  support_const <| Nat.cast_ne_zero.2 hn
        Function.mulSupport_natCast
      theorem
     (hn : n ≠ 1) : mulSupport (n : α → R) = univ
        lemma mulSupport_natCast (hn : n ≠ 1) : mulSupport (n : α → R) = univ :=
  mulSupport_const <| Nat.cast_ne_one.2 hn
        RingHom.charZero
      theorem
     (ϕ : R →+* S) [CharZero S] : CharZero R
        lemma charZero (ϕ : R →+* S) [CharZero S] : CharZero R where
  cast_injective a b h := CharZero.cast_injective (R := S) <| by
    rw [← map_natCast ϕ, ← map_natCast ϕ, h]
        RingHom.charZero_iff
      theorem
     {ϕ : R →+* S} (hϕ : Injective ϕ) : CharZero R ↔ CharZero S
        
      RingHom.injective_nat
      theorem
     (f : ℕ →+* R) [CharZero R] : Injective f
        lemma injective_nat (f : ℕℕ →+* R) [CharZero R] : Injective f :=
  Subsingleton.elim (Nat.castRingHom _) f ▸ Nat.cast_injective
        add_self_eq_zero
      theorem
     {a : R} : a + a = 0 ↔ a = 0
        @[simp]
theorem add_self_eq_zero {a : R} : a + a = 0 ↔ a = 0 := by
  simp only [(two_mul a).symm, mul_eq_zero, two_ne_zero, false_or]
        Nat.cast_pow_eq_one
      theorem
     {a : ℕ} (hn : n ≠ 0) : (a : R) ^ n = 1 ↔ a = 1
        @[simp] lemma Nat.cast_pow_eq_one {a : ℕ} (hn : n ≠ 0) : (a : R) ^ n = 1 ↔ a = 1 := by
  simp [← cast_pow, cast_eq_one, hn]
        CharZero.neg_eq_self_iff
      theorem
     {a : R} : -a = a ↔ a = 0
        @[scoped simp] theorem CharZero.neg_eq_self_iff {a : R} : -a = a ↔ a = 0 :=
  neg_eq_iff_add_eq_zero.trans add_self_eq_zero
        nat_mul_inj
      theorem
     {n : ℕ} {a b : R} (h : (n : R) * a = (n : R) * b) : n = 0 ∨ a = b
        theorem nat_mul_inj {n : ℕ} {a b : R} (h : (n : R) * a = (n : R) * b) : n = 0 ∨ a = b := by
  rw [← sub_eq_zero, ← mul_sub, mul_eq_zero, sub_eq_zero] at h
  exact mod_cast h
        nat_mul_inj'
      theorem
     {n : ℕ} {a b : R} (h : (n : R) * a = (n : R) * b) (w : n ≠ 0) : a = b
        theorem nat_mul_inj' {n : ℕ} {a b : R} (h : (n : R) * a = (n : R) * b) (w : n ≠ 0) : a = b := by
  simpa [w] using nat_mul_inj h
        units_ne_neg_self
      theorem
     (u : Rˣ) : u ≠ -u
        @[simp]
theorem units_ne_neg_self (u : Rˣ) : u ≠ -u := by
  simp_rw [ne_eq, Units.ext_iff, Units.val_neg, eq_neg_iff_add_eq_zero, ← two_mul,
    Units.mul_left_eq_zero, two_ne_zero, not_false_iff]
        neg_units_ne_self
      theorem
     (u : Rˣ) : -u ≠ u
        @[simp]
theorem neg_units_ne_self (u : Rˣ) : -u ≠ u := (units_ne_neg_self u).symm