import Mathlib.LinearAlgebra.TensorProduct.Basic
import Mathlib.LinearAlgebra.Quotient.Basic
import Mathlib.RingTheory.TensorProduct.Finite
import Mathlib.Algebra.Algebra.Opposite

namespace OAI

namespace ArExplicit

open TensorProduct

variable (k R F M : Type*) [CommRing k] [Ring R]
variable [AddCommGroup F] [AddCommGroup M] [Module k F] [Module k M]
variable [Module Rᵐᵒᵖ F] [Module R M]

def balancingRelations : Submodule k (F ⊗[k] M) :=
  Submodule.span k {z | ∃ (f : F) (r : R) (m : M),
    z = (MulOpposite.op r • f) ⊗ₜ[k] m - f ⊗ₜ[k] (r • m)}

abbrev BalancedTensor := (F ⊗[k] M) ⧸ balancingRelations k R F M

namespace BalancedTensor

variable {k R F M}

def tmul (f : F) (m : M) : BalancedTensor k R F M :=
  (balancingRelations k R F M).mkQ (f ⊗ₜ[k] m)

@[simp] theorem zero_tmul (m : M) : tmul (k := k) (R := R) (0 : F) m = 0 := by
  simp [tmul]

@[simp] theorem tmul_zero (f : F) : tmul (k := k) (R := R) f (0 : M) = 0 := by
  simp [tmul]

theorem add_tmul (f g : F) (m : M) :
    tmul (k := k) (R := R) (f + g) m = tmul f m + tmul g m := by simp [tmul, TensorProduct.add_tmul]

theorem tmul_add (f : F) (m n : M) :
    tmul (k := k) (R := R) f (m + n) = tmul f m + tmul f n := by simp [tmul, TensorProduct.tmul_add]

theorem scalar_tmul (c : k) (f : F) (m : M) :
    tmul (k := k) (R := R) (c • f) m = c • tmul f m := by
  exact (balancingRelations k R F M).mkQ.map_smul c (f ⊗ₜ[k] m)

theorem tmul_scalar (c : k) (f : F) (m : M) :
    tmul (k := k) (R := R) f (c • m) = c • tmul f m := by simp [tmul]

theorem balance (f : F) (r : R) (m : M) :
    tmul (k := k) (R := R) (MulOpposite.op r • f) m = tmul f (r • m) := by
  apply (Submodule.Quotient.eq (balancingRelations k R F M)).mpr
  exact Submodule.subset_span ⟨f, r, m, rfl⟩

def mk : F →ₗ[k] M →ₗ[k] BalancedTensor k R F M where
  toFun f :=
    { toFun := tmul f
      map_add' := tmul_add f
      map_smul' := fun c m => tmul_scalar c f m }
  map_add' f g := by ext m; exact add_tmul f g m
  map_smul' c f := by ext m; exact scalar_tmul c f m

variable {N : Type*} [AddCommGroup N] [Module k N]

def lift (b : F →ₗ[k] M →ₗ[k] N)
    (hb : ∀ (f : F) (r : R) (m : M), b (MulOpposite.op r • f) m = b f (r • m)) :
    BalancedTensor k R F M →ₗ[k] N :=
  (balancingRelations k R F M).liftQ (TensorProduct.lift b) (by
    apply Submodule.span_le.mpr
    rintro z ⟨f, r, m, rfl⟩
    change TensorProduct.lift b ((MulOpposite.op r • f) ⊗ₜ[k] m - f ⊗ₜ[k] (r • m)) = 0
    simp only [map_sub, TensorProduct.lift.tmul, hb, sub_self])

@[simp] theorem lift_tmul (b : F →ₗ[k] M →ₗ[k] N)
    (hb : ∀ (f : F) (r : R) (m : M), b (MulOpposite.op r • f) m = b f (r • m)) (f : F) (m : M) :
    lift b hb (tmul f m) = b f m := rfl

@[ext] theorem hom_ext (f g : BalancedTensor k R F M →ₗ[k] N)
    (h : ∀ x y, f (tmul x y) = g (tmul x y)) : f = g := by
  apply LinearMap.ext
  intro z
  induction z using Submodule.Quotient.induction_on with
  | H z =>
      induction z using TensorProduct.inductionOn with
      | tmul x y => exact h x y
      | add z z' hz hz' =>
          change f ((balancingRelations k R F M).mkQ (z + z')) =
            g ((balancingRelations k R F M).mkQ (z + z'))
          simp only [map_add]
          exact congrArg₂ (· + ·) hz hz'

end BalancedTensor
end ArExplicit

end OAI