import OAI.Dynamics.ConditionalShuffle.ResetPartial

namespace OAI

noncomputable section
open scoped BigOperators Classical
open Filter Topology
namespace Thorp.Conditional

def reversePosition (d : ℕ) : State d where
  toFun x := fun i => x i.rev
  invFun x := fun i => x i.rev
  left_inv x := by funext i; simp
  right_inv x := by funext i; simp

@[simp] lemma reversePosition_apply (d : ℕ) (x : Position d) (i : Fin d) :
    reversePosition d x i = x i.rev := rfl

@[simp] lemma reversePosition_involutive (d : ℕ) (x : Position d) :
    reversePosition d (reversePosition d x) = x := by ext i; simp

lemma reversePosition_cons (d : ℕ) (b : Bool) (x : Position d) :
    reversePosition (d+1) (Fin.cons b x) = Fin.snoc (reversePosition d x) b := by
  ext i; refine Fin.lastCases ?_ (fun j => ?_) i
  · simp
  · simp [Fin.rev_castSucc]

lemma reversePosition_snoc (d : ℕ) (b : Bool) (x : Position d) :
    reversePosition (d+1) (Fin.snoc x b) = Fin.cons b (reversePosition d x) := by
  have := congrArg (reversePosition (d+1)) (reversePosition_cons d b (reversePosition d x))
  simpa only [reversePosition_involutive] using this.symm

def reverseCoins (d : ℕ) : Coins (d+1) ≃ Coins (d+1) where
  toFun c := c ∘ reversePosition d
  invFun c := c ∘ reversePosition d
  left_inv c := by funext x; change c (reversePosition d (reversePosition d x)) = c x; rw [reversePosition_involutive]
  right_inv c := by funext x; change c (reversePosition d (reversePosition d x)) = c x; rw [reversePosition_involutive]

lemma reverse_step_cancel (d : ℕ) (c : Coins (d+1)) (x : Position (d+1)) :
    step (d+1) (reverseCoins d c) (reversePosition (d+1) (step (d+1) c x)) =
      reversePosition (d+1) x := by
  obtain ⟨⟨b,x⟩,rfl⟩ := (Fin.consEquiv (fun _ : Fin (d+1) => Bool)).surjective x
  change step (d+1) (reverseCoins d c) (reversePosition (d+1) (step (d+1) c (Fin.cons b x))) = reversePosition (d+1) (Fin.cons b x)
  rw [step_cons d c b x, scatterPosition_eq_snoc, reversePosition_snoc, step_cons d (reverseCoins d c),
    scatterPosition_eq_snoc, reversePosition_cons]
  have he : reverseCoins d c (reversePosition d x) = c x := by change c (reversePosition d (reversePosition d x)) = c x; rw [reversePosition_involutive]
  rw [he, Bool.xor_assoc, Bool.xor_self, Bool.xor_false]

lemma reverse_step (d : ℕ) (c : Coins (d+1)) :
    step (d+1) (reverseCoins d c) =
      reversePosition (d+1) * (step (d+1) c)⁻¹ * reversePosition (d+1) := by
  apply Equiv.ext; intro x
  have hh := reverse_step_cancel d c ((step (d+1) c).symm (reversePosition (d+1) x))
  change step (d+1) (reverseCoins d c) x =
    reversePosition (d+1) ((step (d+1) c).symm (reversePosition (d+1) x))
  simpa only [Equiv.apply_symm_apply, reversePosition_involutive] using hh

def reverseHistory (d t : ℕ) : History (d+1) t ≃ History (d+1) t where
  toFun ω := fun i => reverseCoins d (ω i.rev)
  invFun ω := fun i => reverseCoins d (ω i.rev)
  left_inv ω := by
    funext i x
    change ω i.rev.rev (reversePosition d (reversePosition d x)) = ω i x
    rw [Fin.rev_rev, reversePosition_involutive]
  right_inv ω := by
    funext i x
    change ω i.rev.rev (reversePosition d (reversePosition d x)) = ω i x
    rw [Fin.rev_rev, reversePosition_involutive]

lemma run_cons (d t : ℕ) (c : Coins d) (ω : History d t) :
    run d (t+1) (Fin.cons c ω) = run d t ω * step d c := by
  simp [run, List.ofFn_succ]

lemma reverseHistory_cons (d t : ℕ) (c : Coins (d+1)) (ω : History (d+1) t) :
    reverseHistory d (t+1) (Fin.cons c ω) = Fin.snoc (reverseHistory d t ω) (reverseCoins d c) := by
  ext i; refine Fin.lastCases ?_ (fun j => ?_) i
  · simp [reverseHistory]
  · simp [reverseHistory, Fin.rev_castSucc]

lemma reverse_run (d t : ℕ) (ω : History (d+1) t) :
    run (d+1) t (reverseHistory d t ω) =
      reversePosition (d+1) * (run (d+1) t ω)⁻¹ * reversePosition (d+1) := by
  have hr : reversePosition (d+1) * reversePosition (d+1) = 1 := by
    apply Equiv.ext; intro x; exact reversePosition_involutive (d+1) x
  induction t with
  | zero => simp [run_zero, hr]
  | succ t ih =>
      obtain ⟨⟨c,ω⟩,rfl⟩ := (Fin.consEquiv (fun _ : Fin (t+1) => Coins (d+1))).surjective ω
      change run (d+1) (t+1) (reverseHistory d (t+1) (Fin.cons c ω)) =
        reversePosition (d+1) * (run (d+1) (t+1) (Fin.cons c ω))⁻¹ * reversePosition (d+1)
      rw [reverseHistory_cons, run_succ]
      simp only [Fin.snoc_last, Fin.snoc_castSucc]
      rw [ih, reverse_step, run_cons, mul_inv_rev]
      calc
        _ = reversePosition (d+1) * (step (d+1) c)⁻¹ *
            (reversePosition (d+1) * reversePosition (d+1)) *
            (run (d+1) t ω)⁻¹ * reversePosition (d+1) := by group
        _ = _ := by rw [hr]; group

end Thorp.Conditional

end

end OAI