import Mathlib
import OAI.Combinatorics.Chromatic.Shuffle.GlobalPrimitiveLog
import OAI.Combinatorics.Chromatic.GradedAlgebra.NilpotentSeriesInverse

namespace OAI

section
namespace ElementaryPositivity.RawShuffle
open scoped TensorProduct DirectSum
open WithConv ElementaryPositivity.FiniteLog
variable {I : Type*} [Fintype I] [DecidableEq I]
attribute [local instance] Classical.propDecidable
variable (a : I → I → ℕ) (c η : I → ℝ) (hc : ∀ i,0<c i) (θ : ℝ)
  [Fact (SlopeEulerSymmetric a c η θ)]
variable {A : Type*} [Ring A] [Algebra ℚ A]

lemma convSeries_exp_log {f : WithConv (UnitalShuffle a c η hc θ →ₗ[ℚ] A)}
    (hf : convVanishes a c η hc θ 1 f) :
    convSeries a c η hc θ (convSeries a c η hc θ f (PowerSeries.log ℚ)) (PowerSeries.exp ℚ)=1+f := by
  apply convolutionProjection_jointly_injective a c η hc θ
  intro n
  rw [convolutionProjection_series a c η hc θ n
    (convSeries_order_one a c η hc θ (PowerSeries.log ℚ) (PowerSeries.constantCoeff_log (A := ℚ))),
    convolutionProjection_series a c η hc θ n hf,map_add,map_one]
  exact nilEval_exp_log ⟨n,convolutionProjection_nilpotent a c η hc θ n hf⟩

theorem globalPrimitiveLog_exponential :
    convSeries a c η hc θ (toConv (globalPrimitiveLog a c η hc θ)) (PowerSeries.exp ℚ)=
      toConv (LinearMap.id : UnitalShuffle a c η hc θ →ₗ[ℚ] UnitalShuffle a c η hc θ) := by
  have h := convSeries_exp_log a c η hc θ (convolutionJ_vanishes a c η hc θ)
  change convSeries a c η hc θ (toConv (globalPrimitiveLog a c η hc θ)) (PowerSeries.exp ℚ)=_ at h
  rw [convolutionJ] at h
  convert h using 1; abel

lemma convolution_mapsTo_mul (S : Subalgebra ℚ A)
    {f g : WithConv (UnitalShuffle a c η hc θ →ₗ[ℚ] A)}
    (hf : ∀ x,f.ofConv x ∈ S) (hg : ∀ x,g.ofConv x ∈ S) :
    ∀ x,(f*g).ofConv x ∈ S := by
  intro x
  rw [LinearMap.convMul_apply]
  generalize Coalgebra.comul (R := ℚ) x=t
  induction t using TensorProduct.inductionOn with
  | add t u ht hu => simpa only [map_add] using S.add_mem ht hu
  | tmul x y =>
    rw [TensorProduct.map_tmul,LinearMap.mul'_apply]
    exact S.mul_mem (hf x) (hg y)

lemma convolution_mapsTo_pow (S : Subalgebra ℚ A)
    {f : WithConv (UnitalShuffle a c η hc θ →ₗ[ℚ] A)}
    (hf : ∀ x,f.ofConv x ∈ S) (n : ℕ) : ∀ x,(f^n).ofConv x ∈ S := by
  induction n with
  | zero => intro x; exact S.algebraMap_mem _
  | succ n ih =>
    rw [pow_succ]
    exact convolution_mapsTo_mul a c η hc θ S ih hf

theorem globalPrimitiveLog_adjoin :
    Algebra.adjoin ℚ (Set.range (globalPrimitiveLog a c η hc θ))=⊤ := by
  apply top_unique
  intro x hx
  clear hx
  induction x using DirectSum.induction_on with
  | zero => exact Subalgebra.zero_mem _
  | add x y hx hy => exact Subalgebra.add_mem _ hx hy
  | of k x =>
    let S := Algebra.adjoin ℚ (Set.range (globalPrimitiveLog a c η hc θ))
    have h := congrArg (fun f=>f.ofConv (DirectSum.lof ℚ _ (unitalComponent a c η hc θ) k x))
      (globalPrimitiveLog_exponential a c η hc θ)
    rw [convSeries_lof] at h
    simp only [LinearMap.id_apply] at h
    change DirectSum.lof ℚ _ (unitalComponent a c η hc θ) k x ∈ S
    rw [←h]
    apply Subalgebra.sum_mem
    intro r hr
    exact S.smul_mem (convolution_mapsTo_pow a c η hc θ S
      (fun x=>Algebra.subset_adjoin ⟨x,rfl⟩) r _) _

end ElementaryPositivity.RawShuffle

end
section
namespace ElementaryPositivity.RawShuffle
open scoped TensorProduct DirectSum
open WithConv DimensionSplit
variable {I : Type*} [Fintype I] [DecidableEq I]
attribute [local instance] Classical.propDecidable
variable (a : I → I → ℕ) (c η : I → ℝ) (hc : ∀ i,0<c i) (θ : ℝ)
  [Fact (SlopeEulerSymmetric a c η θ)]

noncomputable def globalHomogeneous (k : SlopeWeight c η hc θ) : Submodule ℚ (UnitalShuffle a c η hc θ) :=
  LinearMap.range (DirectSum.lof ℚ _ (unitalComponent a c η hc θ) k)

def convPreservesWeight (f : WithConv (UnitalShuffle a c η hc θ →ₗ[ℚ] UnitalShuffle a c η hc θ)) : Prop :=
  ∀ k (x : unitalComponent a c η hc θ k),
    f.ofConv (DirectSum.lof ℚ _ (unitalComponent a c η hc θ) k x) ∈ globalHomogeneous a c η hc θ k

lemma globalHomogeneous_mul {k l : SlopeWeight c η hc θ} {x y : UnitalShuffle a c η hc θ}
    (hx : x ∈ globalHomogeneous a c η hc θ k) (hy : y ∈ globalHomogeneous a c η hc θ l) :
    x*y ∈ globalHomogeneous a c η hc θ (k+l) := by
  obtain ⟨x,rfl⟩ := hx
  obtain ⟨y,rfl⟩ := hy
  exact ⟨GradedMonoid.GMul.mul x y,(globalLof_mul a c η hc θ k l x y).symm⟩

lemma convPreservesWeight_one : convPreservesWeight a c η hc θ 1 := by
  intro k x
  change algebraMap ℚ (UnitalShuffle a c η hc θ)
    (globalCounit a c η hc θ (DirectSum.lof ℚ _ (unitalComponent a c η hc θ) k x)) ∈ _
  by_cases hk : k=0
  · subst k
    rw [Algebra.algebraMap_eq_smul_one]
    apply Submodule.smul_mem
    exact ⟨unitalGradeOne a c η hc θ,rfl⟩
  · rw [globalCounit_lof_ne a c η hc θ k hk,map_zero]
    exact Submodule.zero_mem _

omit [Fact (SlopeEulerSymmetric a c η θ)] in
lemma convPreservesWeight_id : convPreservesWeight a c η hc θ (toConv LinearMap.id) :=
  fun _ x=>⟨x,rfl⟩

omit [Fact (SlopeEulerSymmetric a c η θ)] in
lemma convPreservesWeight_sub
    {f g : WithConv (UnitalShuffle a c η hc θ →ₗ[ℚ] UnitalShuffle a c η hc θ)}
    (hf : convPreservesWeight a c η hc θ f) (hg : convPreservesWeight a c η hc θ g) :
    convPreservesWeight a c η hc θ (f-g) :=
  fun k x=>(globalHomogeneous a c η hc θ k).sub_mem (hf k x) (hg k x)

lemma globalTensorGrade_map_homogeneous (d e : slopeDimensions c η hc θ) (W : ℤ)
    (f g : WithConv (UnitalShuffle a c η hc θ →ₗ[ℚ] UnitalShuffle a c η hc θ))
    (hf : convPreservesWeight a c η hc θ f) (hg : convPreservesWeight a c η hc θ g)
    (x : UnitalSourceTensorGrade a c η hc θ d.val e.val W) :
    LinearMap.mul' ℚ (UnitalShuffle a c η hc θ)
      (TensorProduct.map f.ofConv g.ofConv (globalTensorGradeInclusion a c η hc θ d e W x)) ∈
        globalHomogeneous a c η hc θ (d+e,W) := by
  induction x using unitalTensorGrade_induction a c η hc θ d.val e.val W with
  | hz => simpa only [map_zero] using (globalHomogeneous a c η hc θ (d+e,W)).zero_mem
  | ha x y hx hy => simpa only [map_add] using (globalHomogeneous a c η hc θ (d+e,W)).add_mem hx hy
  | ht u x y =>
    rw [globalTensorGradeInclusion_part,TensorProduct.map_tmul,LinearMap.mul'_apply]
    have h := globalHomogeneous_mul a c η hc θ (hf (d,u) x) (hg (e,W-u) y)
    have heq : (d,u)+(e,W-u)=(d+e,W) := by ext <;> simp
    rwa [heq] at h

lemma convPreservesWeight_mul
    {f g : WithConv (UnitalShuffle a c η hc θ →ₗ[ℚ] UnitalShuffle a c η hc θ)}
    (hf : convPreservesWeight a c η hc θ f) (hg : convPreservesWeight a c η hc θ g) :
    convPreservesWeight a c η hc θ (f*g) := by
  intro k x
  rw [LinearMap.convMul_apply]
  change LinearMap.mul' ℚ (UnitalShuffle a c η hc θ) (TensorProduct.map f.ofConv g.ofConv
    (globalCoproduct a c η hc θ (DirectSum.lof ℚ _ (unitalComponent a c η hc θ) k x))) ∈ _
  rw [globalCoproduct_lof]
  simp only [map_sum]
  apply Submodule.sum_mem
  intro s hs
  have h := globalTensorGrade_map_homogeneous a c η hc θ
    ⟨left s.val,s.property.1⟩ ⟨right s.val,s.property.2⟩ k.2 f g hf hg
    (unitalGradeCoproduct a c η hc θ (left s.val) (right s.val)
      (s.property.1.compatible s.property.2) k.2
      (unitalGradeCast a c η hc θ (left_add_right s.val).symm rfl x))
  have heq : (⟨left s.val,s.property.1⟩+⟨right s.val,s.property.2⟩ : slopeDimensions c η hc θ)=k.1 :=
    Subtype.ext (left_add_right s.val)
  rw [heq] at h
  exact h

lemma convPreservesWeight_pow
    {f : WithConv (UnitalShuffle a c η hc θ →ₗ[ℚ] UnitalShuffle a c η hc θ)}
    (hf : convPreservesWeight a c η hc θ f) (n : ℕ) :
    convPreservesWeight a c η hc θ (f^n) := by
  induction n with
  | zero => exact convPreservesWeight_one a c η hc θ
  | succ n ih => rw [pow_succ]; exact convPreservesWeight_mul a c η hc θ ih hf

lemma globalPrimitiveLog_homogeneous :
    convPreservesWeight a c η hc θ (toConv (globalPrimitiveLog a c η hc θ)) := by
  intro k x
  change (convSeries a c η hc θ (convolutionJ a c η hc θ) (PowerSeries.log ℚ)).ofConv _ ∈ _
  rw [convSeries_lof]
  apply Submodule.sum_mem
  intro r hr
  exact Submodule.smul_mem _ _ (convPreservesWeight_pow a c η hc θ
    (convPreservesWeight_sub a c η hc θ (convPreservesWeight_id a c η hc θ)
      (convPreservesWeight_one a c η hc θ)) r k x)

end ElementaryPositivity.RawShuffle

end

end OAI