import Mathlib

namespace OAI
noncomputable section
open scoped Topology BoundedContinuousFunction
namespace FlatRecursion
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℂ E]
def shift (n : ℤ) : C(ℤ,ℤ) := ⟨fun j => j-n, continuous_of_discreteTopology⟩
def greenTerm (G : E →L[ℂ] E) (n : ℤ) : (ℤ →ᵇ E) →L[ℂ] (ℤ →ᵇ E) :=
  (G.compLeftContinuousBounded ℤ).comp (BoundedContinuousFunction.compContinuousCLM E ℂ (shift n))
@[simp] lemma greenTerm_apply (G : E →L[ℂ] E) (n : ℤ) (f : ℤ →ᵇ E) (j : ℤ) :
    greenTerm G n f j=G (f (j-n)) := rfl
lemma greenTerm_norm (G : E →L[ℂ] E) (n : ℤ) : ‖greenTerm G n‖≤‖G‖ := by
  refine ContinuousLinearMap.opNorm_le_bound _ (norm_nonneg G) (fun f => ?_)
  refine (BoundedContinuousFunction.norm_le (mul_nonneg (norm_nonneg _) (norm_nonneg _))).mpr ?_
  intro j
  exact G.le_opNorm_of_le (f.norm_coe_le_norm (j-n))
variable [CompleteSpace E]
lemma greenTerm_summable (G : ℤ → E →L[ℂ] E) (hG : Summable (fun n => ‖G n‖)) :
    Summable (fun n => greenTerm (G n) n) :=
  Summable.of_norm_bounded hG (fun index => greenTerm_norm (G index) index)
def greenOperator (G : ℤ → E →L[ℂ] E) : (ℤ →ᵇ E) →L[ℂ] (ℤ →ᵇ E) :=
  ∑' n : ℤ, greenTerm (G n) n
lemma convolution_summable (G : ℤ → E →L[ℂ] E) (hG : Summable (fun n => ‖G n‖))
    (f : ℤ →ᵇ E) (j : ℤ) : Summable (fun n => G n (f (j-n))) := by
  refine Summable.of_norm_bounded (hG.mul_right ‖f‖) (fun n => ?_)
  exact (G n).le_opNorm_of_le (f.norm_coe_le_norm _)
lemma greenOperator_apply (G : ℤ → E →L[ℂ] E) (hG : Summable (fun n => ‖G n‖))
    (f : ℤ →ᵇ E) (j : ℤ) : greenOperator G f j=∑' n : ℤ, G n (f (j-n)) := by
  exact ((BoundedContinuousFunction.evalCLM ℂ j).comp
    (ContinuousLinearMap.apply ℂ (ℤ →ᵇ E) f)).map_tsum (greenTerm_summable G hG)
lemma greenOperator_solves (P : E →L[ℂ] E) (q : ℂ) (G : ℤ → E →L[ℂ] E)
    (hG : Summable (fun n => ‖G n‖))
    (hrec : ∀ n : ℤ, q • G (n+1)-P*G n=if n=0 then 1 else 0)
    (f : ℤ →ᵇ E) (j : ℤ) : q • greenOperator G f (j+1)=P (greenOperator G f j)+f j := by
  have hs := convolution_summable G hG f j
  have hs' := convolution_summable G hG f (j+1)
  have hshift : (∑' n : ℤ, G n (f (j+1-n)))=∑' n : ℤ, G (n+1) (f (j-n)) := by
    rw [← (Equiv.addRight (1:ℤ)).tsum_eq]
    congr 1
    funext n
    simp only [Equiv.coe_addRight]
    congr 2
    omega
  have hs2 : Summable (fun n : ℤ => G (n+1) (f (j-n))) := by
    convert hs'.comp_injective (i := fun n : ℤ => n+1) (fun a b h => add_right_cancel h) using 1
    funext n
    dsimp
    congr 2
    omega
  rw [greenOperator_apply G hG, greenOperator_apply G hG, hshift]
  apply sub_eq_zero.mp
  rw [sub_add_eq_sub_sub, P.map_tsum hs, ← Summable.tsum_const_smul q hs2, ← Summable.tsum_sub (Summable.const_smul q hs2) (P.summable hs)]
  have he : (fun n : ℤ => q • G (n+1) (f (j-n))-P (G n (f (j-n))))=
      (fun n : ℤ => if n=0 then f j else 0) := by
    funext n
    have hn := congrArg (fun L : E →L[ℂ] E => L (f (j-n))) (hrec n)
    by_cases hn0 : n=0
    · simpa [hn0] using hn
    · simpa [hn0] using hn
  rw [he, tsum_ite_eq, sub_self]
end FlatRecursion

end

end OAI