File: Mathlib/RingTheory/AdicCompletion/Functoriality.lean

full_name: _private.Mathlib.RingTheory.AdicCompletion.Functoriality.0.LinearMap.reduceModIdealAux
code: /-- `R`-linear version of `reduceModIdeal`. -/
private def reduceModIdealAux (f : M →ₗ[R] N) :
    M ⧸ (I • ⊤ : Submodule R M) →ₗ[R] N ⧸ (I • ⊤ : Submodule R N) 
goal: M ⧸ I • ⊤ →ₗ[R] N ⧸ I • ⊤

full_name: _private.Mathlib.RingTheory.AdicCompletion.Functoriality.0.LinearMap.reduceModIdealAux_apply
code: @[local simp]
private theorem reduceModIdealAux_apply (f : M →ₗ[R] N) (x : M) :
    (f.reduceModIdealAux I) (Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) x) =
      Submodule.Quotient.mk (p := (I • ⊤ : Submodule R N)) (f x) 
goal: (LinearMap.reduceModIdealAux I f) (Submodule.Quotient.mk x) = Submodule.Quotient.mk (f x)

full_name: LinearMap.reduceModIdeal
code: /-- The induced linear map on the quotients mod `I • ⊤`. -/
def reduceModIdeal (f : M →ₗ[R] N) :
    M ⧸ (I • ⊤ : Submodule R M) →ₗ[R ⧸ I] N ⧸ (I • ⊤ : Submodule R N) 
goal: M ⧸ I • ⊤ →ₗ[R ⧸ I] N ⧸ I • ⊤

full_name: LinearMap.reduceModIdeal_apply
code: @[simp]
theorem reduceModIdeal_apply (f : M →ₗ[R] N) (x : M) :
    (f.reduceModIdeal I) (Submodule.Quotient.mk (p := (I • ⊤ : Submodule R M)) x) =
      Submodule.Quotient.mk (p := (I • ⊤ : Submodule R N)) (f x) 
goal: (LinearMap.reduceModIdeal I f) (Submodule.Quotient.mk x) = Submodule.Quotient.mk (f x)

full_name: AdicCompletion.transitionMap_comp_reduceModIdeal
code: theorem transitionMap_comp_reduceModIdeal (f : M →ₗ[R] N) {m n : ℕ}
    (hmn : m ≤ n) : transitionMap I N hmn ∘ₗ f.reduceModIdeal (I ^ n) =
      (f.reduceModIdeal (I ^ m) : _ →ₗ[R] _) ∘ₗ transitionMap I M hmn 
goal: AdicCompletion.transitionMap I N hmn ∘ₗ ↑R (LinearMap.reduceModIdeal (I ^ n) f) =
  ↑R (LinearMap.reduceModIdeal (I ^ m) f) ∘ₗ AdicCompletion.transitionMap I M hmn

full_name: AdicCompletion.AdicCauchySequence.map
code: /-- A linear map induces a linear map on adic cauchy sequences. -/
@[simps]
def map (f : M →ₗ[R] N) : AdicCauchySequence I M →ₗ[R] AdicCauchySequence I N 
goal: AdicCompletion.AdicCauchySequence I M →ₗ[R] AdicCompletion.AdicCauchySequence I N

full_name: AdicCompletion.AdicCauchySequence.map_apply_coe
code: /-- A linear map induces a linear map on adic cauchy sequences. -/
@[simps]
def map (f : M →ₗ[R] N) : AdicCauchySequence I M →ₗ[R] AdicCauchySequence I N 
goal: ↑((AdicCompletion.AdicCauchySequence.map I f) a) n = f (↑a n)

full_name: AdicCompletion.AdicCauchySequence.map_id
code: @[simp]
theorem map_id : map I (LinearMap.id (M := M)) = LinearMap.id 
goal: AdicCompletion.AdicCauchySequence.map I LinearMap.id = LinearMap.id

full_name: AdicCompletion.AdicCauchySequence.map_comp
code: theorem map_comp (f : M →ₗ[R] N) (g : N →ₗ[R] P) :
    map I g ∘ₗ map I f = map I (g ∘ₗ f) 
goal: AdicCompletion.AdicCauchySequence.map I g ∘ₗ AdicCompletion.AdicCauchySequence.map I f =
  AdicCompletion.AdicCauchySequence.map I (g ∘ₗ f)

full_name: AdicCompletion.AdicCauchySequence.map_comp_apply
code: theorem map_comp_apply (f : M →ₗ[R] N) (g : N →ₗ[R] P) (a : AdicCauchySequence I M) :
    map I g (map I f a) = map I (g ∘ₗ f) a 
goal: (AdicCompletion.AdicCauchySequence.map I g) ((AdicCompletion.AdicCauchySequence.map I f) a) =
  (AdicCompletion.AdicCauchySequence.map I (g ∘ₗ f)) a

full_name: AdicCompletion.AdicCauchySequence.map_zero
code: @[simp]
theorem map_zero : map I (0 : M →ₗ[R] N) = 0 
goal: AdicCompletion.AdicCauchySequence.map I 0 = 0

full_name: _private.Mathlib.RingTheory.AdicCompletion.Functoriality.0.AdicCompletion.adicCompletionAux
code: /-- `R`-linear version of `adicCompletion`. -/
private def adicCompletionAux (f : M →ₗ[R] N) :
    AdicCompletion I M →ₗ[R] AdicCompletion I N 
goal: AdicCompletion I M →ₗ[R] AdicCompletion I N

full_name: _private.Mathlib.RingTheory.AdicCompletion.Functoriality.0.AdicCompletion.adicCompletionAux_val_apply
code: @[local simp]
private theorem adicCompletionAux_val_apply (f : M →ₗ[R] N) {n : ℕ} (x : AdicCompletion I M) :
    (adicCompletionAux I f x).val n = f.reduceModIdeal (I ^ n) (x.val n) 
goal: ↑((AdicCompletion.adicCompletionAux I f) x) n = (LinearMap.reduceModIdeal (I ^ n) f) (↑x n)

full_name: AdicCompletion.map
code: /-- A linear map induces a map on adic completions. -/
def map (f : M →ₗ[R] N) :
    AdicCompletion I M →ₗ[AdicCompletion I R] AdicCompletion I N 
goal: AdicCompletion I M →ₗ[AdicCompletion I R] AdicCompletion I N

full_name: AdicCompletion.map_val_apply
code: @[simp]
theorem map_val_apply (f : M →ₗ[R] N) {n : ℕ} (x : AdicCompletion I M) :
    (map I f x).val n = f.reduceModIdeal (I ^ n) (x.val n) 
goal: ↑((AdicCompletion.map I f) x) n = (LinearMap.reduceModIdeal (I ^ n) f) (↑x n)

full_name: AdicCompletion.map_ext
code: /-- Equality of maps out of an adic completion can be checked on Cauchy sequences. -/
theorem map_ext {f g : AdicCompletion I M → N}
    (h : ∀ (a : AdicCauchySequence I M),
      f (AdicCompletion.mk I M a) = g (AdicCompletion.mk I M a)) :
    f = g 
goal: f = g

full_name: AdicCompletion.map_ext'
code: /-- Equality of linear maps out of an adic completion can be checked on Cauchy sequences. -/
@[ext]
theorem map_ext' {f g : AdicCompletion I M →ₗ[AdicCompletion I R] T}
    (h : ∀ (a : AdicCauchySequence I M),
      f (AdicCompletion.mk I M a) = g (AdicCompletion.mk I M a)) :
    f = g 
goal: f = g

full_name: AdicCompletion.map_ext''
code: /-- Equality of linear maps out of an adic completion can be checked on Cauchy sequences. -/
@[ext]
theorem map_ext'' {f g : AdicCompletion I M →ₗ[R] N}
    (h : f.comp (AdicCompletion.mk I M) = g.comp (AdicCompletion.mk I M)) :
    f = g 
goal: f = g

full_name: AdicCompletion.map_id
code: @[simp]
theorem map_id :
    map I (LinearMap.id (M := M)) =
      LinearMap.id (R := AdicCompletion I R) (M := AdicCompletion I M) 
goal: AdicCompletion.map I LinearMap.id = LinearMap.id

full_name: AdicCompletion.map_comp
code: theorem map_comp (f : M →ₗ[R] N) (g : N →ₗ[R] P) :
    map I g ∘ₗ map I f = map I (g ∘ₗ f) 
goal: AdicCompletion.map I g ∘ₗ AdicCompletion.map I f = AdicCompletion.map I (g ∘ₗ f)

full_name: AdicCompletion.map_comp_apply
code: theorem map_comp_apply (f : M →ₗ[R] N) (g : N →ₗ[R] P) (x : AdicCompletion I M) :
    map I g (map I f x) = map I (g ∘ₗ f) x 
goal: (AdicCompletion.map I g) ((AdicCompletion.map I f) x) = (AdicCompletion.map I (g ∘ₗ f)) x

full_name: AdicCompletion.map_mk
code: @[simp]
theorem map_mk (f : M →ₗ[R] N) (a : AdicCauchySequence I M) :
    map I f (AdicCompletion.mk I M a) =
      AdicCompletion.mk I N (AdicCauchySequence.map I f a) 
goal: (AdicCompletion.map I f) ((AdicCompletion.mk I M) a) =
  (AdicCompletion.mk I N) ((AdicCompletion.AdicCauchySequence.map I f) a)

full_name: AdicCompletion.map_zero
code: @[simp]
theorem map_zero : map I (0 : M →ₗ[R] N) = 0 
goal: AdicCompletion.map I 0 = 0

full_name: AdicCompletion.congr
code: /-- A linear equiv induces a linear equiv on adic completions. -/
def congr (f : M ≃ₗ[R] N) :
    AdicCompletion I M ≃ₗ[AdicCompletion I R] AdicCompletion I N 
goal: AdicCompletion I M ≃ₗ[AdicCompletion I R] AdicCompletion I N

full_name: AdicCompletion.congr_apply
code: @[simp]
theorem congr_apply (f : M ≃ₗ[R] N) (x : AdicCompletion I M) :
    congr I f x = map I f x 
goal: (AdicCompletion.congr I f) x = (AdicCompletion.map I ↑f) x

full_name: AdicCompletion.congr_symm_apply
code: @[simp]
theorem congr_symm_apply (f : M ≃ₗ[R] N) (x : AdicCompletion I N) :
    (congr I f).symm x = map I f.symm x 
goal: (AdicCompletion.congr I f).symm x = (AdicCompletion.map I ↑f.symm) x

full_name: AdicCompletion.pi
code: /-- The canonical map from the adic completion of the product to the product of the
adic completions. -/
@[simps!]
def pi : AdicCompletion I (∀ j, M j) →ₗ[AdicCompletion I R] ∀ j, AdicCompletion I (M j) 
goal: AdicCompletion I ((j : ι) → M j) →ₗ[AdicCompletion I R] (j : ι) → AdicCompletion I (M j)

full_name: AdicCompletion.pi_apply_coe
code: /-- The canonical map from the adic completion of the product to the product of the
adic completions. -/
@[simps!]
def pi : AdicCompletion I (∀ j, M j) →ₗ[AdicCompletion I R] ∀ j, AdicCompletion I (M j) 
goal: ↑((AdicCompletion.pi I M) c i) n = (LinearMap.reduceModIdeal (I ^ n) (LinearMap.proj i)) (↑c n)

full_name: AdicCompletion.sum
code: /-- The canonical map from the sum of the adic completions to the adic completion
of the sum. -/
def sum :
    (⨁ j, (AdicCompletion I (M j))) →ₗ[AdicCompletion I R] AdicCompletion I (⨁ j, M j) 
goal: (DirectSum ι fun j => AdicCompletion I (M j)) →ₗ[AdicCompletion I R] AdicCompletion I (DirectSum ι fun j => M j)

full_name: AdicCompletion.sum_lof
code: @[simp]
theorem sum_lof (j : ι) (x : AdicCompletion I (M j)) :
    sum I M ((DirectSum.lof (AdicCompletion I R) ι (fun i ↦ AdicCompletion I (M i)) j) x) =
      map I (lof R ι M j) x 
goal: (AdicCompletion.sum I M) ((DirectSum.lof (AdicCompletion I R) ι (fun i => AdicCompletion I (M i)) j) x) =
  (AdicCompletion.map I (DirectSum.lof R ι M j)) x

full_name: AdicCompletion.sum_of
code: @[simp]
theorem sum_of (j : ι) (x : AdicCompletion I (M j)) :
    sum I M ((DirectSum.of (fun i ↦ AdicCompletion I (M i)) j) x) =
      map I (lof R ι M j) x 
goal: (AdicCompletion.sum I M) ((DirectSum.of (fun i => AdicCompletion I (M i)) j) x) =
  (AdicCompletion.map I (DirectSum.lof R ι M j)) x

full_name: AdicCompletion.sumInv
code: /-- If `ι` is finite, we use the equivalence of sum and product to obtain an inverse for
`AdicCompletion.sum` from `AdicCompletion.pi`. -/
def sumInv : AdicCompletion I (⨁ j, M j) →ₗ[AdicCompletion I R] (⨁ j, (AdicCompletion I (M j))) 
goal: AdicCompletion I (DirectSum ι fun j => M j) →ₗ[AdicCompletion I R] DirectSum ι fun j => AdicCompletion I (M j)

full_name: AdicCompletion.component_sumInv
code: @[simp]
theorem component_sumInv (x : AdicCompletion I (⨁ j, M j)) (j : ι) :
    component (AdicCompletion I R) ι _ j (sumInv I M x) =
      map I (component R ι _ j) x 
goal: (DirectSum.component (AdicCompletion I R) ι (fun i => AdicCompletion I (M i)) j) ((AdicCompletion.sumInv I M) x) =
  (AdicCompletion.map I (DirectSum.component R ι M j)) x

full_name: AdicCompletion.sumInv_apply
code: @[simp]
theorem sumInv_apply (x : AdicCompletion I (⨁ j, M j)) (j : ι) :
    (sumInv I M x) j = map I (component R ι _ j) x 
goal: ((AdicCompletion.sumInv I M) x) j = (AdicCompletion.map I (DirectSum.component R ι M j)) x

full_name: AdicCompletion.sumInv_comp_sum
code: theorem sumInv_comp_sum : sumInv I M ∘ₗ sum I M = LinearMap.id 
goal: AdicCompletion.sumInv I M ∘ₗ AdicCompletion.sum I M = LinearMap.id

full_name: AdicCompletion.sum_comp_sumInv
code: theorem sum_comp_sumInv : sum I M ∘ₗ sumInv I M = LinearMap.id 
goal: AdicCompletion.sum I M ∘ₗ AdicCompletion.sumInv I M = LinearMap.id

full_name: AdicCompletion.sumEquivOfFintype
code: /-- If `ι` is finite, `sum` has `sumInv` as inverse. -/
def sumEquivOfFintype :
    (⨁ j, (AdicCompletion I (M j))) ≃ₗ[AdicCompletion I R] AdicCompletion I (⨁ j, M j) 
goal: (DirectSum ι fun j => AdicCompletion I (M j)) ≃ₗ[AdicCompletion I R] AdicCompletion I (DirectSum ι fun j => M j)

full_name: AdicCompletion.sumEquivOfFintype_apply
code: @[simp]
theorem sumEquivOfFintype_apply (x : ⨁ j, (AdicCompletion I (M j))) :
    sumEquivOfFintype I M x = sum I M x 
goal: (AdicCompletion.sumEquivOfFintype I M) x = (AdicCompletion.sum I M) x

full_name: AdicCompletion.sumEquivOfFintype_symm_apply
code: @[simp]
theorem sumEquivOfFintype_symm_apply (x : AdicCompletion I (⨁ j, M j)) :
    (sumEquivOfFintype I M).symm x = sumInv I M x 
goal: (AdicCompletion.sumEquivOfFintype I M).symm x = (AdicCompletion.sumInv I M) x

full_name: AdicCompletion.piEquivOfFintype
code: /-- If `ι` is finite, `pi` is a linear equiv. -/
def piEquivOfFintype :
    AdicCompletion I (∀ j, M j) ≃ₗ[AdicCompletion I R] ∀ j, AdicCompletion I (M j) 
goal: AdicCompletion I ((j : ι) → M j) ≃ₗ[AdicCompletion I R] (j : ι) → AdicCompletion I (M j)

full_name: AdicCompletion.piEquivOfFintype_apply
code: @[simp]
theorem piEquivOfFintype_apply (x : AdicCompletion I (∀ j, M j)) :
    piEquivOfFintype I M x = pi I M x 
goal: (AdicCompletion.piEquivOfFintype I M) x = (AdicCompletion.pi I M) x

full_name: AdicCompletion.piEquivFin
code: /-- Adic completion of `R^n` is `(AdicCompletion I R)^n`. -/
def piEquivFin (n : ℕ) :
    AdicCompletion I (Fin n → R) ≃ₗ[AdicCompletion I R] Fin n → AdicCompletion I R 
goal: AdicCompletion I (Fin n → R) ≃ₗ[AdicCompletion I R] Fin n → AdicCompletion I R

full_name: AdicCompletion.piEquivFin_apply
code: @[simp]
theorem piEquivFin_apply (n : ℕ) (x : AdicCompletion I (Fin n → R)) :
    piEquivFin I n x = pi I (fun _ : Fin n ↦ R) x 
goal: (AdicCompletion.piEquivFin I n) x = (AdicCompletion.pi I fun x => R) x