File: Mathlib/RingTheory/AdicCompletion/Algebra.lean

full_name: AdicCompletion.transitionMap_ideal_mk
code: @[local simp]
theorem transitionMap_ideal_mk {m n : ℕ} (hmn : m ≤ n) (x : R) :
    transitionMap I R hmn (Ideal.Quotient.mk (I ^ n • ⊤ : Ideal R) x) =
      Ideal.Quotient.mk (I ^ m • ⊤ : Ideal R) x 
goal: (AdicCompletion.transitionMap I R hmn) ((Ideal.Quotient.mk (I ^ n • ⊤)) x) = (Ideal.Quotient.mk (I ^ m • ⊤)) x

full_name: AdicCompletion.transitionMap_map_one
code: @[local simp]
theorem transitionMap_map_one {m n : ℕ} (hmn : m ≤ n) : transitionMap I R hmn 1 = 1 
goal: (AdicCompletion.transitionMap I R hmn) 1 = 1

full_name: AdicCompletion.transitionMap_map_mul
code: @[local simp]
theorem transitionMap_map_mul {m n : ℕ} (hmn : m ≤ n) (x y : R ⧸ (I ^ n • ⊤ : Ideal R)) :
    transitionMap I R hmn (x * y) = transitionMap I R hmn x * transitionMap I R hmn y 
goal: (AdicCompletion.transitionMap I R hmn) (x * y) =
  (AdicCompletion.transitionMap I R hmn) x * (AdicCompletion.transitionMap I R hmn) y

full_name: AdicCompletion.transitionMap_map_pow
code: @[local simp]
theorem transitionMap_map_pow {m n a : ℕ} (hmn : m ≤ n) (x : R ⧸ (I ^ n • ⊤ : Ideal R)) :
    transitionMap I R hmn (x ^ a) = transitionMap I R hmn x ^ a 
goal: (AdicCompletion.transitionMap I R hmn) (x ^ a) = (AdicCompletion.transitionMap I R hmn) x ^ a

full_name: AdicCompletion.transitionMapₐ
code: /-- `AdicCompletion.transitionMap` as an algebra homomorphism. -/
def transitionMapₐ {m n : ℕ} (hmn : m ≤ n) :
    R ⧸ (I ^ n • ⊤ : Ideal R) →ₐ[R] R ⧸ (I ^ m • ⊤ : Ideal R) 
goal: R ⧸ I ^ n • ⊤ →ₐ[R] R ⧸ I ^ m • ⊤

full_name: AdicCompletion.subalgebra
code: /-- `AdicCompletion I R` is an `R`-subalgebra of `∀ n, R ⧸ (I ^ n • ⊤ : Ideal R)`. -/
def subalgebra : Subalgebra R (∀ n, R ⧸ (I ^ n • ⊤ : Ideal R)) 
goal: Subalgebra R ((n : ℕ) → R ⧸ I ^ n • ⊤)

full_name: AdicCompletion.subring
code: /-- `AdicCompletion I R` is a subring of `∀ n, R ⧸ (I ^ n • ⊤ : Ideal R)`. -/
def subring : Subring (∀ n, R ⧸ (I ^ n • ⊤ : Ideal R)) 
goal: Subring ((n : ℕ) → R ⧸ I ^ n • ⊤)

full_name: AdicCompletion.instMul
code: instance : Mul (AdicCompletion I R) 
goal: Mul (AdicCompletion I R)

full_name: AdicCompletion.instOne
code: instance : One (AdicCompletion I R) 
goal: One (AdicCompletion I R)

full_name: AdicCompletion.instNatCast
code: instance : NatCast (AdicCompletion I R) 
goal: NatCast (AdicCompletion I R)

full_name: AdicCompletion.instIntCast
code: instance : IntCast (AdicCompletion I R) 
goal: IntCast (AdicCompletion I R)

full_name: AdicCompletion.instPowNat
code: instance : Pow (AdicCompletion I R) ℕ 
goal: Pow (AdicCompletion I R) ℕ

full_name: AdicCompletion.instCommRing
code: instance : CommRing (AdicCompletion I R) 
goal: CommRing (AdicCompletion I R)

full_name: AdicCompletion.instAlgebra
code: instance : Algebra R (AdicCompletion I R) 
goal: Algebra R (AdicCompletion I R)

full_name: AdicCompletion.val_one
code: @[simp]
theorem val_one (n : ℕ) : (1 : AdicCompletion I R).val n = 1 
goal: ↑1 n = 1

full_name: AdicCompletion.val_mul
code: @[simp]
theorem val_mul (n : ℕ) (x y : AdicCompletion I R) : (x * y).val n = x.val n * y.val n 
goal: ↑(x * y) n = ↑x n * ↑y n

full_name: AdicCompletion.evalₐ
code: /-- The canonical algebra map from the adic completion to `R ⧸ I ^ n`.

This is `AdicCompletion.eval` postcomposed with the algebra isomorphism
`R ⧸ (I ^ n • ⊤) ≃ₐ[R] R ⧸ I ^ n`. -/
def evalₐ (n : ℕ) : AdicCompletion I R →ₐ[R] R ⧸ I ^ n 
goal: AdicCompletion I R →ₐ[R] R ⧸ I ^ n

full_name: AdicCompletion.evalₐ_mk
code: @[simp]
theorem evalₐ_mk (n : ℕ) (x : AdicCauchySequence I R) :
    evalₐ I n (mk I R x) = Ideal.Quotient.mk (I ^ n) (x.val n) 
goal: (AdicCompletion.evalₐ I n) ((AdicCompletion.mk I R) x) = (Ideal.Quotient.mk (I ^ n)) (↑x n)

full_name: AdicCompletion.AdicCauchySequence.subalgebra
code: /-- `AdicCauchySequence I R` is an `R`-subalgebra of `ℕ → R`. -/
def AdicCauchySequence.subalgebra : Subalgebra R (ℕ → R) 
goal: Subalgebra R (ℕ → R)

full_name: AdicCompletion.AdicCauchySequence.subring
code: /-- `AdicCauchySequence I R` is a subring of `ℕ → R`. -/
def AdicCauchySequence.subring : Subring (ℕ → R) 
goal: Subring (ℕ → R)

full_name: AdicCompletion.instMulAdicCauchySequence
code: instance : Mul (AdicCauchySequence I R) 
goal: Mul (AdicCompletion.AdicCauchySequence I R)

full_name: AdicCompletion.instOneAdicCauchySequence
code: instance : One (AdicCauchySequence I R) 
goal: One (AdicCompletion.AdicCauchySequence I R)

full_name: AdicCompletion.instNatCastAdicCauchySequence
code: instance : NatCast (AdicCauchySequence I R) 
goal: NatCast (AdicCompletion.AdicCauchySequence I R)

full_name: AdicCompletion.instIntCastAdicCauchySequence
code: instance : IntCast (AdicCauchySequence I R) 
goal: IntCast (AdicCompletion.AdicCauchySequence I R)

full_name: AdicCompletion.instPowAdicCauchySequenceNat
code: instance : Pow (AdicCauchySequence I R) ℕ 
goal: Pow (AdicCompletion.AdicCauchySequence I R) ℕ

full_name: AdicCompletion.instCommRingAdicCauchySequence
code: instance : CommRing (AdicCauchySequence I R) 
goal: CommRing (AdicCompletion.AdicCauchySequence I R)

full_name: AdicCompletion.instAlgebraAdicCauchySequence
code: instance : Algebra R (AdicCauchySequence I R) 
goal: Algebra R (AdicCompletion.AdicCauchySequence I R)

full_name: AdicCompletion.one_apply
code: @[simp]
theorem one_apply (n : ℕ) : (1 : AdicCauchySequence I R) n = 1 
goal: ↑1 n = 1

full_name: AdicCompletion.mul_apply
code: @[simp]
theorem mul_apply (n : ℕ) (f g : AdicCauchySequence I R) : (f * g) n = f n * g n 
goal: ↑(f * g) n = ↑f n * ↑g n

full_name: AdicCompletion.mkₐ
code: /-- The canonical algebra map from adic cauchy sequences to the adic completion. -/
@[simps!]
def mkₐ : AdicCauchySequence I R →ₐ[R] AdicCompletion I R 
goal: AdicCompletion.AdicCauchySequence I R →ₐ[R] AdicCompletion I R

full_name: AdicCompletion.mkₐ_apply_coe
code: /-- The canonical algebra map from adic cauchy sequences to the adic completion. -/
@[simps!]
def mkₐ : AdicCauchySequence I R →ₐ[R] AdicCompletion I R 
goal: ↑((AdicCompletion.mkₐ I) a) n = (Ideal.Quotient.mk (I ^ n • ⊤)) (↑a n)

full_name: AdicCompletion.evalₐ_mkₐ
code: @[simp]
theorem evalₐ_mkₐ (n : ℕ) (x : AdicCauchySequence I R) :
    evalₐ I n (mkₐ I x) = Ideal.Quotient.mk (I ^ n) (x.val n) 
goal: (AdicCompletion.evalₐ I n) ((AdicCompletion.mkₐ I) x) = (Ideal.Quotient.mk (I ^ n)) (↑x n)

full_name: AdicCompletion.Ideal.mk_eq_mk
code: theorem Ideal.mk_eq_mk {m n : ℕ} (hmn : m ≤ n) (r : AdicCauchySequence I R) :
    Ideal.Quotient.mk (I ^ m) (r.val n) = Ideal.Quotient.mk (I ^ m) (r.val m) 
goal: (Ideal.Quotient.mk (I ^ m)) (↑r n) = (Ideal.Quotient.mk (I ^ m)) (↑r m)

full_name: AdicCompletion.smul_mk
code: theorem smul_mk {m n : ℕ} (hmn : m ≤ n) (r : AdicCauchySequence I R)
    (x : AdicCauchySequence I M) :
    r.val n • Submodule.Quotient.mk (p := (I ^ m • ⊤ : Submodule R M)) (x.val n) =
      r.val m • Submodule.Quotient.mk (p := (I ^ m • ⊤ : Submodule R M)) (x.val m) 
goal: ↑r n • Submodule.Quotient.mk (↑x n) = ↑r m • Submodule.Quotient.mk (↑x m)

full_name: AdicCompletion.instSMulQuotientIdealHSMulTopSubmodule
code: /-- Scalar multiplication of `R ⧸ (I • ⊤)` on `M ⧸ (I • ⊤)`. This is used in order to have
good definitional behaviour for the module instance on adic completions -/
instance : SMul (R ⧸ (I • ⊤ : Ideal R)) (M ⧸ (I • ⊤ : Submodule R M)) 
goal: SMul (R ⧸ I • ⊤) (M ⧸ I • ⊤)

full_name: AdicCompletion.mk_smul_mk
code: @[local simp]
theorem mk_smul_mk (r : R) (x : M) :
    Ideal.Quotient.mk (I • ⊤) r • Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) x
      = r • Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) x 
goal: (Ideal.Quotient.mk (I • ⊤)) r • Submodule.Quotient.mk x = r • Submodule.Quotient.mk x

full_name: AdicCompletion.val_smul_eq_evalₐ_smul
code: theorem val_smul_eq_evalₐ_smul (n : ℕ) (r : AdicCompletion I R)
    (x : M ⧸ (I ^ n • ⊤ : Submodule R M)) : r.val n • x = evalₐ I n r • x 
goal: ↑r n • x = (AdicCompletion.evalₐ I n) r • x

full_name: AdicCompletion.instModuleQuotientIdealHSMulTopSubmodule
code: instance : Module (R ⧸ (I • ⊤ : Ideal R)) (M ⧸ (I • ⊤ : Submodule R M)) 
goal: Module (R ⧸ I • ⊤) (M ⧸ I • ⊤)

full_name: AdicCompletion.instIsScalarTowerQuotientIdealHSMulTopSubmodule
code: instance : IsScalarTower R (R ⧸ (I • ⊤ : Ideal R)) (M ⧸ (I • ⊤ : Submodule R M)) 
goal: IsScalarTower R (R ⧸ I • ⊤) (M ⧸ I • ⊤)

full_name: AdicCompletion.smul
code: instance smul : SMul (AdicCompletion I R) (AdicCompletion I M) 
goal: SMul (AdicCompletion I R) (AdicCompletion I M)

full_name: AdicCompletion.smul_eval
code: @[simp]
theorem smul_eval (n : ℕ) (r : AdicCompletion I R) (x : AdicCompletion I M) :
    (r • x).val n = r.val n • x.val n 
goal: ↑(r • x) n = ↑r n • ↑x n

full_name: AdicCompletion.module
code: /-- `AdicCompletion I M` is naturally an `AdicCompletion I R` module. -/
instance module : Module (AdicCompletion I R) (AdicCompletion I M) 
goal: Module (AdicCompletion I R) (AdicCompletion I M)

full_name: AdicCompletion.instIsScalarTower
code: instance : IsScalarTower R (AdicCompletion I R) (AdicCompletion I M) 
goal: IsScalarTower R (AdicCompletion I R) (AdicCompletion I M)