import Mathlib
import OAI.Combinatorics.KServer.FiniteLaw

namespace OAI

/-! Relabel a finite metric across universes without changing the experiment,
initial labels, service constraints, optimal cost or behavior-policy horizon. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer.FiniteMetricTransport
attribute [local instance] Classical.propDecidable Classical.decEq
universe u v
variable {Y:Type u} {Z:Type v}

lemma configuration_map {k:ℕ} (f:Y→Z) (s:Configuration k Y) (h:List (Y×Fin k)):
    configurationAfter (f∘s) (mapHistory f h)=f∘configurationAfter s h:=by
  induction h generalizing s with
  | nil=>rfl
  | cons a h ih=>
    simp only [mapHistory,List.map_cons,configurationAfter,List.foldl_cons]
    change configurationAfter (serve (f∘s) a.2 (f a.1)) (mapHistory f h)=
      f∘configurationAfter (serve s a.2 a.1) h
    rw [←map_serve f]
    exact ih _

lemma stronglyLazy {k:ℕ} (e:Y≃Z) (s:Configuration k Y) (A:Policy k Z)
    (hA:StronglyLazy (e∘s) A):StronglyLazy s (retractPolicy e A):=by
  intro h r hi j hj
  apply hA (mapHistory e h) (e r)
  · obtain ⟨i,hi⟩:=hi
    refine ⟨i,?_⟩
    rw [configuration_map]
    exact congrArg e hi
  · rw [configuration_map]
    exact fun he=>hj (e.injective he)

variable [MetricSpace Y] [MetricSpace Z]
lemma cost {k:ℕ} (e:Y≃Z) (he:Isometry e.symm) (s:Configuration k Y) (A:Policy k Z) (σ:List Y):
    expectedCost (retractPolicy e A) s σ=expectedCost A (e∘s) (σ.map e):=by
  have hh:=expectedCost_retract e e.symm e.apply_symm_apply he A (e∘s) (σ.map e)
  simpa [Function.comp_def] using hh

variable [Fintype Y] [Fintype Z]
omit [MetricSpace Y] [MetricSpace Z] in
def lawOn {H:ℕ} (e:Y≃Z) (law:FiniteDistribution (Fin H→Y)):FiniteDistribution (Fin H→Z):=
  ⟨fun σ=>law.val (e.symm∘σ),fun σ=>law.property.1 _,by
    calc
      (∑ σ:Fin H→Z,law.val (e.symm∘σ))=∑ σ:Fin H→Y,law.val σ:=by
        exact Fintype.sum_equiv (Equiv.arrowCongr (Equiv.refl (Fin H)) e.symm)
          _ _ (fun _=>rfl)
      _=1:=law.property.2⟩

omit [MetricSpace Y] [MetricSpace Z] in
lemma sum_lawOn {H:ℕ} (e:Y≃Z) (law:FiniteDistribution (Fin H→Y)) (f:(Fin H→Z)→ℝ):
    (∑ σ:Fin H→Z,(lawOn e law).val σ*f σ)=∑ σ:Fin H→Y,law.val σ*f (e∘σ):=by
  apply Fintype.sum_equiv (Equiv.arrowCongr (Equiv.refl (Fin H)) e.symm)
  intro σ
  dsimp only [lawOn,Equiv.arrowCongr,Equiv.refl,Equiv.coe_fn_mk,Function.comp_def]
  congr 2
  funext i
  exact (e.apply_symm_apply (σ i)).symm

lemma mean_cost {k H:ℕ} (e:Y≃Z) (he:Isometry e.symm) (s:Configuration k Y)
    (A:Policy k Z) (law:FiniteDistribution (Fin H→Y)):
    (∑ σ:Fin H→Y,law.val σ*expectedCost (retractPolicy e A) s (List.ofFn σ))=
      ∑ σ:Fin H→Z,(lawOn e law).val σ*expectedCost A (e∘s) (List.ofFn σ):=by
  rw [sum_lawOn]
  apply sum_congr rfl
  intro σ _
  rw [cost e he,List.map_ofFn]

lemma mean_opt {k H:ℕ} [NeZero k] (e:Y≃Z) (he:Isometry e) (s:Configuration k Y)
    (law:FiniteDistribution (Fin H→Y)):
    (∑ σ:Fin H→Z,(lawOn e law).val σ*optimalCost (e∘s) (List.ofFn σ))=
      ∑ σ:Fin H→Y,law.val σ*optimalCost s (List.ofFn σ):=by
  rw [sum_lawOn]
  apply sum_congr rfl
  intro σ _
  simpa only [List.map_ofFn] using congrArg (fun c:ℝ=>law.val σ*c)
    (optimalCost_map e he s (List.ofFn σ))
end KServer.FiniteMetricTransport

end


/-! Unconditional finite-law theorem, with one absolute coefficient and a
law/horizon-independent inventory. Finite relabeling removes the construction's
universe-zero implementation restriction. -/
noncomputable section
open scoped BigOperators
open Finset
namespace KServer
open GlobalEndpoint FiniteMetricTransport
attribute [local instance] Classical.propDecidable Classical.decEq
universe u

theorem finite_law : FiniteLawStatement.{u}:=by
  refine ⟨competitiveMultiplier,?_⟩
  intro Y mY fY _ k hk s
  have : NeZero k:=⟨by omega⟩
  let Z:=Fin (Fintype.card Y)
  let e:Y≃Z:=Fintype.equivFin Y
  let : MetricSpace Z:=e.symm.metricSpace
  have hes:Isometry e.symm:=isometry_iff_dist_eq.mpr (fun _ _=>rfl)
  have he:Isometry e:=isometry_iff_dist_eq.mpr (fun x y=>by
    change dist (e.symm (e x)) (e.symm (e y))=dist x y
    rw [e.symm_apply_apply,e.symm_apply_apply])
  have hkr:1≤(k:ℝ):=by exact_mod_cast (show 1≤k by omega)
  obtain ⟨R,hR,L,hL,hdia,hf⟩:=finite_scales Z
  obtain ⟨D,hD,hall⟩:=finite_geometric (e∘s) hkr hR hL hdia hf
  refine ⟨D,hD,?_⟩
  intro H law
  obtain ⟨A,hA,hcost⟩:=hall H (lawOn e law)
  refine ⟨retractPolicy e A,stronglyLazy e s A hA,?_⟩
  rw [mean_cost e hes s A law]
  rw [mean_opt e he s law] at hcost
  exact hcost

/-- The positive universal constant strengthens ReductionStatement. -/


def MainStatement : Prop :=
  ∃ C : ℝ, 0 < C ∧ ∀ (k : ℕ), 2 ≤ k →
    ∀ (X : Type u) (_ : MetricSpace X),
      (∃ e : Fin (k + 1) → X, Function.Injective e) →
      ∀ s : Configuration k X,
        ∃ A : Policy k X, ∃ B : ℝ,
          0 ≤ B ∧ (Function.Injective s → B = 0) ∧
          ∀ σ : List X,
            expectedCost A s σ ≤ C * (Real.log (k + 1)) ^ 2 * optimalCost s σ + B

theorem fully_quantified_main : MainStatement.{u}:=by
  obtain ⟨C,hC⟩:=finite_law_suffices_for_main finite_law.{u}
  refine ⟨max C 1,lt_of_lt_of_le (by norm_num : (0:ℝ)<1) (le_max_right C 1),?_⟩
  intro k hk X mX hX s
  have : NeZero k:=⟨by omega⟩
  obtain ⟨A,B,hB,hzero,hcost⟩:=hC k hk X mX hX s
  refine ⟨A,B,hB,hzero,?_⟩
  intro σ
  have hnp:0≤(Real.log ((k:ℝ)+1))^2*optimalCost s σ:=
    mul_nonneg (sq_nonneg _) (optimalCost_nonneg s σ)
  have hm:=mul_le_mul_of_nonneg_right (le_max_left C 1) hnp
  have hh:=hcost σ
  nlinarith only [hh,hm]
end KServer

end


namespace KServer
universe u
/-- A positive absolute squared-logarithmic competitive bound on arbitrary metrics,
with one causal policy for all horizons and every labeled starting configuration. -/
theorem main_theorem : MainStatement.{u} := fully_quantified_main
end KServer

end OAI