import OAI.Combinatorics.EditApproximation.Geometry.BandGuards
import Mathlib.Data.Int.Log
import OAI.Combinatorics.EditApproximation.Definitions


namespace OAI

/-!
# Actual dyadic child envelopes

The maximum scans the actual finite band. The dyadic ceiling uses the
computable integer upper logarithm of a positive rational, including values
below one.
-/

namespace EditApproximation

open Finset



theorem rationalMaximum_le (fallback upper : ℚ) (values : List ℚ)
    (hfallback : fallback ≤ upper) (hvalues : ∀ value ∈ values, value ≤ upper) :
    rationalMaximum fallback values ≤ upper := by
  induction values with
  | nil => exact hfallback
  | cons value rest ih =>
    exact max_le (hvalues value (by simp)) (ih (fun value hv => hvalues value (by simp [hv])))

theorem le_rationalMaximum_member (fallback : ℚ) (values : List ℚ) (value : ℚ)
    (hvalue : value ∈ values) : value ≤ rationalMaximum fallback values := by
  induction values with
  | nil => simp only [List.not_mem_nil] at hvalue
  | cons head rest ih =>
    rcases List.mem_cons.mp hvalue with rfl | hrest
    · exact le_max_left _ _
    · exact (ih hrest).trans (le_max_right _ _)



theorem rationalDyadicCeiling_bounds (value : ℚ) (hvalue : 0 < value) :
    value ≤ rationalDyadicCeiling value ∧ rationalDyadicCeiling value < 2 * value := by
  constructor
  · exact Int.self_le_zpow_clog (by decide : 1 < 2) value
  · have h := mul_lt_mul_of_pos_right
      (Int.zpow_pred_clog_lt_self (by decide : 1 < 2) hvalue) (by norm_num : (0 : ℚ) < 2)
    change (2 : ℚ) ^ (Int.clog 2 value - 1) * 2 < value * 2 at h
    have hexponent : Int.clog 2 value - 1 + 1 = Int.clog 2 value := by omega
    rw [← zpow_add_one₀ (by norm_num : (2 : ℚ) ≠ 0), hexponent] at h
    simpa only [rationalDyadicCeiling, mul_comm] using h

/-- Zero is a harmless duplicated fallback under the initial table lower
invariant. The positive b/M floor ensures that the ceiling input is positive. -/


theorem bandChildEnvelope_lower {ny M : ℕ} (b : ℕ)
    (band : List (Fin M → TargetInterval ny))
    (initial : Fin M → TargetInterval ny → ℚ) (i : Fin M) :
    (b : ℚ) / M ≤ bandChildEnvelope b band initial i ∧
      ∀ action ∈ band, initial i (action i) ≤ bandChildEnvelope b band initial i := by
  have hceil := Int.self_le_zpow_clog (R := ℚ) (by decide : 1 < 2)
    (max ((b : ℚ) / M) (rationalMaximum 0 (band.map fun action => initial i (action i))))
  refine ⟨(le_max_left _ _).trans hceil, ?_⟩
  intro action ha
  exact (le_rationalMaximum_member 0 _ _ (List.mem_map.mpr ⟨action, ha, rfl⟩)).trans
    ((le_max_right _ _).trans hceil)

/-- Every finite envelope is bounded using the actual computed-band
endpoint diameter and the initial table's spatial inequality. -/
theorem bandChildEnvelope_upper {nx ny M : ℕ} (parent : TargetInterval nx)
    (r : TargetInterval ny) (b P : ℕ) (hb : 0 < b) (hM : 0 < M)
    (tau theta velocity : ℚ) (htau : 0 < tau) (htheta : 0 ≤ theta)
    (child initial : Fin M → TargetInterval ny → ℚ)
    (comparison : Fin M → TargetInterval ny)
    (hcomparison : comparison ∈ computedBandActions parent r b P tau theta velocity child)
    (L0 : ℚ) (hL0 : 0 ≤ L0)
    (hinitial : ∀ i, 0 ≤ initial i (comparison i))
    (hspatial : ∀ i s t, initial i s ≤ initial i t + L0 * targetEndpointDistance s t)
    (i : Fin M) :
    bandChildEnvelope b (computedBandActions parent r b P tau theta velocity child) initial i ≤
      2 * ((b : ℚ) / M) + 2 * initial i (comparison i) + 8 * L0 * theta * b / M := by
  let band := computedBandActions parent r b P tau theta velocity child
  let delta : ℚ := 4 * theta * b / M
  let upper := initial i (comparison i) + L0 * delta
  have hdelta : 0 ≤ delta := by dsimp only [delta]; positivity
  have hupper : 0 ≤ upper := add_nonneg (hinitial i) (mul_nonneg hL0 hdelta)
  have hmembers : ∀ value ∈ band.map (fun action => initial i (action i)), value ≤ upper := by
    intro value hvalue
    obtain ⟨action, ha, rfl⟩ := List.mem_map.mp hvalue
    have hdistReal := computedBand_child_endpoint_diameter parent r b P tau theta velocity htau htheta
      child action comparison ha hcomparison i
    have hdist : (targetEndpointDistance (action i) (comparison i) : ℚ) ≤ delta := by exact_mod_cast hdistReal
    exact (hspatial i (action i) (comparison i)).trans
      (add_le_add le_rfl (mul_le_mul_of_nonneg_left hdist hL0))
  have hmaximum := rationalMaximum_le 0 upper _ hupper hmembers
  have hfloor : (0 : ℚ) < (b : ℚ) / M := div_pos (by exact_mod_cast hb) (by exact_mod_cast hM)
  have hpositive := hfloor.trans_le (le_max_left ((b : ℚ) / M)
    (rationalMaximum 0 (band.map fun action => initial i (action i))))
  have hceil := (rationalDyadicCeiling_bounds _ hpositive).2.le
  have hmaxUpper : max ((b : ℚ) / M)
      (rationalMaximum 0 (band.map fun action => initial i (action i))) ≤ (b : ℚ) / M + upper := by
    apply max_le
    · exact le_add_of_nonneg_right hupper
    · exact hmaximum.trans (le_add_of_nonneg_left hfloor.le)
  apply hceil.trans
  have hmul := mul_le_mul_of_nonneg_left hmaxUpper (by norm_num : (0 : ℚ) ≤ 2)
  dsimp only [upper, delta] at hmul
  convert hmul using 1
  ring

/-- The actual sum guard follows from the concrete envelopes, the initial
cone bounds at the comparison child states, and their actual edit costs. -/
theorem bandChildEnvelope_sum_guard {α : Type*} (source target : List α)
    {M : ℕ} (parent : TargetInterval source.length) (r : TargetInterval target.length)
    (b P : ℕ) (hb : 0 < b) (hM : 0 < M)
    (tau theta velocity : ℚ) (htau : 0 < tau) (htheta : 0 ≤ theta)
    (child initial : Fin M → TargetInterval target.length → ℚ)
    (comparison : Fin M → TargetInterval target.length)
    (hcomparison : comparison ∈ computedBandActions parent r b P tau theta velocity child)
    (L0 F : ℚ) (hL0 : 0 ≤ L0) (hF : 1 ≤ F) (hsmall : L0 * theta ≤ 1)
    (hinitial : ∀ i, 0 ≤ initial i (comparison i))
    (hspatial : ∀ i s t, initial i s ≤ initial i t + L0 * targetEndpointDistance s t)
    (hinitialUpper : ∀ i, initial i (comparison i) ≤ 2 * F * (stateEditCost
      (substring source (sourceChild parent i).lo (sourceChild parent i).hi) target (comparison i) : ℚ))
    (hcomparisonCost : (∑ i : Fin M, (stateEditCost
      (substring source (sourceChild parent i).lo (sourceChild parent i).hi) target (comparison i) : ℚ)) ≤ 4 * b) :
    (∑ i : Fin M, bandChildEnvelope b
      (computedBandActions parent r b P tau theta velocity child) initial i) ≤ 64 * F * b := by
  have hMr : (0 : ℚ) < M := by exact_mod_cast hM
  have hpoint := fun i => bandChildEnvelope_upper parent r b P hb hM tau theta velocity htau htheta
    child initial comparison hcomparison L0 hL0 hinitial hspatial i
  have hsum := sum_le_sum (fun i (_ : i ∈ (univ : Finset (Fin M))) => hpoint i)
  have hequal : (∑ i : Fin M, (2 * ((b : ℚ) / M) + 2 * initial i (comparison i) +
      8 * L0 * theta * b / M)) = 2 * b + 2 * (∑ i : Fin M, initial i (comparison i)) +
        8 * L0 * theta * b := by
    rw [sum_add_distrib, sum_add_distrib, sum_const, sum_const,
      card_univ, Fintype.card_fin, ← mul_sum]
    simp only [nsmul_eq_mul]
    field_simp [hMr.ne']
  rw [hequal] at hsum
  have hinitSum := sum_le_sum (fun i (_ : i ∈ (univ : Finset (Fin M))) => hinitialUpper i)
  rw [← mul_sum] at hinitSum
  have hFpos : 0 ≤ 2 * F := by linarith
  have hcost := mul_le_mul_of_nonneg_left hcomparisonCost hFpos
  have hsmallb := mul_le_mul_of_nonneg_right hsmall (show (0 : ℚ) ≤ b by positivity)
  have hFb := mul_le_mul_of_nonneg_right hF (show (0 : ℚ) ≤ b by positivity)
  nlinarith only [hsum, hinitSum, hcost, hsmallb, hFb]

end EditApproximation

end OAI