File: Mathlib/RingTheory/AdicCompletion/AsTensorProduct.lean

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.ofTensorProductBil
code: private
def ofTensorProductBil : AdicCompletion I R →ₗ[AdicCompletion I R] M →ₗ[R] AdicCompletion I M 
goal: AdicCompletion I R →ₗ[AdicCompletion I R] M →ₗ[R] AdicCompletion I M

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.ofTensorProductBil_apply_apply
code: @[simp]
private lemma ofTensorProductBil_apply_apply (r : AdicCompletion I R) (x : M) :
    ((AdicCompletion.ofTensorProductBil I M) r) x = r • (of I M) x 
goal: ((AdicCompletion.ofTensorProductBil I M) r) x = r • (AdicCompletion.of I M) x

full_name: AdicCompletion.ofTensorProduct
code: /-- The natural `AdicCompletion I R`-linear map from `AdicCompletion I R ⊗[R] M` to
the adic completion of `M`. -/
def ofTensorProduct : AdicCompletion I R ⊗[R] M →ₗ[AdicCompletion I R] AdicCompletion I M 
goal: AdicCompletion I R ⊗[R] M →ₗ[AdicCompletion I R] AdicCompletion I M

full_name: AdicCompletion.ofTensorProduct_tmul
code: @[simp]
lemma ofTensorProduct_tmul (r : AdicCompletion I R) (x : M) :
    ofTensorProduct I M (r ⊗ₜ x) = r • of I M x 
goal: (AdicCompletion.ofTensorProduct I M) (r ⊗ₜ[R] x) = r • (AdicCompletion.of I M) x

full_name: AdicCompletion.ofTensorProduct_naturality
code: /-- `ofTensorProduct` is functorial in `M`. -/
lemma ofTensorProduct_naturality (f : M →ₗ[R] N) :
    map I f ∘ₗ ofTensorProduct I M =
      ofTensorProduct I N ∘ₗ AlgebraTensorModule.map LinearMap.id f 
goal: AdicCompletion.map I f ∘ₗ AdicCompletion.ofTensorProduct I M =
  AdicCompletion.ofTensorProduct I N ∘ₗ TensorProduct.AlgebraTensorModule.map LinearMap.id f

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.piEquivOfFintype_comp_ofTensorProduct_eq
code: private lemma piEquivOfFintype_comp_ofTensorProduct_eq :
    piEquivOfFintype I (fun _ : ι ↦ R) ∘ₗ ofTensorProduct I (ι → R) =
      (TensorProduct.piScalarRight R (AdicCompletion I R) (AdicCompletion I R) ι).toLinearMap 
goal: ↑(AdicCompletion.piEquivOfFintype I fun x => R) ∘ₗ AdicCompletion.ofTensorProduct I (ι → R) =
  ↑(TensorProduct.piScalarRight R (AdicCompletion I R) (AdicCompletion I R) ι)

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.ofTensorProduct_eq
code: private lemma ofTensorProduct_eq :
    ofTensorProduct I (ι → R) = (piEquivOfFintype I (ι := ι) (fun _ : ι ↦ R)).symm.toLinearMap ∘ₗ
      (TensorProduct.piScalarRight R (AdicCompletion I R) (AdicCompletion I R) ι).toLinearMap 
goal: AdicCompletion.ofTensorProduct I (ι → R) =
  ↑(AdicCompletion.piEquivOfFintype I fun x => R).symm ∘ₗ
    ↑(TensorProduct.piScalarRight R (AdicCompletion I R) (AdicCompletion I R) ι)

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.ofTensorProductInvOfPiFintype
code: private def ofTensorProductInvOfPiFintype :
    AdicCompletion I (ι → R) ≃ₗ[AdicCompletion I R] AdicCompletion I R ⊗[R] (ι → R) 
goal: AdicCompletion I (ι → R) ≃ₗ[AdicCompletion I R] AdicCompletion I R ⊗[R] (ι → R)

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.ofTensorProductInvOfPiFintype_comp_ofTensorProduct
code: private lemma ofTensorProductInvOfPiFintype_comp_ofTensorProduct :
    ofTensorProductInvOfPiFintype I ι ∘ₗ ofTensorProduct I (ι → R) = LinearMap.id 
goal: ↑(AdicCompletion.ofTensorProductInvOfPiFintype I ι) ∘ₗ AdicCompletion.ofTensorProduct I (ι → R) = LinearMap.id

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.ofTensorProduct_comp_ofTensorProductInvOfPiFintype
code: private lemma ofTensorProduct_comp_ofTensorProductInvOfPiFintype :
    ofTensorProduct I (ι → R) ∘ₗ ofTensorProductInvOfPiFintype I ι = LinearMap.id 
goal: AdicCompletion.ofTensorProduct I (ι → R) ∘ₗ ↑(AdicCompletion.ofTensorProductInvOfPiFintype I ι) = LinearMap.id

full_name: AdicCompletion.ofTensorProductEquivOfPiFintype
code: /-- `ofTensorProduct` as an equiv in the case of `M = R^ι` where `ι` is finite. -/
def ofTensorProductEquivOfPiFintype :
    AdicCompletion I R ⊗[R] (ι → R) ≃ₗ[AdicCompletion I R] AdicCompletion I (ι → R) 
goal: AdicCompletion I R ⊗[R] (ι → R) ≃ₗ[AdicCompletion I R] AdicCompletion I (ι → R)

full_name: AdicCompletion.ofTensorProduct_bijective_of_pi_of_fintype
code: /-- If `M = R^ι`, `ofTensorProduct` is bijective. -/
lemma ofTensorProduct_bijective_of_pi_of_fintype [Finite ι] :
    Function.Bijective (ofTensorProduct I (ι → R)) 
goal: Function.Bijective ⇑(AdicCompletion.ofTensorProduct I (ι → R))

full_name: AdicCompletion.ofTensorProduct_surjective_of_finite
code: /-- If `M` is a finite `R`-module, then the canonical map
`AdicCompletion I R ⊗[R] M →ₗ AdicCompletion I M` is surjective. -/
lemma ofTensorProduct_surjective_of_finite [Module.Finite R M] :
    Function.Surjective (ofTensorProduct I M) 
goal: Function.Surjective ⇑(AdicCompletion.ofTensorProduct I M)

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.lTensorKerIncl
code: private
def lTensorKerIncl : AdicCompletion I R ⊗[R] LinearMap.ker f →ₗ[AdicCompletion I R]
    AdicCompletion I R ⊗[R] (ι → R) 
goal: AdicCompletion I R ⊗[R] ↥(LinearMap.ker f) →ₗ[AdicCompletion I R] AdicCompletion I R ⊗[R] (ι → R)

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.lTensorf
code: private def lTensorf :
    AdicCompletion I R ⊗[R] (ι → R) →ₗ[AdicCompletion I R] AdicCompletion I R ⊗[R] M 
goal: AdicCompletion I R ⊗[R] (ι → R) →ₗ[AdicCompletion I R] AdicCompletion I R ⊗[R] M

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.if_exact
code: private lemma if_exact : Function.Exact (LinearMap.ker f).subtype f 
goal: Function.Exact ⇑(LinearMap.ker f).subtype ⇑f

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.tens_exact
code: private lemma tens_exact : Function.Exact (lTensorKerIncl I M f) (lTensorf I M f) 
goal: Function.Exact ⇑(AdicCompletion.lTensorKerIncl I M f) ⇑(AdicCompletion.lTensorf I M f)

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.tens_surj
code: private lemma tens_surj : Function.Surjective (lTensorf I M f) 
goal: Function.Surjective ⇑(AdicCompletion.lTensorf I M f)

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.adic_exact
code: private lemma adic_exact : Function.Exact (map I (LinearMap.ker f).subtype) (map I f) 
goal: Function.Exact ⇑(AdicCompletion.map I (LinearMap.ker f).subtype) ⇑(AdicCompletion.map I f)

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.adic_surj
code: private lemma adic_surj : Function.Surjective (map I f) 
goal: Function.Surjective ⇑(AdicCompletion.map I f)

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.instAddCommGroupTensorProductSubtypeForallMemSubmoduleKerLinearMapId
code: private instance : AddCommGroup (AdicCompletion I R ⊗[R] (LinearMap.ker f)) 
goal: AddCommGroup (AdicCompletion I R ⊗[R] ↥(LinearMap.ker f))

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.firstRow
code: private def firstRow : ComposableArrows (ModuleCat (AdicCompletion I R)) 4 
goal: CategoryTheory.ComposableArrows (ModuleCat (AdicCompletion I R)) 4

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.secondRow
code: private def secondRow : ComposableArrows (ModuleCat (AdicCompletion I R)) 4 
goal: CategoryTheory.ComposableArrows (ModuleCat (AdicCompletion I R)) 4

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.firstRow_exact
code: private lemma firstRow_exact : (firstRow I M f).Exact 
goal: (AdicCompletion.firstRow I M f).Exact

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.secondRow_exact
code: private lemma secondRow_exact : (secondRow I M f).Exact 
goal: (AdicCompletion.secondRow I M f).Exact

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.firstRowToSecondRow
code: private def firstRowToSecondRow : firstRow I M f ⟶ secondRow I M f 
goal: AdicCompletion.firstRow I M f ⟶ AdicCompletion.secondRow I M f

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.ofTensorProduct_iso
code: private lemma ofTensorProduct_iso : IsIso (ModuleCat.ofHom (ofTensorProduct I M)) 
goal: CategoryTheory.IsIso (ModuleCat.ofHom (AdicCompletion.ofTensorProduct I M))

full_name: _private.Mathlib.RingTheory.AdicCompletion.AsTensorProduct.0.AdicCompletion.ofTensorProduct_bijective_of_map_from_fin
code: private
lemma ofTensorProduct_bijective_of_map_from_fin : Function.Bijective (ofTensorProduct I M) 
goal: Function.Bijective ⇑(AdicCompletion.ofTensorProduct I M)

full_name: AdicCompletion.ofTensorProduct_bijective_of_finite_of_isNoetherian
code: /-- If `R` is a Noetherian ring and `M` is a finite `R`-module, then the natural map
given by `AdicCompletion.ofTensorProduct` is an isomorphism. -/
theorem ofTensorProduct_bijective_of_finite_of_isNoetherian [Module.Finite R M] :
    Function.Bijective (ofTensorProduct I M) 
goal: Function.Bijective ⇑(AdicCompletion.ofTensorProduct I M)

full_name: AdicCompletion.ofTensorProductEquivOfFiniteNoetherian
code: /-- `ofTensorProduct` packaged as linear equiv if `M` is a finite `R`-module and `R` is
Noetherian. -/
def ofTensorProductEquivOfFiniteNoetherian [Module.Finite R M] :
    AdicCompletion I R ⊗[R] M ≃ₗ[AdicCompletion I R] AdicCompletion I M 
goal: AdicCompletion I R ⊗[R] M ≃ₗ[AdicCompletion I R] AdicCompletion I M

full_name: AdicCompletion.ofTensorProductEquivOfFiniteNoetherian_apply
code: @[simp]
lemma ofTensorProductEquivOfFiniteNoetherian_apply [Module.Finite R M]
    (x : AdicCompletion I R ⊗[R] M) :
    ofTensorProductEquivOfFiniteNoetherian I M x = ofTensorProduct I M x 
goal: (AdicCompletion.ofTensorProductEquivOfFiniteNoetherian I M) x = (AdicCompletion.ofTensorProduct I M) x

full_name: AdicCompletion.ofTensorProductEquivOfFiniteNoetherian_symm_of
code: @[simp]
lemma ofTensorProductEquivOfFiniteNoetherian_symm_of [Module.Finite R M] (x : M) :
    (ofTensorProductEquivOfFiniteNoetherian I M).symm ((of I M) x) = 1 ⊗ₜ x 
goal: (AdicCompletion.ofTensorProductEquivOfFiniteNoetherian I M).symm ((AdicCompletion.of I M) x) = 1 ⊗ₜ[R] x

full_name: AdicCompletion.tensor_map_id_left_eq_map
code: lemma tensor_map_id_left_eq_map :
    (AlgebraTensorModule.map LinearMap.id f) =
      (ofTensorProductEquivOfFiniteNoetherian I N).symm.toLinearMap ∘ₗ
      map I f ∘ₗ
      (ofTensorProductEquivOfFiniteNoetherian I M).toLinearMap 
goal: TensorProduct.AlgebraTensorModule.map LinearMap.id f =
  ↑(AdicCompletion.ofTensorProductEquivOfFiniteNoetherian I N).symm ∘ₗ
    AdicCompletion.map I f ∘ₗ ↑(AdicCompletion.ofTensorProductEquivOfFiniteNoetherian I M)

full_name: AdicCompletion.tensor_map_id_left_injective_of_injective
code: lemma tensor_map_id_left_injective_of_injective (hf : Function.Injective f) :
    Function.Injective (AlgebraTensorModule.map LinearMap.id f :
        AdicCompletion I R ⊗[R] M →ₗ[AdicCompletion I R] AdicCompletion I R ⊗[R] N) 
goal: Function.Injective ⇑(TensorProduct.AlgebraTensorModule.map LinearMap.id f)

full_name: AdicCompletion.flat_of_isNoetherian
code: /-- Adic completion of a Noetherian ring `R` is flat over `R`. -/
instance flat_of_isNoetherian [IsNoetherianRing R] : Algebra.Flat R (AdicCompletion I R) 
goal: Algebra.Flat R (AdicCompletion I R)