import OAI.Algebra.AuslanderReiten.Tensor.BalancedTensorAction

namespace OAI

namespace ArExplicit.BalancedTensor

open TensorProduct

variable {k R F M N : Type*} [CommRing k] [Ring R]
variable [AddCommGroup F] [AddCommGroup M] [Module k F] [Module k M]
variable [Module Rᵐᵒᵖ F] [Module R M]

@[elab_as_elim] theorem induction_on {motive : BalancedTensor k R F M → Prop}
    (z : BalancedTensor k R F M) (zero : motive 0)
    (tmul : ∀ f m, motive (tmul f m))
    (add : ∀ x y, motive x → motive y → motive (x + y)) : motive z := by
  classical
  by_cases hz : z = 0
  · simpa only [hz] using zero
  clear hz
  induction z using Submodule.Quotient.induction_on with
  | H z =>
    induction z using TensorProduct.inductionOn with
    | tmul f m => exact tmul f m
    | add x y hx hy => exact add _ _ hx hy

variable {F' M' : Type*} [AddCommGroup F'] [AddCommGroup M']
variable [Module k F'] [Module k M'] [Module Rᵐᵒᵖ F'] [Module R M']

def map (a : F →ₗ[k] F') (b : M →ₗ[k] M')
    (ha : ∀ (r : Rᵐᵒᵖ) f, a (r • f) = r • a f)
    (hb : ∀ (r : R) m, b (r • m) = r • b m) :
    BalancedTensor k R F M →ₗ[k] BalancedTensor k R F' M' :=
  lift
    { toFun := fun f => (mk (a f)).comp b
      map_add' := by intros; ext m; simp
      map_smul' := by intros; ext m; simp }
    (by
      intro f r m
      change tmul (a (MulOpposite.op r • f)) (b m) = tmul (a f) (b (r • m))
      rw [ha, hb, balance])

@[simp] theorem map_tmul (a : F →ₗ[k] F') (b : M →ₗ[k] M')
    (ha : ∀ (r : Rᵐᵒᵖ) f, a (r • f) = r • a f)
    (hb : ∀ (r : R) m, b (r • m) = r • b m) (f : F) (m : M) :
    map a b ha hb (tmul f m) = tmul (a f) (b m) := rfl

theorem map_surjective (a : F →ₗ[k] F') (b : M →ₗ[k] M')
    (ha : ∀ (r : Rᵐᵒᵖ) f, a (r • f) = r • a f)
    (hb : ∀ (r : R) m, b (r • m) = r • b m)
    (asurj : Function.Surjective a) (bsurj : Function.Surjective b) :
    Function.Surjective (map a b ha hb) := by
  intro z
  induction z using induction_on with
  | zero => exact ⟨0, map_zero _⟩
  | tmul f m =>
    obtain ⟨f, rfl⟩ := asurj f
    obtain ⟨m, rfl⟩ := bsurj m
    exact ⟨tmul f m, rfl⟩
  | add x y hx hy =>
    obtain ⟨x, rfl⟩ := hx
    obtain ⟨y, rfl⟩ := hy
    exact ⟨x + y, map_add _ x y⟩

section LeftLinear

variable {S : Type*} [Ring S] [AddCommGroup N] [Module k N]
variable [Module S F] [Module S N]
variable [SMulCommClass k S F] [SMulCommClass S Rᵐᵒᵖ F]

def liftLeft (b : F →ₗ[k] M →ₗ[k] N)
    (hb : ∀ (f : F) (r : R) (m : M), b (MulOpposite.op r • f) m = b f (r • m))
    (hs : ∀ (s : S) f m, b (s • f) m = s • b f m) :
    BalancedTensor k R F M →ₗ[S] N where
  __ := (lift b hb).toAddHom
  map_smul' s z := by
    change lift b hb (s • z) = s • lift b hb z
    induction z using induction_on with
    | zero => simp
    | tmul f m => simpa only [smul_tmul, lift_tmul, RingHom.id_apply] using hs s f m
    | add x y hx hy => simp only [smul_add, map_add] at *; rw [hx, hy]

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

end LeftLinear

end ArExplicit.BalancedTensor

end OAI