import OAI.Probability.DirectionalWalk.LateEndpoints

namespace OAI

open MeasureTheory ProbabilityTheory Filter Preorder
open scoped ENNReal BigOperators Topology

namespace DirectionalZeroOne

open scoped Classical

def combineTapes {α : Type*} (p : (ℕ → α) × (ℕ → α)) : TwoTape α :=
  fun i => if i.1 then p.2 i.2 else p.1 i.2

lemma measurable_combineTapes {α : Type*} [MeasurableSpace α] :
    Measurable (combineTapes (α := α)) := by
  apply Measurable.of_eval
  intro i
  cases i with | mk b n =>
    cases b <;> simp only [combineTapes,↓reduceIte,Bool.false_eq_true] <;> fun_prop

lemma combineTapes_law {α : Type*} [MeasurableSpace α]
    (ν : Bool → Measure α) [∀ b, IsProbabilityMeasure (ν b)] :
    ((Measure.infinitePi (fun _ : ℕ => ν false)).prod
      (Measure.infinitePi (fun _ : ℕ => ν true))).map combineTapes = twoTapeLaw ν := by
  have hpair := (twoExtract_independent ν).map_prod_eq_prod_map_map
    (Measurable.of_eval (fun i => measurable_pi_apply (false,i))).aemeasurable
    (Measurable.of_eval (fun i => measurable_pi_apply (true,i))).aemeasurable
  rw [twoExtract_law,twoExtract_law] at hpair
  rw [← hpair,Measure.map_map measurable_combineTapes
    ((Measurable.of_eval (fun i => measurable_pi_apply (false,i))).prodMk
      (Measurable.of_eval (fun i => measurable_pi_apply (true,i))))]
  have he : combineTapes ∘ (fun Z : TwoTape α => ((fun i => Z (false,i)),(fun i => Z (true,i)))) = id := by
    funext Z
    funext i
    cases i with | mk b n => cases b <;> rfl
  rw [he,Measure.map_id]

noncomputable def mixedTapes {d : ℕ} (e : Step d) (p : (ℕ → Word d) × Path d) : TwoTape (Word d) :=
  combineTapes (p.1,slabs (axisDirection (oppositeStep e)) p.2)

lemma measurable_mixedTapes {d : ℕ} (e : Step d) : Measurable (mixedTapes e) :=
  measurable_combineTapes.comp
    (measurable_fst.prodMk ((measurable_slabs (axisDirection (oppositeStep e))).comp measurable_snd))

lemma mixedTapes_law {d : ℕ} (μ : Measure (Row d)) [IsProbabilityMeasure μ]
    (hell : StrictEllipticity μ) (e : Step d)
    (hp : ∀ b, 0 < annealed μ 0 (nonBacktracking (axisDirection (placedAxis e b)))) :
    letI : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) :=
      fun b => slabLaw_probability μ _ (hp b)
    ((Measure.infinitePi (fun _ : ℕ => slabLaw μ (axisDirection e))).prod
      (conditioned μ (axisDirection (oppositeStep e)))).map (mixedTapes e) =
      twoTapeLaw (fun b => slabLaw μ (axisDirection (placedAxis e b))) := by
  let : ∀ b, IsProbabilityMeasure (slabLaw μ (axisDirection (placedAxis e b))) :=
    fun b => slabLaw_probability μ _ (hp b)
  let := slabLaw_probability μ (axisDirection e) (hp false)
  let := conditioned_probability μ (axisDirection (oppositeStep e)) (hp true)
  have hpminus : 0 < annealed μ 0 (nonBacktracking (axisDirection (oppositeStep e))) := hp true
  change (((Measure.infinitePi (fun _ : ℕ => slabLaw μ (axisDirection e))).prod
      (conditioned μ (axisDirection (oppositeStep e)))).map
    (combineTapes ∘ (fun p => (p.1,slabs (axisDirection (oppositeStep e)) p.2)))) = _
  have hf : Measurable (fun p : (ℕ → Word d) × Path d =>
      (p.1,slabs (axisDirection (oppositeStep e)) p.2)) :=
    measurable_fst.prodMk ((measurable_slabs (axisDirection (oppositeStep e))).comp measurable_snd)
  rw [← Measure.map_map measurable_combineTapes hf]
  have hmap := Measure.map_prod_map
    (Measure.infinitePi (fun _ : ℕ => slabLaw μ (axisDirection e)))
    (conditioned μ (axisDirection (oppositeStep e))) measurable_id
    (measurable_slabs (axisDirection (oppositeStep e)))
  simp only [Measure.map_id',Prod.map_def,Function.id_def] at hmap
  rw [← hmap,slabs_map_eq_infinitePi μ hell _ (axisDirection_ne_zero (oppositeStep e)) hpminus]
  exact combineTapes_law (fun b => slabLaw μ (axisDirection (placedAxis e b)))

lemma measurableSet_contactDepth {d : ℕ} (e : Step d) (h : ℕ) :
    MeasurableSet {Z : TwoTape (Word d) | contactDepth e Z h} := by
  have hsite (b : Bool) (i t : ℕ) : Measurable (fun Z : TwoTape (Word d) => opposedSite e Z b i t) := by
    unfold opposedSite opposedAnchor
    cases b <;> simp only [Bool.false_eq_true,↓reduceIte]
    · exact (Finset.measurable_sum _ (fun j _ => (measurable_of_countable wordEnd).comp
        (measurable_pi_apply (X := fun _ : Bool × ℕ => Word d) (false,j)))).neg.add ((measurable_of_countable (fun a : Word d => wordPath a t)).comp
          (measurable_pi_apply (X := fun _ : Bool × ℕ => Word d) (false,i)))
    · exact (measurable_const.add (Finset.measurable_sum _ (fun j _ =>
        (measurable_of_countable wordEnd).comp (measurable_pi_apply (X := fun _ : Bool × ℕ => Word d) (true,j))))).add
          ((measurable_of_countable (fun a : Word d => wordPath a t)).comp (measurable_pi_apply (X := fun _ : Bool × ℕ => Word d) (true,i)))
  have hdep (b : Bool) (y : Site d) : MeasurableSet {Z : TwoTape (Word d) | opposedDeparture e Z b y} := by
    simp only [opposedDeparture,Set.ofPred_exists]
    apply MeasurableSet.iUnion;intro i
    apply MeasurableSet.iUnion;intro t
    apply MeasurableSet.inter
    · exact (measurable_pi_apply (X := fun _ : Bool × ℕ => Word d) (b,i)) (Set.to_countable {a : Word d | t < a.1}).measurableSet
    · exact (hsite b i t) (measurableSet_singleton y)
  unfold contactDepth contactAt
  simp only [Set.ofPred_exists]
  exact MeasurableSet.iUnion (fun y => ((hdep false y).inter (hdep true y)).inter (MeasurableSet.const _))

end DirectionalZeroOne

end OAI