import OAI.Combinatorics.ContingencyTables.Machines.CachedCompletionWeights
import OAI.Combinatorics.ContingencyTables.Machines.CachedDecisionSemantics
import OAI.Combinatorics.ContingencyTables.Transport.BooleanEnumeration
import OAI.Combinatorics.ContingencyTables.Transport.ListedIntegerLaw

namespace OAI

/-! # Weighted transitions from the cached completion list -/

namespace ContingencyTables.ProfilePrograms
open MatchingFPRAS MatchingFPRAS.TreeTyped DensePrograms
open scoped BigOperators Classical

attribute [local irreducible] cachedDecisionRealizer cachedDecision

abbrev DecisionQuery := ShortStep×(List ℕ×List ℕ)

/-- A rejected box entry contributes zero. A valid completion contributes
its cached integer multiplicity precisely when it reaches the target. -/
def decisionWeight (z : DecisionQuery×(Option MatrixCode×ℕ)) : ℕ :=
  z.2.1.elim 0 (fun X => if cachedDecision (z.1.1,X)=z.1.2 then z.2.2 else 0)

def decisionWeightRealizer : Realizer decisionWeight := by
  let input : Realizer (fun z : DecisionQuery×(Option MatrixCode×ℕ) =>
      ((z.1,z.2.2),z.2.1)) := pair (pair first (composition second second))
        (composition second first)
  let step : Realizer (fun z : (DecisionQuery×ℕ)×MatrixCode =>
      (z.1.1.1,z.2)) := pair (composition (composition first first) first) second
  let target : Realizer (fun z : (DecisionQuery×ℕ)×MatrixCode => z.1.1.2) :=
    composition (composition first first) second
  let test := composition (pair (composition step cachedDecisionRealizer) target) profileCodeEqual
  let entry := choose test (composition first second) (constant 0)
  exact (composition input (optionCases (constant 0) entry)).congr (by
    intro z
    simp only [Function.comp_apply,decide_eq_true_eq]
    rfl)

lemma polynomial_decisionWeight : PolynomialTime decisionWeightRealizer := by
  unfold decisionWeightRealizer
  apply polynomial_congr
  exact polynomial_composition
    (polynomial_pair (polynomial_pair polynomial_first
      (polynomial_composition polynomial_second polynomial_second))
      (polynomial_composition polynomial_second polynomial_first))
    (polynomial_optionCases (polynomial_constant 0) (polynomial_choose
      (polynomial_composition (polynomial_pair
        (polynomial_composition (polynomial_pair
          (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
            polynomial_first) polynomial_second) polynomial_cachedDecision)
        (polynomial_composition (polynomial_composition polynomial_first polynomial_first)
          polynomial_second)) polynomial_profileCodeEqual)
      (polynomial_composition polynomial_first polynomial_second) (polynomial_constant 0)))

def decisionWeightSum (z : DecisionQuery×List (Option MatrixCode×ℕ)) : ℕ :=
  (z.2.map (fun a => decisionWeight (z.1,a))).sum

def decisionWeightSumRealizer : Realizer decisionWeightSum :=
  composition (mapWith decisionWeightRealizer) listSum

lemma polynomial_decisionWeightSum : PolynomialTime decisionWeightSumRealizer :=
  polynomial_composition (polynomial_mapWith polynomial_decisionWeight) polynomial_listSum

end ContingencyTables.ProfilePrograms

namespace ContingencyTables.DensePrograms
open scoped BigOperators Classical
noncomputable section

/-- Free-box enumeration sums each feasible table's weight once. -/
lemma sum_completionWeights {m n d : ℕ} (R : Option (Fin m) → ℕ)
    (P : Option (Fin n) → ℕ) (hd : 14≤d) (hq : m*n≤d)
    (hR : ∀ i,d^12≤R i) (hP : ∀ j,d^12≤P j) (htotal : ∑ i,R i=∑ j,P j)
    (h : ℕ) (w : MatrixCode → ℕ) :
    ((completionWeights ((marginCode R,marginCode P),(d,h))).map
      (fun z => z.1.elim 0 (fun X => z.2*w X))).sum=
      ∑ X : Table R P,(canonicalCounts R P hd hR hP htotal h).count X*w (tableOutput X) := by
  rw [completionWeights_actual R P hd hq hR hP htotal h,List.map_ofFn,List.sum_ofFn]
  let f : BoxCompletion.Box m n (∑ i,R i) → ℕ := fun z =>
    (BoxCompletion.decode R P htotal (∑ i,R i) z).elim 0
      (fun X => (canonicalCounts R P hd hR hP htotal h).count X*w (tableOutput X))
  have hs := finFunctionFinEquiv.symm.sum_comp f
  have hi : (∑ k : Fin (((∑ i,R i)+1)^(m*n)),
      let o := BoxCompletion.decode R P htotal (∑ i,R i) (finFunctionFinEquiv.symm k)
      (o.map tableOutput).elim 0 (fun X =>
        o.elim 0 (fun T => (canonicalCounts R P hd hR hP htotal h).count T)*w X))=
      ∑ z : BoxCompletion.Box m n (∑ i,R i),f z := by
    rw [←hs]
    apply Finset.sum_congr rfl
    intro k _
    dsimp only [f]
    cases BoxCompletion.decode R P htotal (∑ i,R i) (finFunctionFinEquiv.symm k) <;> rfl
  exact hi.trans (BoxCompletion.sum_decode R P htotal le_rfl _)

end
end ContingencyTables.DensePrograms

namespace ContingencyTables.SmallGraphProfiles
open ProfilePrograms DensePrograms PhysicalCompletionFibres FirstPaperPhysicalMarginal
open SmallContextCoordinates CompletionCounts CompletionTranslation
open scoped BigOperators Classical
noncomputable section

attribute [local irreducible] canonicalCounts completionWeights decisionWeightSum

variable {m n q : ℕ} (r : Fin m → ℕ) (c : Fin n → ℕ)
variable (e : Fin q ≃ Cells (paperSmall r c))
variable (hr : 0<(largeIndices ((dimensionAllowance (I := Fin m) (J := Fin n))^20,List.ofFn r)).length)
variable (hc : 0<(largeIndices ((dimensionAllowance (I := Fin m) (J := Fin n))^20,List.ofFn c)).length)
local notation "d" => dimensionAllowance (I := Fin m) (J := Fin n)
local notation "R" => listedRows r c (d^20) (d^12) (stateCapacity r c) hr
local notation "P" => listedColumns r c (d^20) (d^12) (stateCapacity r c) hc
local notation "s" => smallProposalBits (I := Fin m) (J := Fin n)

lemma decisionWeightSum_actual (htotal : ∑ i,r i=∑ j,c j) (h : ℕ)
    (x y : PaperStates r c) (word : Fin s → Bool) :
    decisionWeightSum ((encodedShortStep r c e h x word,stateCode r c e y),
      completionWeights ((marginCode (R x),marginCode (P x)),(d,h)))=
      ∑ A : Table (R x) (P x),if completionDecision R P x (decodedCodeProposal r c e x word) A=y
        then (canonicalCounts (R x) (P x) (listed_dimension_fourteen r c hr hc)
          (listed_row_padding r c (d^20) (d^12) (stateCapacity r c) hr hc x)
          (listed_column_padding r c (d^20) (d^12) (stateCapacity r c) hr hc x)
          (listed_paper_totals r c hr hc x) h).count A else 0 := by
  let w : MatrixCode → ℕ := fun X =>
    if cachedDecision (encodedShortStep r c e h x word,X)=stateCode r c e y then 1 else 0
  have he : decisionWeightSum ((encodedShortStep r c e h x word,stateCode r c e y),
      completionWeights ((marginCode (R x),marginCode (P x)),(d,h)))=
      ((completionWeights ((marginCode (R x),marginCode (P x)),(d,h))).map
        (fun z => z.1.elim 0 (fun X => z.2*w X))).sum := by
    unfold decisionWeightSum
    congr 1
    apply List.map_congr_left
    intro z _
    rcases z with ⟨o,a⟩
    cases o with
    | none => rfl
    | some X =>
      simp only [decisionWeight,Option.elim_some,w]
      split_ifs <;> simp
  rw [he,sum_completionWeights (R x) (P x) (listed_dimension_fourteen r c hr hc)
    (by simpa only [Fintype.card_prod,Fintype.card_fin] using (listed_dimensions r c hr hc).2.2)
    (listed_row_padding r c (d^20) (d^12) (stateCapacity r c) hr hc x)
    (listed_column_padding r c (d^20) (d^12) (stateCapacity r c) hr hc x)
    (listed_paper_totals r c hr hc x) h w]
  apply Finset.sum_congr rfl
  intro A _
  simp only [w,cachedDecision_encoded r c e hr hc htotal h x word A,
    (stateCode_injective r c e).eq_iff]
  split_ifs <;> simp

end
end ContingencyTables.SmallGraphProfiles

end OAI