import OAI.Computability.FourierTransform.IntervalEffects

namespace OAI
/-! Word primitives across equal disjoint intervals. Uniform shear realizations. -/
namespace PowerSaving.Slant

open Zone Reel Stroke Spectral Binary Complex
noncomputable section

/- aligned spells with coordinates u and v -/
def shade (u v : Zone) (f g : Line) : Reel :=
  tick ⟨id, (fun i => if u.has i then f (i-u.lo) else if v.has i then g (i-v.lo)
          else 1),id⟩

def jumps (u v : Zone) (i : ℕ) :=
  if u.has i then v.lo+(i-u.lo)
  else if v.has i then u.lo+(i-v.lo) else i

def snap (u v : Zone) : Reel := tick ⟨id,fun _ => 1,jumps u v⟩

theorem sound_shade {u v : Zone} {f g : Line} {n : ℕ} (h : u.Fits n) (k : v.Fits n) :
    (shade u v f g).Sound n := by
  apply Reel.sound_tick
  refine ⟨fun _ hi => hi,fun _ hi => hi,fun _ => rfl,fun _ _ => rfl,
    fun _ _ => rfl,fun i hi => ?_⟩
  exact (ite_eq_right_iff.mpr fun hu => by
    have := h _ hu; omega).trans (ite_eq_right (fun hv => by have := k _ hv; omega))

lemma jumps_u {u v : Zone} {i} (h : i<u.wide) :
    jumps u v (u.lo+i)=v.lo+i := by simp [jumps,u.inside h]

lemma jumps_v {u v : Zone} (h : u.Sep v) {i} (g : i<v.wide) :
    jumps u v (v.lo+i)=u.lo+i := by
  simp [jumps, v.inside g, h.symm _ (v.inside g)]

lemma sound_snap {u v : Zone} {n : ℕ} (h : u.Fits n) (g : v.Fits n)
    (hv : u.wide=v.wide) (hw : u.Sep v) : (snap u v).Sound n := by
  have H1 (i : ℕ) (hi : u.has i) : jumps u v i=v.lo+(i-u.lo) := by rw [jumps,ite_eq_left hi]
  have H2 (i : ℕ) (hi : v.has i) : jumps u v i=u.lo+(i-v.lo) := by
    rw [jumps,ite_eq_right (hw.symm _ hi), ite_eq_left hi]
  apply sound_tick
  refine ⟨fun i hi => hi, fun i hi => ?_, fun i => ?_, fun i hi => rfl,fun i hi => ?_,
    fun i hi => rfl⟩
  · change jumps u v i<n
    by_cases hk : u.has i
    · rw [H1 i hk]; exact g _ (v.inside (hv ▸ u.enter hk))
    by_cases hk' : v.has i
    · rw [H2 i hk']; exact h _ (u.inside (hv.symm ▸ v.enter hk')) -- dep rewrite?
    · simpa only [jumps,ite_eq_right hk,ite_eq_right hk']
  · change jumps u v (jumps u v i)=i
    by_cases hk : u.has i
    · rw [H1 i hk, jumps_v hw (hv ▸ u.enter hk),u.identify hk]
    by_cases hk' : v.has i
    · rw [H2 i hk', jumps_u (hv.symm ▸ v.enter hk'),v.identify hk']
    · simp only [jumps,ite_eq_right hk,ite_eq_right hk']
  · unfold jumps; dsimp
    split
    · rename_i hk; have := h _ hk; omega
    split
    · rename_i hk; have := g _ hk; omega
    · rfl

abbrev Bicolor := ℂ × ℂ

def twinsAt (u v : Zone) (x : Line) (i : ℕ) : Bicolor := (u.peek x i,v.peek x i)

structure Twins (r : Reel) (u v : Zone) (f : ℕ → Bicolor → Bicolor) : Prop where
  acts : ∀ x i, i<u.wide → twinsAt u v (r.go x) i=f i (twinsAt u v x i)
  waits : ∀ x i, ¬u.has i → ¬v.has i → r.go x i=x i

lemma Twins.stack {r s : Reel} {u v f g} (h : Twins r u v f) (k : Twins s u v g) :
    Twins (r.stack s) u v (fun i x => g i (f i x)) :=
  ⟨fun x i hi => by rw [go_stack, k.acts _ i hi,h.acts _ i hi],fun x i hi gi => by
    rw [go_stack,k.waits _ _ hi gi,h.waits _ _ hi gi]⟩

lemma Twins.congr {r : Reel} {u v f g} (h : Twins r u v f)
    (k : ∀ i<u.wide, ∀ t, f i t=g i t) :
    Twins r u v g :=
  ⟨fun x i hi => (h.acts x i hi).trans (k i hi _),h.waits⟩

section
variable {u v : Zone} (hv : u.wide=v.wide) (hw : u.Sep v)

include hv hw

lemma twins_shade (f g : Line) :
    Twins (shade u v f g) u v (fun i t => (f i * t.1, g i * t.2)) := by
  constructor
  · intro x i hi
    have hp := u.inside hi
    have hh := v.inside (hv ▸ hi)
    simp [shade,twinsAt,Zone.peek,drift,send,applyM,applyC,hp,hh,hw.symm _ hh]
  · intro x i hi hk
    simp [shade,send,applyM,applyC,hi,hk]

lemma twins_snap :
    Twins (snap u v) u v (fun _ t => (ca*t.1+cb*t.2,ca*t.2+cb*t.1)) := by
  constructor
  · intro x i hi
    have hh : u.lo ≠ v.lo := by
      intro g
      have H (i) := hw.symm i
      exact H (v.lo+i) (v.inside (hv ▸ hi)) (by rw [← g]; exact u.inside hi)
    simp [snap,twinsAt,Zone.peek,drift,send,applyC,applyM,
      jumps_u (v:=v) hi,jumps_v hw (hv ▸ hi),hh,Ne.symm hh]
  · intro x i hi hk
    simp [snap,send,applyC,applyM,jumps,hi,hk]

end

def hinge (u v : Zone) : Reel :=
  ((shade u v (fun _ => 1) (fun _ => I)).stack (snap u v)).stack
    (shade u v (fun _ => 1-I) (fun _ => 1+I))

def brick (u v : Zone) : Reel :=
  ((((hinge u v).stack (shade u v (fun _ => -3) (fun _ => 1))).stack
      (hinge u v)).stack (shade u v (fun _ => 2) (fun _ => 1))).stack (hinge u v)

/-- Shear strong when f ≠ 0. -/
def spark (u v : Zone) (f : Line) : Reel :=
  ((shade u v (fun i => (4*f i/5)⁻¹) (fun _ => 1)).stack (brick u v)).stack
    (shade u v (fun i => (-1/8)*(4*f i/5)) (fun _ => -1/6))

def blaze (f : Line) : Line := fun i => 1+ f i * starRingEnd ℂ (f i)

/-- Avoid a coefficient zero test: uniform word for adding f*src. -/
def flash (dst src : Zone) (f : Line) : Reel :=
  (spark dst src (blaze f)).stack (spark dst src (fun i => f i-blaze f i))

section
variable {u v : Zone} {n : ℕ} (h : u.Fits n) (g : v.Fits n)
  (hv : u.wide=v.wide) (hw : u.Sep v)

include h g hv hw

lemma sound_hinge : (hinge u v).Sound n :=
  ((sound_shade h g).stack (sound_snap h g hv hw)).stack (sound_shade h g)

lemma sound_brick : (brick u v).Sound n :=
  have hp := sound_hinge h g hv hw
  ((((hp.stack (sound_shade h g)).stack hp).stack (sound_shade h g)).stack hp)

lemma sound_spark (f : Line) : (spark u v f).Sound n :=
  ((sound_shade h g).stack (sound_brick h g hv hw)).stack (sound_shade h g)

lemma sound_flash (f : Line) : (flash u v f).Sound n :=
  (sound_spark h g hv hw _).stack (sound_spark h g hv hw _)

omit h g

lemma twins_hinge :
    Twins (hinge u v) u v (fun _ t => (t.1+t.2,t.1-t.2)) := by
  unfold hinge
  refine (((twins_shade hv hw _ _).stack (twins_snap hv hw)).stack
    (twins_shade hv hw _ _)).congr ?_
  intro i hi t
  apply Prod.ext
  · apply Complex.ext <;> norm_num [ca,cb,mul_re,mul_im] <;> ring
  · apply Complex.ext <;> norm_num [ca,cb,mul_re,mul_im] <;> ring

lemma twins_brick :
    Twins (brick u v) u v (fun _ t => (-8*t.1-10*t.2,-6*t.2)) := by
  unfold brick
  have hp := twins_hinge hv hw
  refine (((((hp.stack (twins_shade hv hw _ _)).stack hp).stack (twins_shade hv hw _ _)).stack hp)).congr ?_
  intro i hi t
  apply Prod.ext <;> dsimp <;> ring

lemma twins_spark (f : Line) (hh : ∀ i<u.wide, f i ≠ 0) :
    Twins (spark u v f) u v (fun i t => (t.1+f i*t.2,t.2)) := by
  unfold spark
  refine (((twins_shade hv hw _ _).stack (twins_brick hv hw)).stack
    (twins_shade hv hw _ _)).congr ?_
  intro i hi t
  have hz := hh i hi
  apply Prod.ext <;> dsimp
  · field_simp
    ring
  · ring

omit hv hw

lemma blaze_ne (f : Line) (i : ℕ) : blaze f i ≠ 0 := by
  rw [blaze,Complex.mul_conj]
  intro h
  have H := congrArg re h
  simp [normSq_apply] at H
  nlinarith

lemma after_ne (f : Line) (i : ℕ) : f i-blaze f i ≠ 0 := by
  rw [blaze,Complex.mul_conj]
  intro h
  have H := congrArg re h
  simp [normSq_apply] at H
  nlinarith

include hv hw

lemma twins_flash (f : Line) :
    Twins (flash u v f) u v (fun i t => (t.1+f i*t.2,t.2)) := by
  unfold flash
  refine ((twins_spark hv hw (blaze f) (fun i _ => blaze_ne f i)).stack (twins_spark hv hw
    (fun i => f i-blaze f i) (fun i _ => after_ne f i))).congr ?_
  intro i hi t
  apply Prod.ext
  · dsimp; ring
  · rfl

lemma spill_flash (f : Line) :
    Spill (flash u v f) v u (fun x i => f i * x i) := by
  have h := twins_flash hv hw f
  constructor
  · intro x i hi
    exact congrArg Prod.fst (h.acts x i hi)
  · intro x i hi
    by_cases hk : v.has i
    · have hh := congrArg Prod.snd (h.acts x (i-v.lo) (hv.symm ▸ v.enter hk))
      simpa [Zone.peek,drift,twinsAt, v.identify hk] using hh
    · exact h.waits x i hi hk

end

@[simp] lemma beats_shade (u v : Zone) (f g : Line) : (shade u v f g).beats=1 := rfl
@[simp] lemma beats_snap (u v : Zone) : (snap u v).beats=1 := rfl
@[simp] lemma beats_hinge (u v : Zone) : (hinge u v).beats=3 := rfl
@[simp] lemma beats_brick (u v : Zone) : (brick u v).beats=11 := rfl
@[simp] lemma beats_spark (u v : Zone) (f : Line) : (spark u v f).beats=13 := rfl
@[simp] lemma beats_flash (u v : Zone) (f : Line) : (flash u v f).beats=26 := rfl

end
end PowerSaving.Slant

end OAI