import Mathlib
import OAI.Computability.MaxCut.Analysis.CubeEquiv
import OAI.Computability.MaxCut.Estimates.ListSum

namespace OAI

noncomputable section
namespace OptimalMaxCut.RawGrid
open scoped BigOperators
open Finset MaxCutGames.Foundations.Target MaxCutGames.Foundations.Hastad
open LongCode LongCode.InstanceAdapter CounterMachine.Expr
attribute [local instance] Classical.propDecidable

@[simp] theorem vertices_bits {q : ℕ} (g : Instance q) : vertices (bits g) = g.vertices := (word_header g).1
@[simp] theorem edges_bits {q : ℕ} (g : Instance q) : edges (bits g) = g.constraints.length := (word_header g).2.2
@[simp] theorem row_source {q : ℕ} (g : Instance q) (e : Fin g.constraints.length) :
    row q (bits g) e 0 = g.constraints[e].source.val := by
  simpa [row] using InstanceAdapter.row_source g e
@[simp] theorem row_target {q : ℕ} (g : Instance q) (e : Fin g.constraints.length) :
    row q (bits g) e 1 = g.constraints[e].target.val := InstanceAdapter.row_target g e
@[simp] theorem row_image {q : ℕ} (g : Instance q) (e : Fin g.constraints.length) (i : Fin q) :
    row q (bits g) e (2+i.val) = g.constraints[e].permutation.images[i].val := InstanceAdapter.row_image g e i

@[simp] theorem degree_bits {q : ℕ} (g : Instance q) (y : Fin g.vertices) :
    degree q (bits g) y = InstanceAdapter.degree g y := by
  rw [degree, edges_bits, ← Fin.sum_univ_eq_sum_range]
  unfold InstanceAdapter.degree
  apply sum_congr rfl
  intro e he
  rw [row_target]
  simp only [Fin.val_inj]

@[simp] theorem lookup_fin {q : ℕ} (x : Cube (Fin q)) (i : Fin q) :
    lookup x i.val = (finTwoEquiv.symm (x i)).val := by
  simp [lookup, Fin.val_inj]

@[simp] theorem permCode_bits {q : ℕ} (g : Instance q) (e : Fin g.constraints.length)
    (x : Cube (Fin q)) :
    permCode (bits g) e x = (cubeEquiv q (cubePerm (MaxCutGames.Explicit.MachineOutputContract.permutationEquiv g.constraints[e].permutation) x)).val := by
  simp only [permCode, row_image, lookup_fin, cubeEquiv, Equiv.trans_apply, finFunctionFinEquiv_apply]
  rfl

@[simp] theorem query_bits {q : ℕ} (g : Instance q) (e : Fin g.constraints.length)
    (x : Cube (Fin q)) :
    query (bits g) e x = (vertexEquiv g.vertices q
      (g.constraints[e].source,cubePerm (MaxCutGames.Explicit.MachineOutputContract.permutationEquiv g.constraints[e].permutation) x)).val := by
  simp only [query, permCode_bits, row_source]
  rfl

@[simp] theorem gridSize_bits {q : ℕ} (g : Instance q) (K : ℕ) :
    gridSize q K (bits g) = Game.gridSize (Fin g.vertices) (Fin g.constraints.length) q K := by
  simp [gridSize, Game.gridSize, Game.Sample, vertices_bits, edges_bits]

 theorem rational_floor (c : ℚ) (hc : 0 ≤ c) (P d m : ℕ) :
    ⌊(P:ℚ)*((d:ℚ)*c/((m:ℚ)*(d:ℚ)^2))⌋₊ =
      P*d*c.num.toNat/(c.den*m*d^2) := by
  have hn : ((c.num.toNat:ℕ):ℚ) = (c.num:ℚ) := by
    exact_mod_cast Int.toNat_of_nonneg (Rat.num_nonneg.mpr hc)
  have hc' : c = ((c.num.toNat:ℕ):ℚ)/c.den := by rw [hn, Rat.num_div_den]
  conv_lhs => rw [hc']
  have he : (P:ℚ)*((d:ℚ)*(((c.num.toNat:ℕ):ℚ)/c.den)/((m:ℚ)*(d:ℚ)^2)) =
      ((P*d*c.num.toNat:ℕ):ℚ)/((c.den*m*d^2:ℕ):ℚ) := by
    push_cast
    simp only [div_eq_mul_inv, mul_inv_rev]
    ring
  rw [he, Nat.floor_div_natCast, Nat.floor_natCast]

@[simp] theorem atom_bits {q : ℕ} (g : Instance q) (t : ℚ)
    (ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ) (y : Fin g.vertices)
    (e f : Fin g.constraints.length) (x z : Cube (Fin q)) :
    atom t ht K (bits g) y e f x z =
      ⌊(Game.gridSize (Fin g.vertices) (Fin g.constraints.length) q K:ℚ)*
        ((ofInstance g).sampleLaw t ht).weight (y,e,f,x,z)⌋₊ := by
  rw [InstanceAdapter.sampleLaw_weight]
  simp only [atom, row_target, Fin.val_inj, gridSize_bits, degree_bits, edges_bits]
  split_ifs
  · exact (rational_floor _ ((jointLaw t ht q).nonneg _) _ _ _).symm
  · simp

/-- Byte-oriented integer aggregation is exactly the rational rounded law.
This identity is independent of computational complexity assumptions. -/
theorem weights_bits {q : ℕ} (g : Instance q) (t : ℚ)
    (ht : t ∈ Set.Icc (-1:ℚ) 1) (K : ℕ)
    (anchor : Fin (g.vertices*2^q)) (u v : Fin (g.vertices*2^q)) :
    (ofInstance g).gridWeights t ht (vertexEquiv g.vertices q) anchor K u v =
      (weights q t ht K (bits g) u.val v.val : ℚ) / gridSize q K (bits g) := by
  rw [Game.gridWeights, roundedWeights_integer, gridSize_bits]
  by_cases huv : u=v
  · subst v; simp [weights]
  · have hval : u.val ≠ v.val := fun h => huv (Fin.ext h)
    simp only [huv, ↓reduceIte, weights, hval, vertices_bits, edges_bits]
    congr 2
    rw [Fintype.sum_prod_type]
    rw [← Fin.sum_univ_eq_sum_range]
    apply sum_congr rfl
    intro y hy
    rw [Fintype.sum_prod_type, ← Fin.sum_univ_eq_sum_range]
    apply sum_congr rfl
    intro e he
    rw [Fintype.sum_prod_type, ← Fin.sum_univ_eq_sum_range]
    apply sum_congr rfl
    intro f hf
    rw [Fintype.sum_prod_type]
    apply sum_congr rfl
    intro x hx
    apply sum_congr rfl
    intro z hz
    simp only [query_bits, atom_bits, Game.queries, ofInstance, Prod.mk.injEq, ← Fin.val_inj]

end OptimalMaxCut.RawGrid

end

end OAI