import Mathlib

namespace OAI

/-! Tensor localizations, Galois invariants and normality of scalar extensions. -/

noncomputable section
open AlgebraicGeometry CategoryTheory CategoryTheory.Limits TopologicalSpace Order Polynomial
open scoped TensorProduct WithZero
universe u

namespace RelativeDenominators
section

 

theorem algebraMap_surjective_of_isAlgebraic_tensorSelf_domain
    (K A : Type*) [Field K] [Field A] [Algebra K A]
    [Algebra.IsAlgebraic K A] [IsDomain (A ⊗[K] A)] :
    Function.Surjective (algebraMap K A) := by
  have hfield := Algebra.TensorProduct.isField_of_isAlgebraic K A A
    (Or.inl (inferInstance : Algebra.IsAlgebraic K A))
  have hd := IntermediateField.LinearDisjoint.of_isField' hfield
    (AlgHom.id K A) (AlgHom.id K A)
  have he := hd.eq_bot_of_self
  intro x
  apply IntermediateField.mem_bot.mp
  rw [← he]
  exact ⟨x, rfl⟩

variable (K A L M : Type*) [Field K] [CommRing A] [Field L] [Field M]
  [Algebra K A] [Algebra K L] [Algebra K M] [Algebra A M] [IsScalarTower K A M]

 
@[instance_reducible] def tensorFractionAlgebra : Algebra (A ⊗[K] L) (M ⊗[K] L) :=
  (Algebra.TensorProduct.map (IsScalarTower.toAlgHom K A M) (AlgHom.id K L)).toAlgebra

lemma tensorFraction_isLocalization [IsFractionRing A M] :
    letI := tensorFractionAlgebra K A L M
    IsLocalization (Algebra.algebraMapSubmonoid (A ⊗[K] L) (nonZeroDivisors A)) (M ⊗[K] L) := by
  let := tensorFractionAlgebra K A L M
  let : IsScalarTower A (A ⊗[K] L) (M ⊗[K] L) :=
    IsScalarTower.of_algebraMap_eq fun a => by
      change _ = Algebra.TensorProduct.map (IsScalarTower.toAlgHom K A M) (AlgHom.id K L)
        (a ⊗ₜ[K] (1 : L))
      simp
  apply IsLocalization.tensorProduct_tensorProduct K L (nonZeroDivisors A) M
  ext l
  simp [RingHom.algebraMap_toAlgebra]

lemma tensorFraction_domain [IsDomain (A ⊗[K] L)] [IsFractionRing A M] :
    IsDomain (M ⊗[K] L) := by
  let := tensorFractionAlgebra K A L M
  have : Nontrivial A := (algebraMap A M).domain_nontrivial
  let := tensorFraction_isLocalization K A L M
  apply IsLocalization.isDomain_of_le_nonZeroDivisors (M ⊗[K] L)
    (M := Algebra.algebraMapSubmonoid (A ⊗[K] L) (nonZeroDivisors A))
  rintro _ ⟨a, ha, rfl⟩
  rw [mem_nonZeroDivisors_iff_ne_zero]
  intro h
  apply nonZeroDivisors.ne_zero ha
  apply Algebra.TensorProduct.includeLeft_injective (R := K) (S := K) (A := A) (B := L)
    (RingHom.injective (algebraMap K L))
  change a ⊗ₜ[K] (1 : L) = (0 : A) ⊗ₜ[K] (1 : L)
  change a ⊗ₜ[K] (1 : L) = 0 at h
  simpa only [TensorProduct.zero_tmul] using h

 

@[instance_reducible] noncomputable def tensorFractionField [IsDomain (A ⊗[K] L)]
    [IsFractionRing A M] [Module.Finite K L] : Field (M ⊗[K] L) := by
  letI := tensorFraction_domain K A L M
  exact fieldOfFiniteDimensional M (M ⊗[K] L)

lemma tensorFraction_isFractionRing [IsDomain (A ⊗[K] L)]
    [IsFractionRing A M] [Module.Finite K L] :
    letI := tensorFractionAlgebra K A L M
    IsFractionRing (A ⊗[K] L) (M ⊗[K] L) := by
  let := tensorFractionAlgebra K A L M
  let := tensorFraction_isLocalization K A L M
  let := tensorFractionField K A L M
  have hinj : Function.Injective (algebraMap (A ⊗[K] L) (M ⊗[K] L)) := by
    apply IsLocalization.injective (M := Algebra.algebraMapSubmonoid (A ⊗[K] L)
      (nonZeroDivisors A))
    rintro _ ⟨a, ha, rfl⟩
    rw [mem_nonZeroDivisors_iff_ne_zero]
    intro h
    have hn : Nontrivial A := (algebraMap A M).domain_nontrivial
    apply nonZeroDivisors.ne_zero ha
    apply Algebra.TensorProduct.includeLeft_injective (R := K) (S := K) (A := A) (B := L)
      (RingHom.injective (algebraMap K L))
    change a ⊗ₜ[K] (1 : L) = (0 : A) ⊗ₜ[K] (1 : L)
    change a ⊗ₜ[K] (1 : L) = 0 at h
    simpa only [TensorProduct.zero_tmul] using h
  apply IsLocalization.of_le (Algebra.algebraMapSubmonoid (A ⊗[K] L)
    (nonZeroDivisors A)) (nonZeroDivisors (A ⊗[K] L))
  · rintro _ ⟨a, ha, rfl⟩
    rw [mem_nonZeroDivisors_iff_ne_zero]
    intro h
    have hn : Nontrivial A := (algebraMap A M).domain_nontrivial
    apply nonZeroDivisors.ne_zero ha
    apply Algebra.TensorProduct.includeLeft_injective (R := K) (S := K) (A := A) (B := L)
      (RingHom.injective (algebraMap K L))
    change a ⊗ₜ[K] (1 : L) = (0 : A) ⊗ₜ[K] (1 : L)
    change a ⊗ₜ[K] (1 : L) = 0 at h
    simpa only [TensorProduct.zero_tmul] using h
  · intro r hr
    exact isUnit_iff_ne_zero.mpr (fun hz => nonZeroDivisors.ne_zero hr
      (hinj (hz.trans (map_zero _).symm)))

end

 

theorem tensor_invariant_descends
    (K L M : Type*) [Field K] [Field L] [Field M]
    [Algebra K L] [IsGalois K L] [Algebra K M]
    (x : L ⊗[K] M)
    (hx : ∀ σ : Gal(L/K),
      Algebra.TensorProduct.map σ.toAlgHom (AlgHom.id K M) x = x) :
    ∃ m : M, (1 : L) ⊗ₜ[K] m = x := by
  classical
  let b := Module.Free.chooseBasis K M
  let c := b.baseChange L
  have hrepr (σ : Gal(L/K)) (y : L ⊗[K] M) (i) :
      c.repr (Algebra.TensorProduct.map σ.toAlgHom (AlgHom.id K M) y) i =
        σ (c.repr y i) := by
    induction y using TensorProduct.inductionOn with
    | tmul l m => simp [c, Algebra.smul_def]
    | add y z hy hz => simp [hy, hz]
  have hcoeff (i) : ∃ a : K, algebraMap K L a = c.repr x i := by
    apply Algebra.IsInvariant.isInvariant (G := Gal(L/K))
    intro σ
    change σ (c.repr x i) = c.repr x i
    rw [← hrepr, hx]
  choose a ha using hcoeff
  refine ⟨∑ i ∈ (c.repr x).support, a i • b i, ?_⟩
  apply c.repr.injective
  ext i
  simp only [c, Module.Basis.baseChange_repr_tmul, map_sum, map_smul,
    Finsupp.finsetSum_apply, Finsupp.smul_apply, Module.Basis.repr_self,
    Finsupp.single_apply, smul_eq_mul, mul_ite, mul_one, mul_zero]
  by_cases hi : i ∈ (c.repr x).support
  · have hi' : ((b.baseChange L).repr x) i ≠ 0 := Finsupp.mem_support_iff.mp hi
    simpa [hi', Algebra.smul_def, c] using ha i
  · have hxi : c.repr x i = 0 := Finsupp.notMem_support_iff.mp hi
    change ((b.baseChange L).repr x) i = 0 at hxi
    simp [hxi]

@[instance_reducible] noncomputable def tensorGaloisAction
    (K L M : Type*) [Field K] [Field L] [Field M]
    [Algebra K L] [Algebra K M] : MulSemiringAction (Gal(L/K)) (L ⊗[K] M) where
  smul σ x := Algebra.TensorProduct.map σ.toAlgHom (AlgHom.id K M) x
  smul_zero σ := map_zero _
  smul_add σ := map_add _
  smul_one σ := map_one _
  smul_mul σ := map_mul _
  one_smul x := by
    change Algebra.TensorProduct.map (1 : Gal(L/K)).toAlgHom (AlgHom.id K M) x = x
    induction x using TensorProduct.inductionOn with
    | tmul l m => simp
    | add x y hx hy => simp [hx, hy]
  mul_smul σ τ x := by
    change Algebra.TensorProduct.map (σ * τ).toAlgHom (AlgHom.id K M) x =
      Algebra.TensorProduct.map σ.toAlgHom (AlgHom.id K M)
        (Algebra.TensorProduct.map τ.toAlgHom (AlgHom.id K M) x)
    induction x using TensorProduct.inductionOn with
    | tmul l m => simp
    | add x y hx hy => simp [hx, hy]

 
theorem tensor_invariant_unit_descends
    (K L M : Type*) [Field K] [Field L] [Field M]
    [Algebra K L] [IsGalois K L] [Algebra K M]
    (x : (L ⊗[K] M)ˣ)
    (hx : ∀ σ : Gal(L/K),
      Algebra.TensorProduct.map σ.toAlgHom (AlgHom.id K M) (x : L ⊗[K] M) = x) :
    ∃ m : Mˣ, Units.map Algebra.TensorProduct.includeRight.toMonoidHom m = x := by
  obtain ⟨m, hm⟩ := tensor_invariant_descends K L M (x : L ⊗[K] M) hx
  have hm0 : m ≠ 0 := by
    intro hz
    simp only [hz, TensorProduct.tmul_zero] at hm
    exact (Units.ne_zero x) hm.symm
  exact ⟨Units.mk0 m hm0, Units.ext hm⟩

open scoped TensorProduct

 

lemma tensor_galois_coefficient
    (K L M : Type*) [Field K] [Field L] [CommRing M]
    [Algebra K L] [Algebra K M] [IsGalois K L] [Module.Finite K L]
    {ι : Type*} [Fintype ι] [DecidableEq ι] (b : Module.Basis ι K L)
    (i : ι) (x : M ⊗[K] L) :
    (b.baseChange M).repr x i ⊗ₜ[K] (1 : L) =
      ∑ σ : Gal(L/K), Algebra.TensorProduct.map (AlgHom.id K M) σ.toAlgHom
        ((1 : M) ⊗ₜ[K] b.traceDual i * x) := by
  classical
  have hb (l : L) : b.repr l i = Algebra.trace K L (l * b.traceDual i) := by
    simpa only [Module.Basis.traceDual_traceDual, Algebra.traceForm_apply] using
      (b.traceDual.traceDual_repr_apply l i)
  induction x using TensorProduct.inductionOn with
  | tmul m l =>
      simp only [Module.Basis.baseChange_repr_tmul, Algebra.TensorProduct.tmul_mul_tmul,
        one_mul, Algebra.TensorProduct.map_tmul, AlgHom.id_apply, AlgEquiv.coe_toAlgHom]
      rw [← TensorProduct.tmul_sum, ← trace_eq_sum_automorphisms,
        mul_comm (b.traceDual i), ← hb]
      rw [TensorProduct.smul_tmul, Algebra.smul_def, mul_one]
  | add x y hx hy =>
      simp only [map_add, Finsupp.add_apply, TensorProduct.add_tmul, mul_add, Finset.sum_add_distrib,
        hx, hy]

 
noncomputable def tensorRightGaloisAlgHom
    (K A L M : Type*) [Field K] [CommRing A] [Field L] [CommRing M]
    [Algebra K A] [Algebra K L] [Algebra K M] [Algebra A M] [IsScalarTower K A M]
    (σ : Gal(L/K)) : (M ⊗[K] L) →ₐ[A] (M ⊗[K] L) where
  __ := (Algebra.TensorProduct.map (AlgHom.id K M) σ.toAlgHom).toRingHom
  commutes' a := by
    change Algebra.TensorProduct.map (AlgHom.id K M) σ.toAlgHom
      (algebraMap A M a ⊗ₜ[K] (1 : L)) = algebraMap A M a ⊗ₜ[K] (1 : L)
    simp

lemma tensorFraction_isScalarTower
    (K A L M : Type*) [Field K] [CommRing A] [Field L] [Field M]
    [Algebra K A] [Algebra K L] [Algebra K M] [Algebra A M] [IsScalarTower K A M] :
    letI := tensorFractionAlgebra K A L M
    IsScalarTower A (A ⊗[K] L) (M ⊗[K] L) := by
  let := tensorFractionAlgebra K A L M
  apply IsScalarTower.of_algebraMap_eq
  intro a
  change _ = Algebra.TensorProduct.map (IsScalarTower.toAlgHom K A M) (AlgHom.id K L)
    (a ⊗ₜ[K] (1 : L))
  simp

 

theorem tensor_isIntegrallyClosed_of_galois
    (K A L M : Type*) [Field K] [CommRing A] [IsDomain A] [Field L] [Field M]
    [Algebra K A] [Algebra K L] [Algebra K M] [Algebra A M] [IsScalarTower K A M]
    [IsFractionRing A M] [IsIntegrallyClosed A] [IsGalois K L] [Module.Finite K L]
    [IsDomain (A ⊗[K] L)] : IsIntegrallyClosed (A ⊗[K] L) := by
  classical
  let := tensorFractionAlgebra K A L M
  let := tensorFraction_isScalarTower K A L M
  let := tensorFraction_isFractionRing K A L M
  let := tensorFractionField K A L M
  apply (isIntegrallyClosed_iff (M ⊗[K] L)).mpr
  intro x hx
  have hxA : IsIntegral A x := isIntegral_trans x hx
  let b := Module.finBasis K L
  have hint (l : L) : IsIntegral A ((1 : M) ⊗ₜ[K] l) := by
    have h := (Algebra.IsIntegral.isIntegral l : IsIntegral K l).map
      (Algebra.TensorProduct.includeRight : L →ₐ[K] M ⊗[K] L)
    exact h.tower_top
  have hcoeff (i) : ∃ a : A, algebraMap A M a = (b.baseChange M).repr x i := by
    apply IsIntegrallyClosed.isIntegral_iff.mp
    apply (isIntegral_algebraMap_iff (B := M ⊗[K] L)).mp
    change IsIntegral A ((b.baseChange M).repr x i ⊗ₜ[K] (1 : L))
    rw [tensor_galois_coefficient K L M b i x]
    exact IsIntegral.sum _ fun σ _ => (hint (b.traceDual i) |>.mul hxA).map
      (tensorRightGaloisAlgHom K A L M σ)
  choose a ha using hcoeff
  refine ⟨∑ i, a i ⊗ₜ[K] b i, ?_⟩
  rw [map_sum, ← (b.baseChange M).sum_repr x]
  apply Finset.sum_congr rfl
  intro i _
  change Algebra.TensorProduct.map (IsScalarTower.toAlgHom K A M) (AlgHom.id K L)
    (a i ⊗ₜ[K] b i) = _
  simp only [Algebra.TensorProduct.map_tmul, IsScalarTower.toAlgHom_apply,
    AlgHom.id_apply, ha, Module.Basis.baseChange_apply, TensorProduct.smul_tmul', smul_eq_mul,
    mul_one]

end RelativeDenominators
end

end OAI