import OAI.Dynamics.ConditionalShuffle.ResampledInstrument

namespace OAI

noncomputable section
open scoped Classical
namespace Revealed.Overlay
open Thorp Thorp.Conditional Revealed.Split Revealed.Disintegration Revealed.Instrument Revealed.Scheduled
variable {ι α : Type} [Fintype ι] [Fintype α] [DecidableEq α]

lemma step_relative_roundtrip_cons (d : ℕ) (c c' : Position d → Bool) (b : Bool) (x : Position d) :
    step (d+1) c ((step (d+1) c').symm (step (d+1) c (Fin.cons b x))) =
      step (d+1) c' (Fin.cons b x) := by
  calc
    _ = step (d+1) c ((step (d+1) c').symm (scatterPosition d (b ^^ c x,x))) := by
      rw [step_cons]
    _ = step (d+1) c (Fin.cons ((b ^^ c x) ^^ c' x) x) := by
      erw [step_symm_scatter]; rfl
    _ = scatterPosition d (((b ^^ c x) ^^ c' x) ^^ c x,x) := step_cons d c _ x
    _ = scatterPosition d (b ^^ c' x,x) := by
      apply congrArg (scatterPosition d)
      apply Prod.ext
      · cases b <;> cases c x <;> cases c' x <;> rfl
      · rfl
    _ = _ := (step_cons d c' b x).symm

lemma step_relative_roundtrip (d : ℕ) (c c' : Coins (d+1)) (x : Position (d+1)) :
    step (d+1) c ((step (d+1) c').symm (step (d+1) c x)) = step (d+1) c' x := by
  have h := step_relative_roundtrip_cons d c c' (x 0) (Fin.tail x)
  simpa only [Fin.cons_self_tail] using h

lemma multiplier_forward (d : ℕ) (L : Sum ι α ≃ Position (d+1)) (active : Bool)
    (c r : Coins (d+1)) (a : α) :
    step (d+1) c (L (.inr (multiplier d L active c r a))) =
      step (d+1) (xorCoins d L active c r) (L (.inr a)) := by
  have hm := relative_spec (L.trans (step (d+1) c))
    (L.trans (step (d+1) (xorCoins d L active c r)))
    (fun i => (xorCoins_occupied d L active c r i).symm) a
  change step (d+1) (xorCoins d L active c r) (L (.inr (multiplier d L active c r a))) =
    step (d+1) c (L (.inr a)) at hm
  have he := congrArg (step (d+1) (xorCoins d L active c r)).symm hm
  rw [Equiv.symm_apply_apply] at he
  rw [he]
  exact step_relative_roundtrip d c _ _

lemma multiplier_factor (d : ℕ) (L : Sum ι α ≃ Position (d+1)) (active : Bool)
    (c r : Coins (d+1)) :
    (Equiv.sumCongr (Equiv.refl ι) (multiplier d L active c r)).trans (L.trans (step (d+1) c)) =
      L.trans (step (d+1) (xorCoins d L active c r)) := by
  apply Equiv.ext
  intro x
  cases x with
  | inl i => exact (xorCoins_occupied d L active c r i).symm
  | inr a => exact multiplier_forward d L active c r a

lemma multiplier_gauge (d : ℕ) (L : Sum ι α ≃ Position (d+1)) (active : Bool)
    (c r : Coins (d+1)) :
    multiplier d L active c r = (assignment (L.trans (step (d+1) c)))⁻¹ *
      increment (Split.outside L) (step (d+1) (xorCoins d L active c r)) * assignment L := by
  have hh := congrArg assignment (multiplier_factor d L active c r)
  rw [assignment_pre] at hh
  rw [assignment_post L (step (d+1) (xorCoins d L active c r))] at hh
  rw [mul_assoc]
  exact (eq_inv_mul_iff_mul_eq).2 hh

def xorIncrement (d : ℕ) (σ : ℕ → Bool) (e : ℕ × Outside ι α (Position (d+1)))
    (c r : Coins (d+1)) : Equiv.Perm α :=
  increment e.2 (step (d+1) (xorCoins d (sectionFrame e.2) (σ e.1) c r))

lemma xorIncrement_law (d : ℕ) (σ : ℕ → Bool) (e : ℕ × Outside ι α (Position (d+1)))
    (c : Coins (d+1)) : fairMass (xorIncrement d σ e c) =
      kernel (stepInstrument (d+1) σ) e ((stepInstrument (d+1) σ).obs e c) := xor_kernel d σ e c

lemma xorCoins_frame (d : ℕ) (L : Sum ι α ≃ Position (d+1)) (active : Bool)
    (c r : Coins (d+1)) : xorCoins d L active c r =
      xorCoins d (sectionFrame (Split.outside L)) active c r := by
  rw [xor_resample, xor_resample]
  unfold resample
  rw [mask_frame]

lemma observed_base (d : ℕ) (L : Sum ι α ≃ Position d) (σ : ℕ → Bool) (t : ℕ) (c : History d t) :
    base (stepInstrument d σ) (0,Split.outside L) t (observed (stepInstrument d σ) (0,Split.outside L) t c) =
      (t,Split.outside (L.trans (run d t c))) := by
  apply Prod.ext
  · simpa only [Nat.zero_add] using base_clock d σ 0 (Split.outside L) t _
  · rw [base_outside, observed_outside, Physical.physical_base]

lemma overlayRun_gauge (d : ℕ) (L : Sum ι α ≃ Position (d+1)) (σ : ℕ → Bool)
    (t : ℕ) (c r : History (d+1) t) :
    overlayRun d L σ t c r = (assignment (L.trans (run (d+1) t c)))⁻¹ *
      resampledRun (stepInstrument (d+1) σ) (xorIncrement d σ) (0,Split.outside L) t c r * assignment L := by
  induction t with
  | zero => simp only [overlayRun, run_zero, resampledRun, mul_one]; exact (inv_mul_cancel _).symm
  | succ t ih =>
      rw [overlayRun, multiplier_gauge, ih, resampledRun, observed_base]
      rw [xorCoins_frame, run_succ]
      change (assignment ((L.trans (run (d+1) t (Fin.init c))).trans (step (d+1) (c (Fin.last t)))))⁻¹ *
        increment _ (step (d+1) (xorCoins d (sectionFrame (Split.outside (L.trans (run (d+1) t (Fin.init c)))))
          (σ t) (c (Fin.last t)) (r (Fin.last t)))) * assignment (L.trans (run (d+1) t (Fin.init c))) *
        ((assignment (L.trans (run (d+1) t (Fin.init c))))⁻¹ * _ * assignment L) =
          (assignment ((L.trans (run (d+1) t (Fin.init c))).trans (step (d+1) (c (Fin.last t)))))⁻¹ *
            (increment _ (step (d+1) (xorCoins d (sectionFrame (Split.outside (L.trans (run (d+1) t (Fin.init c)))))
              (σ t) (c (Fin.last t)) (r (Fin.last t)))) * _) * assignment L
      group

end Revealed.Overlay

end

end OAI