import OAI.Algebra.Finitistic.Ordinary.OrdinaryAssociativeTensorModules
import Mathlib.Tactic.Abel

namespace OAI
noncomputable section
namespace LittleFinitistic.BalancedAssociativity
open BalancedTensor
universe u
variable (k A B M N Z : Type u) [Field k] [Ring A] [Ring B] [Algebra k A] [Algebra k B]
variable [AddCommGroup M] [Module k M] [Module Aᵐᵒᵖ M]
variable [AddCommGroup N] [Module k N] [Module A N] [Module Bᵐᵒᵖ N]
  [IsScalarTower k A N] [IsScalarTower k Bᵐᵒᵖ N] [SMulCommClass A Bᵐᵒᵖ N]
variable [AddCommGroup Z] [Module k Z] [Module B Z]

abbrev Left := Tensor k B (RightTensor k A B M N) Z
abbrev Right := Tensor k A M (LeftTensor k B A N Z)

/-- Reassociate a fixed last input through the actual A-balanced quotient. -/
def forwardAt (z : Z) : RightTensor k A B M N →ₗ[k] Right k A B M N Z :=
  lift ((mk k A M (LeftTensor k B A N Z)).compl₁₂ LinearMap.id ((LeftTensor.mk k A B N Z).flip z)) (by
    intro a m n
    change mk k A M (LeftTensor k B A N Z) (MulOpposite.op a • m) (LeftTensor.mk k A B N Z n z) =
      mk k A M (LeftTensor k B A N Z) m (LeftTensor.mk k A B N Z (a • n) z)
    rw [balance,LeftTensor.smul_mk])

@[simp] theorem forwardAt_mk (m : M) (n : N) (z : Z) :
    forwardAt k A B M N Z z (RightTensor.mk k A B M N m n) =
      mk k A M (LeftTensor k B A N Z) m (LeftTensor.mk k A B N Z n z) := rfl

def forwardBilinear : RightTensor k A B M N →ₗ[k] Z →ₗ[k] Right k A B M N Z where
  toFun x :=
    { toFun := fun z => forwardAt k A B M N Z z x
      map_add' := fun z z' => by
        have h : forwardAt k A B M N Z (z+z') =
            forwardAt k A B M N Z z + forwardAt k A B M N Z z' := by
          apply BalancedTensor.ext
          intro m n
          change mk k A M (LeftTensor k B A N Z) m (LeftTensor.mk k A B N Z n (z+z')) =
            mk k A M (LeftTensor k B A N Z) m (LeftTensor.mk k A B N Z n z) +
            mk k A M (LeftTensor k B A N Z) m (LeftTensor.mk k A B N Z n z')
          simp only [map_add]
        exact congrArg (fun f => f x) h
      map_smul' := fun r z => by
        have h : forwardAt k A B M N Z (r • z) = r • forwardAt k A B M N Z z := by
          apply BalancedTensor.ext
          intro m n
          change mk k A M (LeftTensor k B A N Z) m (LeftTensor.mk k A B N Z n (r • z)) =
            r • mk k A M (LeftTensor k B A N Z) m (LeftTensor.mk k A B N Z n z)
          simp only [map_smul]
        exact congrArg (fun f => f x) h }
  map_add' x y := by ext z; exact (forwardAt k A B M N Z z).map_add x y
  map_smul' r x := by ext z; exact (forwardAt k A B M N Z z).map_smul r x

/-- The actual forward associativity map of balanced tensors. -/
def forward : Left k A B M N Z →ₗ[k] Right k A B M N Z :=
  lift (forwardBilinear k A B M N Z) (by
    intro b x z
    have h : (forwardAt k A B M N Z z).comp (RightTensor.action k A B M N (MulOpposite.op b)) =
        forwardAt k A B M N Z (b • z) := by
      apply BalancedTensor.ext
      intro m n
      change forwardAt k A B M N Z z (MulOpposite.op b • RightTensor.mk k A B M N m n) =
        forwardAt k A B M N Z (b • z) (RightTensor.mk k A B M N m n)
      rw [RightTensor.smul_mk,forwardAt_mk,forwardAt_mk]
      exact congrArg (mk k A M (LeftTensor k B A N Z) m) (balance b n z)
    exact congrArg (fun f => f x) h)


@[simp] theorem forward_mk (m : M) (n : N) (z : Z) :
    forward k A B M N Z (mk k B (RightTensor k A B M N) Z (RightTensor.mk k A B M N m n) z) =
      mk k A M (LeftTensor k B A N Z) m (LeftTensor.mk k A B N Z n z) := rfl

/-- Reassociate a fixed first input through the actual B-balanced quotient. -/
def inverseAt (m : M) : LeftTensor k B A N Z →ₗ[k] Left k A B M N Z :=
  lift ((mk k B (RightTensor k A B M N) Z).compl₁₂ (RightTensor.mk k A B M N m) LinearMap.id) (by
    intro b n z
    change mk k B (RightTensor k A B M N) Z (RightTensor.mk k A B M N m (MulOpposite.op b • n)) z =
      mk k B (RightTensor k A B M N) Z (RightTensor.mk k A B M N m n) (b • z)
    rw [← RightTensor.smul_mk,balance])

@[simp] theorem inverseAt_mk (m : M) (n : N) (z : Z) :
    inverseAt k A B M N Z m (LeftTensor.mk k A B N Z n z) =
      mk k B (RightTensor k A B M N) Z (RightTensor.mk k A B M N m n) z := rfl

def inverseBilinear : M →ₗ[k] LeftTensor k B A N Z →ₗ[k] Left k A B M N Z where
  toFun := inverseAt k A B M N Z
  map_add' m m' := by
    apply BalancedTensor.ext
    intro n z
    change mk k B (RightTensor k A B M N) Z (RightTensor.mk k A B M N (m+m') n) z =
      mk k B (RightTensor k A B M N) Z (RightTensor.mk k A B M N m n) z +
      mk k B (RightTensor k A B M N) Z (RightTensor.mk k A B M N m' n) z
    simp only [map_add,LinearMap.add_apply]
  map_smul' r m := by
    apply BalancedTensor.ext
    intro n z
    change mk k B (RightTensor k A B M N) Z (RightTensor.mk k A B M N (r • m) n) z =
      r • mk k B (RightTensor k A B M N) Z (RightTensor.mk k A B M N m n) z
    simp only [map_smul,LinearMap.smul_apply]

/-- The actual inverse associativity map of balanced tensors. -/
def inverse : Right k A B M N Z →ₗ[k] Left k A B M N Z :=
  lift (inverseBilinear k A B M N Z) (by
    intro a m x
    have h : inverseAt k A B M N Z (MulOpposite.op a • m) =
        (inverseAt k A B M N Z m).comp (LeftTensor.action k A B N Z a) := by
      apply BalancedTensor.ext
      intro n z
      change inverseAt k A B M N Z (MulOpposite.op a • m) (LeftTensor.mk k A B N Z n z) =
        inverseAt k A B M N Z m (a • LeftTensor.mk k A B N Z n z)
      rw [LeftTensor.smul_mk,inverseAt_mk,inverseAt_mk]
      exact congrArg (fun y => mk k B (RightTensor k A B M N) Z y z) (balance a m n)
    exact congrArg (fun f => f x) h)


@[simp] theorem inverse_mk (m : M) (n : N) (z : Z) :
    inverse k A B M N Z (mk k A M (LeftTensor k B A N Z) m (LeftTensor.mk k A B N Z n z)) =
      mk k B (RightTensor k A B M N) Z (RightTensor.mk k A B M N m n) z := rfl

/-- Associativity of the actual noncommutative balanced tensor, with no flatness hypotheses. -/
def equivalence : Left k A B M N Z ≃ₗ[k] Right k A B M N Z where
  __ := forward k A B M N Z
  invFun := inverse k A B M N Z
  left_inv x := by
    let F := (inverse k A B M N Z).comp (forward k A B M N Z)
    have h : F = LinearMap.id := by
      apply BalancedTensor.ext
      intro y z
      have hz : F.comp ((mk k B (RightTensor k A B M N) Z).flip z) =
          (mk k B (RightTensor k A B M N) Z).flip z := by
        apply BalancedTensor.ext
        intro m n
        rfl
      exact congrArg (fun f => f y) hz
    exact congrArg (fun f => f x) h
  right_inv x := by
    let F := (forward k A B M N Z).comp (inverse k A B M N Z)
    have h : F = LinearMap.id := by
      apply BalancedTensor.ext
      intro m y
      have hm : F.comp (mk k A M (LeftTensor k B A N Z) m) =
          mk k A M (LeftTensor k B A N Z) m := by
        apply BalancedTensor.ext
        intro n z
        rfl
      exact congrArg (fun f => f y) hm
    exact congrArg (fun f => f x) h

end LittleFinitistic.BalancedAssociativity

end

end OAI