import OAI.Algebra.AuslanderReiten.Tensor.BalancedTensorMap
import Mathlib.Algebra.Module.Projective

namespace OAI

noncomputable section
namespace ArExplicit.BalancedTensor

universe u
variable {k R F G Q X : Type u} [Field k] [Ring R] [Algebra k R]
variable [AddCommGroup F] [Module k F] [Module Rᵐᵒᵖ F] [IsScalarTower k Rᵐᵒᵖ F]
variable [AddCommGroup G] [Module k G] [Module Rᵐᵒᵖ G] [IsScalarTower k Rᵐᵒᵖ G]
variable [AddCommGroup Q] [Module k Q] [Module Rᵐᵒᵖ Q] [IsScalarTower k Rᵐᵒᵖ Q]
variable [AddCommGroup X] [Module k X] [Module R X] [IsScalarTower k R X]

def mapFirst (X : Type u) [AddCommGroup X] [Module k X] [Module R X]
    (f : F →ₗ[Rᵐᵒᵖ] G) : BalancedTensor k R F X →ₗ[k] BalancedTensor k R G X :=
  map (f.restrictScalars k) (LinearMap.id : X →ₗ[k] X)
    (fun a x => f.map_smul a x) (fun _ _ => rfl)

omit [IsScalarTower k R X] in
@[simp] theorem mapFirst_tmul (f : F →ₗ[Rᵐᵒᵖ] G) (m : F) (x : X) :
    mapFirst (k := k) X f (tmul m x) = tmul (f m) x := rfl

omit [IsScalarTower k R X] in
@[simp] theorem mapFirst_id : mapFirst (k := k) X (LinearMap.id : F →ₗ[Rᵐᵒᵖ] F) = LinearMap.id := by
  apply LinearMap.ext
  intro z
  induction z using induction_on with
  | zero => simp
  | tmul f x => rfl
  | add z w hz hw => simp_all

omit [IsScalarTower k R X] in
@[simp] theorem mapFirst_comp (f : F →ₗ[Rᵐᵒᵖ] G) (g : G →ₗ[Rᵐᵒᵖ] Q) :
    mapFirst (k := k) X (g.comp f) = (mapFirst (k := k) X g).comp (mapFirst (k := k) X f) := by
  apply LinearMap.ext
  intro z
  induction z using induction_on with
  | zero => simp
  | tmul f x => rfl
  | add z w hz hw => simp_all

omit [IsScalarTower k R X] in
@[simp] theorem mapFirst_add (f g : F →ₗ[Rᵐᵒᵖ] G) :
    mapFirst (k := k) X (f + g) = mapFirst (k := k) X f + mapFirst (k := k) X g := by
  apply LinearMap.ext
  intro z
  induction z using induction_on with
  | zero => simp
  | tmul f x => simp [BalancedTensor.add_tmul]
  | add z w hz hw => simp_all [add_left_comm, add_comm]

omit [IsScalarTower k R X] in
@[simp] theorem mapFirst_zero : mapFirst (k := k) X (0 : F →ₗ[Rᵐᵒᵖ] G) = 0 := by
  apply LinearMap.ext
  intro z
  induction z using induction_on with
  | zero => simp
  | tmul f x => simp
  | add z w hz hw => simp_all

theorem exists_splitting (f : F →ₗ[Rᵐᵒᵖ] G) (g : G →ₗ[Rᵐᵒᵖ] Q)
    (hf : Function.Injective f) (hg : Function.Surjective g)
    (he : LinearMap.range f = LinearMap.ker g) [Module.Projective Rᵐᵒᵖ Q] :
    ∃ c : G →ₗ[Rᵐᵒᵖ] F, ∃ s : Q →ₗ[Rᵐᵒᵖ] G,
      c.comp f = LinearMap.id ∧ g.comp s = LinearMap.id ∧
        f.comp c + s.comp g = LinearMap.id := by
  obtain ⟨s, hs⟩ := Module.projective_lifting_property g (LinearMap.id : Q →ₗ[Rᵐᵒᵖ] Q) hg
  let e : F ≃ₗ[Rᵐᵒᵖ] LinearMap.range f := LinearEquiv.ofBijective f.rangeRestrict
    ⟨fun x y h => hf (congrArg Subtype.val h), by
      rintro ⟨y, x, rfl⟩
      exact ⟨x, rfl⟩⟩
  let r : G →ₗ[Rᵐᵒᵖ] LinearMap.range f :=
    { toFun := fun y => ⟨y - s (g y), by
        rw [he]
        change g (y - s (g y)) = 0
        rw [map_sub, show g (s (g y)) = g y from DFunLike.congr_fun hs (g y), sub_self]⟩
      map_add' a b := by
        apply Subtype.ext
        change a + b - s (g (a + b)) = (a - s (g a)) + (b - s (g b))
        simp only [map_add, add_sub_add_comm]
      map_smul' a b := by
        apply Subtype.ext
        change a • b - s (g (a • b)) = a • (b - s (g b))
        simp only [map_smul, smul_sub] }
  let c : G →ₗ[Rᵐᵒᵖ] F := e.symm.toLinearMap.comp r
  have hc (y : G) : f (c y) = y - s (g y) := by
    exact congrArg Subtype.val (e.apply_symm_apply (r y))
  have hgf : g.comp f = 0 := LinearMap.range_le_ker_iff.mp he.le
  refine ⟨c, s, ?_, hs, ?_⟩
  · apply LinearMap.ext
    intro x
    apply hf
    rw [LinearMap.comp_apply, hc]
    have hz : g (f x) = 0 := DFunLike.congr_fun hgf x
    simp [hz]
  · apply LinearMap.ext
    intro y
    change f (c y) + s (g y) = y
    rw [hc, sub_add_cancel]

omit [IsScalarTower k R X] in
theorem mapFirst_shortExact (f : F →ₗ[Rᵐᵒᵖ] G) (g : G →ₗ[Rᵐᵒᵖ] Q)
    (hf : Function.Injective f) (hg : Function.Surjective g)
    (he : LinearMap.range f = LinearMap.ker g) [Module.Projective Rᵐᵒᵖ Q] :
    Function.Injective (mapFirst (k := k) X f) ∧ Function.Surjective (mapFirst (k := k) X g) ∧
      LinearMap.range (mapFirst (k := k) X f) = LinearMap.ker (mapFirst (k := k) X g) := by
  obtain ⟨c, s, hcf, hgs, hsum⟩ := exists_splitting f g hf hg he
  have hcf' : (mapFirst (k := k) X c).comp (mapFirst (k := k) X f) = LinearMap.id := by
    rw [← mapFirst_comp, hcf, mapFirst_id]
  have hgs' : (mapFirst (k := k) X g).comp (mapFirst (k := k) X s) = LinearMap.id := by
    rw [← mapFirst_comp, hgs, mapFirst_id]
  have hsum' : (mapFirst (k := k) X f).comp (mapFirst (k := k) X c) +
      (mapFirst (k := k) X s).comp (mapFirst (k := k) X g) = LinearMap.id := by
    rw [← mapFirst_comp, ← mapFirst_comp, ← mapFirst_add, hsum, mapFirst_id]
  have hgf : g.comp f = 0 := LinearMap.range_le_ker_iff.mp he.le
  have hgf' : (mapFirst (k := k) X g).comp (mapFirst (k := k) X f) = 0 := by
    rw [← mapFirst_comp, hgf, mapFirst_zero]
  refine ⟨?_, ?_, le_antisymm (LinearMap.range_le_ker_iff.mpr hgf') ?_⟩
  · intro x y hxy
    have hx := DFunLike.congr_fun hcf' x
    have hy := DFunLike.congr_fun hcf' y
    change mapFirst (k := k) X c (mapFirst (k := k) X f x) = x at hx
    change mapFirst (k := k) X c (mapFirst (k := k) X f y) = y at hy
    rw [← hx, ← hy, hxy]
  · intro z
    exact ⟨mapFirst (k := k) X s z, DFunLike.congr_fun hgs' z⟩
  · intro z hz
    refine ⟨mapFirst (k := k) X c z, ?_⟩
    have h := DFunLike.congr_fun hsum' z
    change mapFirst (k := k) X f (mapFirst (k := k) X c z) + mapFirst (k := k) X s (mapFirst (k := k) X g z) = z at h
    simpa only [show mapFirst (k := k) X g z = 0 from hz, map_zero, add_zero] using h

end ArExplicit.BalancedTensor

end

end OAI