import OAI.Dynamics.TriangleBilliards.SeamEnergy

namespace OAI

universe uA uC

open MeasureTheory Set
open scoped ENNReal symmDiff
noncomputable section
open MeasureTheory Set Filter Function Metric
open scoped Topology Convolution ContDiff
noncomputable section
open MeasureTheory Set
open scoped ENNReal
noncomputable section
open MeasureTheory Set Filter BoundedContinuousFunction
open scoped ENNReal Topology ComplexConjugate
noncomputable section
open MeasureTheory Set Filter
open scoped Topology ComplexConjugate
noncomputable section

open MeasureTheory Filter
open scoped ComplexConjugate
noncomputable section

namespace TriangularBilliards.Analysis

/-- Fubini for a real bounded spatial kernel.  Both input slices are merely
integrable; neither is differentiated. -/
lemma real_kernel_adjoint_slice {A : Type uA} [MeasurableSpace A]
    {μ : Measure A} [SFinite μ] {k l : A → A → ℝ}
    (hk : StronglyMeasurable (Function.uncurry k)) {K : ℝ}
    (hK : ∀ x y, |k x y| ≤ K) (hs : ∀ x y, k x y = l y x)
    {f g : A → ℂ} (hf : Integrable f μ) (hg : Integrable g μ) :
    (∫ x, (∫ y, k x y • f y ∂μ) * conj (g x) ∂μ) =
      ∫ y, f y * conj (∫ x, l y x • g x ∂μ) ∂μ := by
  have hgc : Integrable (fun x => conj (g x)) μ :=
    hg.norm.mono' (Complex.continuous_conj.comp_aestronglyMeasurable hg.1)
      (Eventually.of_forall fun _ => by simp)
  have hi : Integrable (Function.uncurry (fun x y => (k x y • f y) * conj (g x)))
      (μ.prod μ) := by
    have hh := (hgc.mul_prod hf).bdd_mul
      (Complex.continuous_ofReal.comp_stronglyMeasurable hk).aestronglyMeasurable
      (Eventually.of_forall fun p => by simpa only [Complex.norm_real, Real.norm_eq_abs, Function.uncurry] using hK p.1 p.2)
    convert hh using 1
    ext p
    change (k p.1 p.2 • f p.2) * conj (g p.1) =
      (k p.1 p.2 : ℂ) * (conj (g p.1) * f p.2)
    rw [Complex.real_smul]
    ring
  simp_rw [← integral_mul_const]
  rw [integral_integral_swap hi]
  apply integral_congr_ae
  filter_upwards [] with y
  rw [← integral_conj, ← integral_const_mul]
  apply integral_congr_ae
  filter_upwards [] with x
  rw [hs]
  simp only [Complex.real_smul, map_mul, Complex.conj_ofReal]
  ring

end TriangularBilliards.Analysis

namespace TriangularBilliards.Analysis

def fiberKernel {A : Type uA} {C : Type uC} [MeasurableSpace A] (μ : Measure A)
    (J : C → C) (k : A → A → C → ℝ) (f : A × C → ℂ) (z : A × C) : ℂ :=
  ∫ y, k z.1 y z.2 • f (y, J z.2) ∂μ

/-- The transport-reversing kernel identity gives the adjoint on a product
space.  This is applicable to both the direct term (J = id) and a wall
reflection, including a derivative kernel with the opposite sign. -/
lemma fiberKernel_adjoint {A : Type uA} {C : Type uC} [MeasurableSpace A] [MeasurableSpace C]
    {μ : Measure A} {ν : Measure C} [SFinite μ] [SFinite ν]
    {J : C → C} (hJ : MeasurePreserving J ν ν) (hJe : MeasurableEmbedding J)
    (hJJ : Function.Involutive J) {k l : A → A → C → ℝ}
    (hk : ∀ c, StronglyMeasurable (Function.uncurry (fun x y => k x y c)))
    (hK : ∀ c, ∃ K : ℝ, ∀ x y, |k x y c| ≤ K)
    (hs : ∀ x y c, k x y c = l y x (J c))
    {f g : A × C → ℂ} (hf : Integrable f (μ.prod ν)) (hg : Integrable g (μ.prod ν))
    (hpair₁ : Integrable (fun z => fiberKernel μ J k f z * conj (g z)) (μ.prod ν))
    (hpair₂ : Integrable (fun z => f z * conj (fiberKernel μ J l g z)) (μ.prod ν)) :
    (∫ z, fiberKernel μ J k f z * conj (g z) ∂μ.prod ν) =
      ∫ z, f z * conj (fiberKernel μ J l g z) ∂μ.prod ν := by
  rw [integral_prod_symm _ hpair₁, integral_prod_symm _ hpair₂]
  calc
    _ = ∫ c, ∫ y, f (y, J c) * conj (fiberKernel μ J l g (y, J c)) ∂μ ∂ν := by
      apply integral_congr_ae
      filter_upwards [hJ.quasiMeasurePreserving.ae hf.prod_left_ae, hg.prod_left_ae] with c hfc hgc
      obtain ⟨K,hKc⟩ := hK c
      have h := real_kernel_adjoint_slice (hk c) hKc (fun x y => hs x y c) hfc hgc
      simpa only [fiberKernel, hJJ c] using h
    _ = _ := hJ.integral_comp hJe (fun c => ∫ y, f (y,c) * conj (fiberKernel μ J l g (y,c)) ∂μ)

end TriangularBilliards.Analysis

namespace TriangularBilliards
open SpatialSmoothing Filter Analysis
open scoped Topology ComplexConjugate

lemma kernel_swap (ε : ℝ) (x y : ℂ) : kernel ε (x-y) = kernel ε (y-x) := by
  exact kernel_radial ε (norm_sub_rev x y)

lemma kernel_wall_swap (Q : Triangle) (i : Fin 3) (ε : ℝ) (x y : ℂ) :
    kernel ε (x-wallReflection Q i y) = kernel ε (y-wallReflection Q i x) := by
  rw [← kernel_wall_transfer, kernel_swap]

lemma kernel_fderiv_neg (ε : ℝ) (x : ℂ) :
    fderiv ℝ (kernel ε) (-x) = -fderiv ℝ (kernel ε) x := by
  simp only [kernel_fderiv, smul_neg, rho_fderiv_neg]

lemma kernel_derivative_swap (ε : ℝ) (x y V : ℂ) :
    fderiv ℝ (kernel ε) (x-y) V = -fderiv ℝ (kernel ε) (y-x) V := by
  rw [← neg_sub x y, kernel_fderiv_neg]
  simp only [_root_.neg_apply, neg_neg]

/-- Reversal of a reflected short segment also reverses its transported
kernel derivative. This is proved from the actual wall unfolding. -/
lemma kernel_wall_derivative_swap (Q : Triangle) (i : Fin 3) (ε : ℝ) (x y V : ℂ) :
    fderiv ℝ (kernel ε) (x-wallReflection Q i y) V =
      -fderiv ℝ (kernel ε) (y-wallReflection Q i x) (reflect (Q.tangent i) V) := by
  have h₁ := ((kernel_contDiff ε).differentiable (by simp) (x-wallReflection Q i y)).hasFDerivAt.comp x
    ((hasFDerivAt_id x).sub_const (wallReflection Q i y))
  have h₂ := ((kernel_contDiff ε).differentiable (by simp) (y-wallReflection Q i x)).hasFDerivAt.comp x
    ((wallReflection_hasFDerivAt Q i x).const_sub y)
  have he : (fun x => kernel ε (x-wallReflection Q i y)) =
      (fun x => kernel ε (y-wallReflection Q i x)) := funext (fun x => kernel_wall_swap Q i ε x y)
  change HasFDerivAt (fun x => kernel ε (x-wallReflection Q i y)) _ x at h₁
  change HasFDerivAt (fun x => kernel ε (y-wallReflection Q i x)) _ x at h₂
  rw [he] at h₁
  have hd := h₁.unique h₂
  have ha := congrArg (fun L : ℂ →L[ℝ] ℝ => L V) hd
  simp only [ContinuousLinearMap.comp_apply, ContinuousLinearMap.id_apply,
    _root_.neg_apply, map_neg] at ha
  exact ha

end TriangularBilliards

namespace TriangularBilliards.Analysis
open Analytic Filter
open scoped ComplexConjugate

lemma fiberKernel_stronglyMeasurable {A : Type uA} {C : Type uC} [MeasurableSpace A] [MeasurableSpace C]
    {μ : Measure A} [SFinite μ] {J : C → C} (hJ : Measurable J)
    {k : A → A → C → ℝ}
    (hk : StronglyMeasurable (fun p : (A × C) × A => k p.1.1 p.2 p.1.2))
    {f : A × C → ℂ} (hf : StronglyMeasurable f) :
    StronglyMeasurable (fiberKernel μ J k f) := by
  exact (hk.smul (hf.comp_measurable (measurable_snd.prodMk (hJ.comp measurable_fst.snd)))).integral_prod_right

lemma fiberKernel_memLp {A : Type uA} {C : Type uC} [MeasurableSpace A] [MeasurableSpace C]
    {μ : Measure A} {ν : Measure C} [IsFiniteMeasure μ] [SFinite ν]
    {J : C → C} (hJ : MeasurePreserving J ν ν) {k : A → A → C → ℝ}
    (hk : StronglyMeasurable (fun p : (A × C) × A => k p.1.1 p.2 p.1.2))
    {K : ℝ} (hK : ∀ x y c, |k x y c| ≤ K)
    {f : A × C → ℂ} (hf : StronglyMeasurable f) (hf₂ : MemLp f 2 (μ.prod ν)) :
    MemLp (fiberKernel μ J k f) 2 (μ.prod ν) := by
  let g : A × C → ℂ := fun z => f (z.1,J z.2)
  have hg : StronglyMeasurable g := hf.comp_measurable (measurable_fst.prodMk (hJ.measurable.comp measurable_snd))
  have hg₂ : MemLp g 2 (μ.prod ν) := hf₂.comp_measurePreserving ((MeasurePreserving.id μ).prod hJ)
  have hF := hk.smul (hf.comp_measurable (measurable_snd.prodMk (hJ.measurable.comp measurable_fst.snd)))
  have hb : ∀ x c y, ‖k x y c • f (y,J c)‖ₑ ≤ ENNReal.ofReal K * ‖g (y,c)‖ₑ := by
    intro x c y
    rw [enorm_smul]
    exact mul_le_mul' (by simpa only [Real.enorm_eq_ofReal_abs] using
      ENNReal.ofReal_le_ofReal (hK x y c)) le_rfl
  have hrow (x : A) : ∫⁻ y : A, ENNReal.ofReal K ∂μ ≤ ENNReal.ofReal K * μ Set.univ := by simp
  have hbound := fiber_kernel_integral_schur_sq μ μ ν (K := fun _ _ : A => ENNReal.ofReal K)
    (F := fun z y => k z.1 y z.2 • f (y,J z.2))
    (measurable_const : Measurable (Function.uncurry (fun _ _ : A => ENNReal.ofReal K)))
    hg.enorm hrow hrow hF hb
  rw [memLp_iff, eLpNorm_lt_top_iff_lintegral_rpow_enorm_lt_top (by norm_num)
    (by norm_num) (fiberKernel_stronglyMeasurable hJ.measurable hk hf).aestronglyMeasurable]
  simp only [ENNReal.toReal_ofNat, ENNReal.rpow_two]
  have hfint : ∫⁻ y, ‖g y‖ₑ ^ (2 : ℕ) ∂μ.prod ν < ⊤ := by
    simpa only [ENNReal.toReal_ofNat, ENNReal.rpow_two] using
      lintegral_rpow_enorm_lt_top_of_eLpNorm_lt_top (by norm_num : (2 : ℝ≥0∞) ≠ 0)
        (by norm_num : (2 : ℝ≥0∞) ≠ ⊤) hg₂.eLpNorm_lt_top
  have hA : ENNReal.ofReal K * μ Set.univ < ⊤ := ENNReal.mul_lt_top ENNReal.ofReal_lt_top (measure_lt_top _ _)
  exact hbound.trans_lt (ENNReal.mul_lt_top (ENNReal.mul_lt_top hA hA) hfint)

lemma memLp_conj {A : Type uA} [MeasurableSpace A] {μ : Measure A} {p : ℝ≥0∞}
    {f : A → ℂ} (hf : MemLp f p μ) : MemLp (fun x => conj (f x)) p μ := by
  apply hf.norm.mono' (Complex.continuous_conj.comp_aestronglyMeasurable hf.aestronglyMeasurable)
  exact Eventually.of_forall fun _ => by simp

lemma fiberKernel_L2_adjoint {A : Type uA} {C : Type uC} [MeasurableSpace A] [MeasurableSpace C]
    {μ : Measure A} {ν : Measure C} [IsFiniteMeasure μ] [IsFiniteMeasure ν]
    {J : C → C} (hJ : MeasurePreserving J ν ν) (hJe : MeasurableEmbedding J)
    (hJJ : Function.Involutive J) {k l : A → A → C → ℝ}
    (hk : StronglyMeasurable (fun p : (A × C) × A => k p.1.1 p.2 p.1.2))
    (hl : StronglyMeasurable (fun p : (A × C) × A => l p.1.1 p.2 p.1.2))
    {K L : ℝ} (hK : ∀ x y c, |k x y c| ≤ K) (hL : ∀ x y c, |l x y c| ≤ L)
    (hs : ∀ x y c, k x y c = l y x (J c))
    {f g : A × C → ℂ} (hfm : StronglyMeasurable f) (hgm : StronglyMeasurable g)
    (hf : MemLp f 2 (μ.prod ν)) (hg : MemLp g 2 (μ.prod ν)) :
    (∫ z, fiberKernel μ J k f z * conj (g z) ∂μ.prod ν) =
      ∫ z, f z * conj (fiberKernel μ J l g z) ∂μ.prod ν := by
  apply fiberKernel_adjoint hJ hJe hJJ
    (fun c => hk.comp_measurable ((measurable_fst.prodMk measurable_const).prodMk measurable_snd))
    (fun c => ⟨K,fun x y => hK x y c⟩) hs (hf.integrable (by norm_num)) (hg.integrable (by norm_num))
  · exact (fiberKernel_memLp hJ hk hK hfm hf).integrable_mul (memLp_conj hg)
  · exact hf.integrable_mul (memLp_conj (fiberKernel_memLp hJ hl hL hgm hg))

end TriangularBilliards.Analysis

namespace TriangularBilliards
open Analysis SpatialSmoothing Filter
open scoped ComplexConjugate

abbrev DirectionParity := Circle × ZMod 2

def associatedField (f : DoublePhase → ℂ) (p : ℂ × DirectionParity) : ℂ :=
  f ((p.1,p.2.1),p.2.2)

lemma associatedField_memLp (Q : Triangle) {f : DoublePhase → ℂ}
    (hf : MemLp f 2 (doubleMeasure Q)) :
    MemLp (associatedField f) 2
      ((volume.restrict Q.table).prod (angularMeasure.prod parityMeasure)) := by
  let μ : Measure ℂ := (volume Q.table)⁻¹ • volume.restrict Q.table
  have hμ : IsProbabilityMeasure μ := ⟨Q.normalized_area_univ⟩
  have ha := measurePreserving_prodAssoc μ angularMeasure parityMeasure
  have hh := hf.comp_measurePreserving (ha.symm MeasurableEquiv.prodAssoc)
  have h := hh.smul_measure Q.area_lt_top.ne
  change MemLp (associatedField f) 2 _ at h
  simpa only [μ, Measure.prod_smul_left, smul_smul,
    ENNReal.mul_inv_cancel Q.area_pos.ne' Q.area_lt_top.ne, one_smul] using h

lemma associatedField_stronglyMeasurable {f : DoublePhase → ℂ}
    (hf : StronglyMeasurable f) : StronglyMeasurable (associatedField f) :=
  hf.comp_measurable ((measurable_fst.prodMk measurable_snd.fst).prodMk measurable_snd.snd)

lemma double_integral_assoc (Q : Triangle) (F : DoublePhase → ℂ) :
    ∫ z, F z ∂doubleMeasure Q = ((volume Q.table)⁻¹).toReal •
      ∫ p : ℂ × DirectionParity, F ((p.1,p.2.1),p.2.2)
        ∂(volume.restrict Q.table).prod (angularMeasure.prod parityMeasure) := by
  simp only [doubleMeasure, phaseMeasure, Measure.prod_smul_left, integral_smul_measure]
  congr 1
  exact (measurePreserving_prodAssoc (volume.restrict Q.table) angularMeasure parityMeasure).integral_comp
    MeasurableEquiv.prodAssoc.measurableEmbedding
    (fun p : ℂ × DirectionParity => F ((p.1,p.2.1),p.2.2))

def directionParityReflection (Q : Triangle) (i : Fin 3) (c : DirectionParity) : DirectionParity :=
  (reflectedDirection Q i c.1,c.2+1)

lemma directionParityReflection_involutive (Q : Triangle) (i : Fin 3) :
    Function.Involutive (directionParityReflection Q i) := by
  rintro ⟨v,b⟩
  simp only [directionParityReflection, reflectedDirection_involutive, Prod.mk.injEq, true_and]
  have : (1 : ZMod 2) + 1 = 0 := by decide
  rw [add_assoc, this, add_zero]

lemma measurePreserving_directionParity (Q : Triangle) (i : Fin 3) :
    MeasurePreserving (directionParityReflection Q i) (angularMeasure.prod parityMeasure)
      (angularMeasure.prod parityMeasure) := by
  convert (measurePreserving_reflectedDirection Q i).prod (measurePreserving_parity_add 1) using 1
  funext ⟨v,b⟩
  exact congrArg (fun q => (reflectedDirection Q i v,q)) (add_comm b 1)

lemma measurableEmbedding_directionParity (Q : Triangle) (i : Fin 3) :
    MeasurableEmbedding (directionParityReflection Q i) :=
  (MeasurableEquiv.ofInvolutive (directionParityReflection Q i)
    (directionParityReflection_involutive Q i)
    (measurePreserving_directionParity Q i).measurable).measurableEmbedding

/-- Kernel integration on the two physical triangle copies, with the exact
unnormalized Euclidean spatial integral and normalized phase pairing. -/
def doubleKernel (Q : Triangle) (J : DirectionParity → DirectionParity)
    (k : ℂ → ℂ → DirectionParity → ℝ) (f : DoublePhase → ℂ)
    (z : DoublePhase) : ℂ :=
  fiberKernel (volume.restrict Q.table) J k (associatedField f)
    (z.1.1,(z.1.2,z.2))

lemma doubleKernel_adjoint (Q : Triangle) {J : DirectionParity → DirectionParity}
    (hJ : MeasurePreserving J (angularMeasure.prod parityMeasure) (angularMeasure.prod parityMeasure))
    (hJe : MeasurableEmbedding J) (hJJ : Function.Involutive J)
    {k l : ℂ → ℂ → DirectionParity → ℝ}
    (hk : StronglyMeasurable (fun p : (ℂ × DirectionParity) × ℂ => k p.1.1 p.2 p.1.2))
    (hl : StronglyMeasurable (fun p : (ℂ × DirectionParity) × ℂ => l p.1.1 p.2 p.1.2))
    {K L : ℝ} (hK : ∀ x y c, |k x y c| ≤ K) (hL : ∀ x y c, |l x y c| ≤ L)
    (hs : ∀ x y c, k x y c = l y x (J c))
    {f g : DoublePhase → ℂ} (hfm : StronglyMeasurable f) (hgm : StronglyMeasurable g)
    (hf : MemLp f 2 (doubleMeasure Q)) (hg : MemLp g 2 (doubleMeasure Q)) :
    (∫ z, doubleKernel Q J k f z * conj (g z) ∂doubleMeasure Q) =
      ∫ z, f z * conj (doubleKernel Q J l g z) ∂doubleMeasure Q := by
  have : IsFiniteMeasure (volume.restrict Q.table) := ⟨by simpa using Q.area_lt_top⟩
  rw [double_integral_assoc, double_integral_assoc]
  congr 1
  exact fiberKernel_L2_adjoint hJ hJe hJJ hk hl hK hL hs
    (associatedField_stronglyMeasurable hfm) (associatedField_stronglyMeasurable hgm)
    (associatedField_memLp Q hf) (associatedField_memLp Q hg)

lemma doubleKernel_neg (Q : Triangle) (J : DirectionParity → DirectionParity)
    (k : ℂ → ℂ → DirectionParity → ℝ) (f : DoublePhase → ℂ) (z : DoublePhase) :
    doubleKernel Q J (fun x y c => -k x y c) f z = -doubleKernel Q J k f z := by
  simp only [doubleKernel, fiberKernel, neg_smul, integral_neg]

lemma doubleKernel_skew (Q : Triangle) {J : DirectionParity → DirectionParity}
    (hJ : MeasurePreserving J (angularMeasure.prod parityMeasure) (angularMeasure.prod parityMeasure))
    (hJe : MeasurableEmbedding J) (hJJ : Function.Involutive J)
    {k : ℂ → ℂ → DirectionParity → ℝ}
    (hk : StronglyMeasurable (fun p : (ℂ × DirectionParity) × ℂ => k p.1.1 p.2 p.1.2))
    {K : ℝ} (hK : ∀ x y c, |k x y c| ≤ K)
    (hs : ∀ x y c, k x y c = -k y x (J c))
    {f g : DoublePhase → ℂ} (hfm : StronglyMeasurable f) (hgm : StronglyMeasurable g)
    (hf : MemLp f 2 (doubleMeasure Q)) (hg : MemLp g 2 (doubleMeasure Q)) :
    (∫ z, doubleKernel Q J k f z * conj (g z) ∂doubleMeasure Q) =
      -(∫ z, f z * conj (doubleKernel Q J k g z) ∂doubleMeasure Q) := by
  have h := doubleKernel_adjoint Q hJ hJe hJJ (l := fun x y c => -k x y c) hk hk.neg hK
    (fun x y c => by simpa only [abs_neg] using hK x y c) hs hfm hgm hf hg
  simpa only [doubleKernel_neg, map_neg, mul_neg, integral_neg] using h

end TriangularBilliards

end
end
end
end
end
end

end OAI