import OAI.Combinatorics.ContingencyTables.Rooted.ForestIntegerEvaluation
import OAI.Combinatorics.MatchingCount.Complexity.TreePolynomialSums

namespace OAI

/-! # Binary list evaluation of the forest's signed affine numerators

Each coefficient is stored by its nonnegative and nonpositive parts.
The program performs two finite product sums and passes their difference
to the proved interval-cost routine. Large capacities are never iterated.
-/

namespace ContingencyTables.ForestAffineProgram

open MatchingFPRAS MatchingFPRAS.TreeTyped
open scoped BigOperators Classical

abbrev Term := (ℕ×ℕ)×ℕ
abbrev Input := ((ℕ×ℕ)×List Term)×ℕ

def positiveTerm (z : Term) : ℕ := z.1.1*z.2
def negativeTerm (z : Term) : ℕ := z.1.2*z.2

def positiveTermRealizer : Realizer positiveTerm :=
  composition (f := fun z : Term => (z.1.1,z.2)) (g := fun z : ℕ×ℕ => z.1*z.2)
    (pair (composition first first) second) multiply

def negativeTermRealizer : Realizer negativeTerm :=
  composition (f := fun z : Term => (z.1.2,z.2)) (g := fun z : ℕ×ℕ => z.1*z.2)
    (pair (composition first second) second) multiply

lemma polynomial_positiveTerm : PolynomialTime positiveTermRealizer :=
  polynomial_composition (polynomial_pair
    (polynomial_composition polynomial_first polynomial_first) polynomial_second) polynomial_multiply

lemma polynomial_negativeTerm : PolynomialTime negativeTermRealizer :=
  polynomial_composition (polynomial_pair
    (polynomial_composition polynomial_first polynomial_second) polynomial_second) polynomial_multiply

def positiveSumRealizer : Realizer (fun xs : List Term => (xs.map positiveTerm).sum) :=
  composition (map positiveTermRealizer) listSum

def negativeSumRealizer : Realizer (fun xs : List Term => (xs.map negativeTerm).sum) :=
  composition (map negativeTermRealizer) listSum

lemma polynomial_positiveSum : PolynomialTime positiveSumRealizer :=
  polynomial_composition (polynomial_map polynomial_positiveTerm) polynomial_listSum

lemma polynomial_negativeSum : PolynomialTime negativeSumRealizer :=
  polynomial_composition (polynomial_map polynomial_negativeTerm) polynomial_listSum

def parts (z : Input) : ℕ×ℕ :=
  (z.1.1.1+(z.1.2.map positiveTerm).sum,z.1.1.2+(z.1.2.map negativeTerm).sum)

def partsRealizer : Realizer parts :=
  pair
    (composition (pair (composition (composition first first) first)
      (composition (composition first second) positiveSumRealizer)) add)
    (composition (pair (composition (composition first first) second)
      (composition (composition first second) negativeSumRealizer)) add)

lemma polynomial_parts : PolynomialTime partsRealizer :=
  polynomial_pair
    (polynomial_composition (polynomial_pair
      (polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_first)
      (polynomial_composition (polynomial_composition polynomial_first polynomial_second)
        polynomial_positiveSum)) polynomial_add)
    (polynomial_composition (polynomial_pair
      (polynomial_composition (polynomial_composition polynomial_first polynomial_first) polynomial_second)
      (polynomial_composition (polynomial_composition polynomial_first polynomial_second)
        polynomial_negativeSum)) polynomial_add)

def evaluate (z : Input) : TreeFraction.Fraction :=
  RationalIntervalProgram.intervalCode (parts z,z.2)

def evaluateRealizer : Realizer evaluate :=
  composition (f := fun z : Input => (parts z,z.2)) (g := RationalIntervalProgram.intervalCode)
    (pair partsRealizer second) RationalIntervalProgram.intervalCodeRealizer

theorem polynomial_evaluate : PolynomialTime evaluateRealizer :=
  polynomial_composition (polynomial_pair polynomial_parts polynomial_second)
    RationalIntervalProgram.polynomial_intervalCode

def signedParts (z : ℤ) : ℕ×ℕ := (z.toNat,(-z).toNat)

lemma signedParts_sub (z : ℤ) : ((signedParts z).1:ℤ)-(signedParts z).2=z := by
  change (z.toNat:ℤ)-((-z).toNat:ℤ)=z
  omega

noncomputable section
variable {q : ℕ}

def data (offset : ℤ) (coefficient : Fin q → ℤ) (v : Fin q → ℕ) (den : ℕ) : Input :=
  ((signedParts offset,List.ofFn (fun i => (signedParts (coefficient i),v i))),den)

lemma parts_data (offset : ℤ) (coefficient : Fin q → ℤ) (v : Fin q → ℕ) (den : ℕ) :
    ((parts (data offset coefficient v den)).1:ℤ)-(parts (data offset coefficient v den)).2=
      offset+∑ i,coefficient i*(v i:ℤ) := by
  simp only [parts,data,List.map_ofFn,Function.comp_apply,positiveTerm,negativeTerm,
    List.sum_ofFn,Nat.cast_add,Nat.cast_sum,Nat.cast_mul]
  rw [add_sub_add_comm,←Finset.sum_sub_distrib,signedParts_sub]
  congr 1
  apply Finset.sum_congr rfl
  intro i _
  rw [←sub_mul,signedParts_sub]

/-- All signs and products in an affine tree term are executed in
binary; the resulting fraction is its exact interval penalty. -/
theorem evaluate_data (offset : ℤ) (coefficient : Fin q → ℤ) (v : Fin q → ℕ)
    (den : ℕ) (hd : 0<den) :
    TreeFraction.val (evaluate (data offset coefficient v den))=
      max 0 (max (-(((offset:ℚ)+∑ i,(coefficient i:ℚ)*(v i:ℚ))/den))
        (((offset:ℚ)+∑ i,(coefficient i:ℚ)*(v i:ℚ))/den-1)) := by
  have he : ((parts (data offset coefficient v den)).1:ℚ)-
      (parts (data offset coefficient v den)).2=
      (offset:ℚ)+∑ i,(coefficient i:ℚ)*(v i:ℚ) := by
    exact_mod_cast parts_data offset coefficient v den
  calc
    _ = max 0 (max (-((((parts (data offset coefficient v den)).1:ℚ)-
          (parts (data offset coefficient v den)).2)/den))
        ((((parts (data offset coefficient v den)).1:ℚ)-
          (parts (data offset coefficient v den)).2)/den-1)) :=
      RationalIntervalProgram.intervalCode_value _ _ _ hd
    _ = _ := by rw [he]


open CompanionFactorialApplication ForestAssignmentSplit CompanionOracleDensity GraphCompletionCounts
open ForestIntegerEvaluation

variable {I J : Type*} [Fintype I] [Fintype J]

def forestData (A : Instance I J) (C : ℕ) (t : TreeCell A.T)
    (x y : I → J → ℤ) (e : Fin q ≃ FreeCell A.small A.T)
    (v : FreeCell A.small A.T → ℕ) : Input :=
  data ((rationalBinWidth A C:ℤ)*ForestIntegerEvaluation.offset A t x y)
    (fun i => ForestIntegerEvaluation.coefficient A t (e i).val*
      ((A.b (e i).val.1 (e i).val.2:ℤ)+1))
    (fun i => v (e i)) (rationalBinWidth A C*A.b t.val.1 t.val.2)

/-- This input is the literal cut-derived affine form of the manuscript.
The executable value is its exact contribution to the softened penalty. -/
theorem evaluate_forest (A : Instance I J) (C : ℕ) (hC : 0<C) (t : TreeCell A.T)
    (x y : I → J → ℤ) (e : Fin q ≃ FreeCell A.small A.T)
    (v : FreeCell A.small A.T → ℕ) :
    TreeFraction.val (evaluate (forestData A C t x y e v))=
      max 0 (max (-rationalScaledTree A C x y (fun f => (v f:ℚ)) t)
        (rationalScaledTree A C x y (fun f => (v f:ℚ)) t-1)) := by
  have hB : 0<rationalBinWidth A C := by
    unfold rationalBinWidth
    exact Nat.mul_pos (Nat.mul_pos (by decide) hC)
      (pow_pos (lt_of_lt_of_le Nat.zero_lt_one A.hd) _)
  have ht := (A.hlarge _ _ (A.hTG t.property)).2
  have hd := Nat.mul_pos hB ht
  have hn : (((rationalBinWidth A C:ℤ)*ForestIntegerEvaluation.offset A t x y:ℤ):ℚ)+
      ∑ i : Fin q,
        ((ForestIntegerEvaluation.coefficient A t (e i).val*
          ((A.b (e i).val.1 (e i).val.2:ℤ)+1):ℤ):ℚ)*(v (e i):ℚ)=
      (ForestIntegerEvaluation.numerator A C t x y v:ℚ) := by
    simp only [ForestIntegerEvaluation.numerator,Int.cast_add,Int.cast_mul,Int.cast_natCast,
      Int.cast_one,Int.cast_sum]
    congr 1
    exact Fintype.sum_equiv e _ _ (fun _ => rfl)
  unfold forestData
  rw [evaluate_data _ _ _ _ hd,hn,Nat.cast_mul,ForestIntegerEvaluation.numerator_div A C hC]

end
end ContingencyTables.ForestAffineProgram

end OAI