import OAI.Combinatorics.BalancedRyser.Local.AlignedGlobalProduct
import OAI.Combinatorics.BalancedRyser.Local.LocalUnusedOffsetProbability

namespace OAI

namespace Balanced.Local.AlignedGlobal

open AlignedUnused TupleAlignment RootChildPartition
noncomputable section
attribute [local instance] Classical.propDecidable

variable {F : Type*} [Field F] [Fintype F] [DecidableEq F]
variable {b κ : ℕ}

def refreshUnused (P : EqualityPattern b κ) (a : DirectionAssignment F b κ)
    (M : MergedPairs F) (u : UnusedArray P a) : MergedPairs F :=
  (split P a).symm ((split P a M).1, u)

omit [Field F] [Fintype F] in
theorem refreshUnused_used (P : EqualityPattern b κ)
    (a : DirectionAssignment F b κ) (M : MergedPairs F) (u : UnusedArray P a)
    (d : Direction F) (hd : d ∈ usedDirections P a) :
    refreshUnused P a M u d = M d := by
  exact congrFun (congrArg Prod.fst
    ((split P a).apply_symm_apply ((split P a M).1, u))) ⟨d, hd⟩

omit [Field F] [Fintype F] in
theorem refreshUnused_unused (P : EqualityPattern b κ)
    (a : DirectionAssignment F b κ) (M : MergedPairs F) (u : UnusedArray P a)
    (d : {d : Direction F // d ∉ usedDirections P a}) :
    refreshUnused P a M u d.1 = u d := by
  exact congrFun (congrArg Prod.snd
    ((split P a).apply_symm_apply ((split P a M).1, u))) d

def refreshAligned (P : EqualityPattern b κ) (a : DirectionAssignment F b κ)
    (bits : Bits b) (p : Point F) (M : AlignedOffsets P a bits p)
    (u : UnusedArray P a) : AlignedOffsets P a bits p :=
  ⟨refreshUnused P a M.1 u,
    (aligned_agree P a bits p M.1 (refreshUnused P a M.1 u)
      (fun d hd => (refreshUnused_used P a M.1 u d hd).symm)).mp M.2⟩

omit [Fintype F] in
theorem coordinates_refreshAligned (P : EqualityPattern b κ)
    (R : Finset (Fin b)) (a : DirectionAssignment F b κ)
    (bits : Bits b) (p : Point F) (M : AlignedOffsets P a bits p)
    (u : UnusedArray P a) :
    coordinates P R a bits p (refreshAligned P a bits p M u) =
      ((coordinates P R a bits p M).1, u) := by
  apply Prod.ext
  · funext ij
    apply congrArg (linePointEquiv (a.1 ij.1.1) (lineEval (a.1 ij.1.1) p))
    apply Subtype.ext
    exact UnusedOffsetProbability.prescribedPoint_eq_of_used_agreement
      _ _ (refreshUnused_used P a M.1 u) ij.1
  · funext d
    exact refreshUnused_unused P a M.1 u d

theorem generated_refresh (P : EqualityPattern b κ) (hκ : κ ≤ 2)
    (R : Finset (Fin b)) (hD : (dependentOccurrences P R).card = 2*κ)
    (a : DirectionAssignment F b κ) (ha : Eligible P a)
    (bits : Bits b) (p : Point F) (x : FreeIndex P R → F)
    (u v : UnusedArray P a) :
    refreshAligned P a bits p
      ((coordinateEquiv P hκ R hD a ha bits p).symm (x,u)) v =
      (coordinateEquiv P hκ R hD a ha bits p).symm (x,v) := by
  apply (coordinateEquiv P hκ R hD a ha bits p).injective
  rw [coordinateEquiv_apply, coordinates_refreshAligned]
  change ((coordinateEquiv P hκ R hD a ha bits p
    ((coordinateEquiv P hκ R hD a ha bits p).symm (x,u))).1, v) = _
  simp only [Equiv.apply_symm_apply]

theorem generated_used_agree (P : EqualityPattern b κ) (hκ : κ ≤ 2)
    (R : Finset (Fin b)) (hD : (dependentOccurrences P R).card = 2*κ)
    (a : DirectionAssignment F b κ) (ha : Eligible P a)
    (bits : Bits b) (p : Point F) (x : FreeIndex P R → F)
    (u v : UnusedArray P a) (d : Direction F) (hd : d ∈ usedDirections P a) :
    ((coordinateEquiv P hκ R hD a ha bits p).symm (x,u)).1 d =
      ((coordinateEquiv P hκ R hD a ha bits p).symm (x,v)).1 d := by
  rw [← generated_refresh P hκ R hD a ha bits p x u v]
  exact (refreshUnused_used P a _ v d hd).symm

def generatedZero (P : EqualityPattern b κ) (hκ : κ ≤ 2)
    (R : Finset (Fin b)) (hD : (dependentOccurrences P R).card = 2*κ)
    (a : DirectionAssignment F b κ) (ha : Eligible P a)
    (bits : Bits b) (p : Point F) (x : FreeIndex P R → F) : MergedPairs F :=
  ((coordinateEquiv P hκ R hD a ha bits p).symm (x, fun _ _ => 0)).1

theorem alignedLaw_map_used {O : Type*}
    (P : EqualityPattern b κ) (hκ : κ ≤ 2)
    (R : Finset (Fin b)) (hD : (dependentOccurrences P R).card = 2*κ)
    (a : DirectionAssignment F b κ) (ha : Eligible P a)
    (bits : Bits b) (p : Point F) (obs : MergedPairs F → O)
    (hobs : ∀ M N, (∀ d ∈ usedDirections P a, M d = N d) → obs M = obs N) :
    (alignedLaw P hκ a ha bits p).map obs =
      (PMF.uniformOfFintype (FreeIndex P R → F)).map
        (fun x => obs (generatedZero P hκ R hD a ha bits p x)) := by
  rw [alignedLaw_eq_uniform_coordinates P hκ R hD a ha bits p, PMF.map_comp]
  have hf : (obs ∘ (fun z =>
      ((coordinateEquiv P hκ R hD a ha bits p).symm z).1)) =
      (fun x => obs (generatedZero P hκ R hD a ha bits p x)) ∘ Prod.fst := by
    funext z
    apply hobs
    intro d hd
    exact generated_used_agree P hκ R hD a ha bits p z.1 z.2 (fun _ _ => 0) d hd
  rw [hf, ← PMF.map_comp, uniform_map_fst]

theorem conditioned_probability_eq_uniform_free
    (P : EqualityPattern b κ) (hκ : κ ≤ 2)
    (R : Finset (Fin b)) (hD : (dependentOccurrences P R).card = 2*κ)
    (a : DirectionAssignment F b κ) (ha : Eligible P a)
    (bits : Bits b) (p : Point F) (E : MergedPairs F → Prop)
    (hE : ∀ M N, (∀ d ∈ usedDirections P a, M d = N d) → (E M ↔ E N)) :
    conditionedOffsetProbability (Aligned P a bits p) E =
      ((PMF.uniformOfFintype (FreeIndex P R → F)).toOuterMeasure
        {x | E (generatedZero P hκ R hD a ha bits p x)}).toReal := by
  rw [conditioned_probability_eq_uniform_coordinates P hκ R hD a ha bits p E]
  have heq : {z | E ((coordinateEquiv P hκ R hD a ha bits p).symm z).1} =
      Prod.fst ⁻¹' {x | E (generatedZero P hκ R hD a ha bits p x)} := by
    ext z
    exact hE _ _ (generated_used_agree P hκ R hD a ha bits p z.1 z.2 (fun _ _ => 0))
  rw [heq]
  have hm := congrArg (fun μ : PMF (FreeIndex P R → F) =>
      (μ.toOuterMeasure {x | E (generatedZero P hκ R hD a ha bits p x)}).toReal)
    (uniform_map_fst (α := FreeIndex P R → F) (β := UnusedArray P a))
  simpa only [PMF.toOuterMeasure_map_apply] using hm

end
end Balanced.Local.AlignedGlobal

end OAI