import OAI.Probability.DirectionalWalk.MarkedSums

namespace OAI

open MeasureTheory ProbabilityTheory Filter Preorder
open scoped ENNReal BigOperators Topology

namespace DirectionalZeroOne

open scoped Classical

noncomputable def countWindowLaw (k n : ℕ) : Measure ℕ :=
  (n : ℝ≥0∞)⁻¹ • ∑ i : Fin n, Measure.dirac (k+i)

instance countWindowLaw_probability (k n : ℕ) [NeZero n] : IsProbabilityMeasure (countWindowLaw k n) := by
  constructor
  simp only [countWindowLaw,Measure.smul_apply,smul_eq_mul,Measure.finsetSum_apply,measure_univ,
    Finset.sum_const,Finset.card_univ,Fintype.card_fin,nsmul_eq_mul,mul_one]
  exact ENNReal.inv_mul_cancel (by exact_mod_cast NeZero.ne n) (by finiteness)

lemma countWindowLaw_atom (k n r : ℕ) : countWindowLaw k n {r} =
    (if k ≤ r ∧ r < k+n then (n : ℝ≥0∞)⁻¹ else 0) := by
  classical
  simp only [countWindowLaw,Measure.smul_apply,smul_eq_mul,Measure.finsetSum_apply,
    Measure.dirac_apply' _ (measurableSet_singleton _),Set.indicator_apply,Set.mem_singleton_iff,Pi.one_apply]
  by_cases h : k ≤ r ∧ r < k+n
  · rw [ite_eq_left h]
    let i : Fin n := ⟨r-k,by omega⟩
    rw [Finset.sum_eq_single i]
    · simp only [show k+(i : ℕ) = r by dsimp [i];omega,ite_eq_left,mul_one]
    · intro j _ hji
      apply ite_eq_right
      intro hj
      apply hji
      apply Fin.ext
      change (j : ℕ) = r-k
      omega
    · simp
  · rw [ite_eq_right h]
    have hz : ∑ i : Fin n, (if k+(i : ℕ) = r then (1 : ℝ≥0∞) else 0) = 0 := by
      apply Finset.sum_eq_zero
      intro i _
      apply ite_eq_right
      intro hi
      exact h ⟨by omega,by omega⟩
    rw [hz,mul_zero]

lemma countWindowLaw_ae (k n : ℕ) : ∀ᵐ r ∂countWindowLaw k n, k ≤ r ∧ r < k+n := by
  filter_upwards [ae_atom_pos (countWindowLaw k n)] with r hr
  by_contra hn
  rw [countWindowLaw_atom,ite_eq_right hn] at hr
  exact hr rfl

lemma countWindowLaw_info (k n : ℕ) : atomInfo (countWindowLaw k n) =ᵐ[countWindowLaw k n]
    fun _ => Real.log n := by
  filter_upwards [countWindowLaw_ae k n] with r hr
  simp only [atomInfo,measureReal_def,countWindowLaw_atom,ite_eq_left hr,ENNReal.toReal_inv,
    ENNReal.toReal_natCast,Real.log_inv,neg_neg]

lemma countWindowLaw_entropy (k n : ℕ) [NeZero n] :
    Integrable (atomInfo (countWindowLaw k n)) (countWindowLaw k n) ∧
      discreteEntropy (countWindowLaw k n) = Real.log n := by
  constructor
  · exact (integrable_const _).congr (countWindowLaw_info k n).symm
  · change (∫ r, atomInfo (countWindowLaw k n) r ∂countWindowLaw k n) = _
    rw [integral_congr_ae (countWindowLaw_info k n)]
    simp

lemma convolution_ae_bounds (μ ν : Measure ℕ) [IsProbabilityMeasure μ] [IsProbabilityMeasure ν]
    (a b c d : ℕ) (hμ : ∀ᵐ x ∂μ, a ≤ x ∧ x ≤ b) (hν : ∀ᵐ y ∂ν, c ≤ y ∧ y ≤ d) :
    ∀ᵐ z ∂μ.conv ν, a+c ≤ z ∧ z ≤ b+d := by
  rw [Measure.conv,ae_map_iff (measurable_of_countable _).aemeasurable (Set.to_countable _).measurableSet]
  apply (Measure.ae_prod_iff_ae_ae (Set.to_countable _).measurableSet).mpr
  filter_upwards [hμ] with x hx
  filter_upwards [hν] with y hy
  exact ⟨Nat.add_le_add hx.1 hy.1,Nat.add_le_add hx.2 hy.2⟩
section MarkedWindows
variable {G : Type*} [Countable G] [MeasurableSpace G] [MeasurableSingletonClass G]
  [AddCommGroup G]
  {α : Type*} [Countable α] [MeasurableSpace α] [MeasurableSingletonClass α]

lemma nthCommonLaw_marked (ν : Bool → Measure α) [∀ b, IsProbabilityMeasure (ν b)]
    (L : Bool → α → ℕ) (hL : ∀ b, ∀ᵐ a ∂ν b, 0 < L b a)
    (he : ∀ᵐ Z ∂twoTapeLaw ν, ∃ H, 0 < H ∧ Z ∈ commonCut L H)
    (D : Bool → α → G) (r : ℕ) :
    (nthCommonLaw ν L r).map (fun a => (listCommonCount L a,pairTotal D a)) =
      (sumLaw (commonGapLaw ν L D) r).map (fun x => (r,x)) := by
  have hc : ∀ᵐ a ∂nthCommonLaw ν L r, listCommonCount L a = r := by
    classical
    filter_upwards [ae_atom_pos (nthCommonLaw ν L r)] with a ha
    by_contra hn
    rw [nthCommonLaw_atom ν L hL he,ite_eq_right (fun h => hn h.2)] at ha
    exact ha rfl
  rw [← nthCommonLaw_pairTotal ν L hL he D r,Measure.map_map (measurable_of_countable _)
    (measurable_of_countable _)]
  apply Measure.map_congr
  filter_upwards [hc] with a ha
  exact Prod.ext ha rfl

lemma windowCommonLaw_marked (ν : Bool → Measure α) [∀ b, IsProbabilityMeasure (ν b)]
    (L : Bool → α → ℕ) (hL : ∀ b, ∀ᵐ a ∂ν b, 0 < L b a)
    (he : ∀ᵐ Z ∂twoTapeLaw ν, ∃ H, 0 < H ∧ Z ∈ commonCut L H)
    (D : Bool → α → G) (k n : ℕ) :
    (windowCommonLaw ν L k n).map (fun a => (listCommonCount L a,pairTotal D a)) =
      markedSumLaw (commonGapLaw ν L D) (countWindowLaw k n) := by
  simp only [windowCommonLaw,Measure.map_smul _ (measurable_of_countable _).aemeasurable]
  rw [Measure.map_finset_sum' (measurable_of_countable _).aemeasurable]
  simp_rw [nthCommonLaw_marked ν L hL he D]
  conv_rhs => unfold markedSumLaw countWindowLaw
  rw [Measure.compProd_smul_left]
  congr 1
  conv_rhs => rw [← Measure.sum_fintype,Measure.compProd_sum_left,Measure.sum_fintype]
  apply Finset.sum_congr rfl
  intro i _
  apply Measure.ext
  intro s hs
  rw [Measure.dirac_compProd_apply hs,Measure.map_apply (measurable_of_countable _) hs]
  rfl
end MarkedWindows

end DirectionalZeroOne

end OAI