lean/OAI/GroupTheory/SimpleOvergroups/ContextualCompiler.lean

import Mathlib
import OAI.Computability.FiniteCompiler.TapeFolding
import OAI.GroupTheory.SimpleOvergroups.BoundedFamilyTests
import OAI.GroupTheory.SimpleOvergroups.CommonCompiler
import OAI.GroupTheory.SimpleOvergroups.DoubleEffective
import OAI.GroupTheory.SimpleOvergroups.FamilyProgram
import OAI.GroupTheory.SimpleOvergroups.EffectiveFamilies

namespace OAI


namespace SimpleFInftyOvergroups.ContextualEncoding.Source
noncomputable section
open FiniteAlgebraicEnvelopes Bootstrap Compiler Compiler.Simulator MachineRealization
open BoundedEncoding NamedAction
open scoped Classical Compiler.HeadCodec

abbrev Sigma := ThreeCodes.Alphabet

def rel (a b : Sigma) : Prop := Encodable.encode a < Encodable.encode b
local instance : DecidableRel rel := fun _ _ => inferInstanceAs (Decidable (_ < _))
local instance : Std.Trichotomous rel := ⟨fun a b hab hba => by
  apply Encodable.encode_injective
  change ¬Encodable.encode a < Encodable.encode b at hab
  change ¬Encodable.encode b < Encodable.encode a at hba
  omega⟩
theorem wf_rel : WellFounded rel := InvImage.wf Encodable.encode Nat.lt_wfRel.wf

theorem primrec_shortlex : PrimrecRel (List.Shortlex rel) := by
  let ord : LinearOrder Sigma := LinearOrder.lift' Encodable.encode Encodable.encode_injective
  exact @Search.primrec_shortlex _ _ _ ord ⟨inferInstance, Primrec.dom_finite _⟩

def raw (n : ℕ) (w : List Sigma) : Part (List Sigma) :=
  WordProgramming.eval ((Encodable.decode n : Option Nat.Partrec.Code).getD .zero) w

theorem raw_encode (c : Nat.Partrec.Code) : raw (Encodable.encode c) = WordProgramming.eval c := by
  funext w
  simp [raw]

theorem partrec_raw : Partrec₂ raw :=
  WordProgramming.partrec_eval.comp
    (Primrec.option_getD.comp (Primrec.decode.comp Primrec.fst) (Primrec.const .zero)).to_comp Computable.snd

abbrev terminalAlphabet {Γ : Type*} (A : Alphabet (Sigma ⊕ Unit) Γ) :=
  UniversalMachine.restrict (ParameterMachine.alphabet A)
abbrev terminalMachine {Γ Q : Type*} [DecidableEq Γ] (A : Alphabet (Sigma ⊕ Unit) Γ) (M : Machine Q Γ) (n : ℕ) :=
  ParameterMachine.machine A M (.inr ()) n

structure Family where
  Γ : Type
  Q : Type
  [finiteΓ : Fintype Γ]
  [finiteQ : Fintype Q]
  [decΓ : DecidableEq Γ]
  [decQ : DecidableEq Q]
  [codeΓ : Primcodable Γ]
  [codeQ : Primcodable Q]
  A : Alphabet (Sigma ⊕ Unit) Γ
  M : Machine Q Γ
  decode : ∀ g a, (terminalAlphabet A).output g = some a → g = (terminalAlphabet A).input a
  realizes : ∀ n, Word.Realizes (terminalAlphabet A) (terminalMachine A M n) (raw n)

attribute [instance] Family.finiteΓ Family.finiteQ Family.decΓ Family.decQ Family.codeΓ Family.codeQ

theorem exists_family : Nonempty Family := by
  obtain ⟨Γ,Q,hΓ,hQ,dΓ,A,M,hd,hr⟩ := UniversalMachine.exists_parameter_machine partrec_raw
  let : Fintype Γ := hΓ
  let : Fintype Q := hQ
  let : DecidableEq Γ := dΓ
  let : Primcodable Γ := Effect.finitePrimcodable Γ
  let : Primcodable Q := Effect.finitePrimcodable Q
  exact ⟨⟨Γ,Q,A,M,UniversalMachine.restrict_decode (ParameterMachine.alphabet A)
    (ParameterMachine.output_decode A hd),hr⟩⟩

def family : Family := exists_family.some

variable {G : Type*} [Group G] {k : ℕ} (s : Fin k → G)
variable {Γ Q P₁ P₂ : Type} [Fintype Γ] [Fintype Q] [DecidableEq Γ] [DecidableEq Q]
  [Primcodable Γ] [Primcodable Q] [Primcodable P₁] [Primcodable P₂] [Finite P₁] [Finite P₂]
variable (A : Alphabet (Sigma ⊕ Unit) Γ) (M : Machine Q Γ)

local instance : Primcodable (ZMod 2) := Effect.finitePrimcodable _
local instance : Primcodable (ZMod 3) := Effect.finitePrimcodable _

abbrev Syntax := CommonCompiler.Letter Sigma Γ Q
abbrev Acting := EffectiveNames.Double.G₂ P₁ P₂ (ZMod 2) (Syntax (Γ:=Γ) (Q:=Q)) 7
abbrev Points := EffectiveNames.Double.X₂ P₁ P₂ (ZMod 2) (Syntax (Γ:=Γ) (Q:=Q)) 7
local instance : Primcodable (Syntax (Γ:=Γ) (Q:=Q)) := inferInstance
local instance : Primcodable (Acting (Γ:=Γ) (Q:=Q) (P₁:=P₁) (P₂:=P₂)) := inferInstance
local instance : Primcodable (Points (Γ:=Γ) (Q:=Q) (P₁:=P₁) (P₂:=P₂)) := inferInstance

abbrev ops := EffectiveNames.Double.operations (P₁:=P₁) (P₂:=P₂) (k₀:=ZMod 2) (n:=7)
  (Word.grade (S:=Sigma) (Γ:=Bool × Γ) (Q:=ParameterCode.Control Q))

abbrev Symbols (k : ℕ) : Fin 3 → Type _
  | 0 => Fin k × Bool
  | 1 => ProductFamily.Letter (Syntax (Γ:=Γ) (Q:=Q))
  | 2 => NamedAction.Letter (Acting (Γ:=Γ) (Q:=Q) (P₁:=P₁) (P₂:=P₂))
      (Points (Γ:=Γ) (Q:=Q) (P₁:=P₁) (P₂:=P₂))

abbrev Keys (k : ℕ) : Fin 3 → Type _
  | 0 => List (Fin k × Bool)
  | 1 => ProductFamily.Key (Syntax (Γ:=Γ) (Q:=Q))
  | 2 => List ℕ × (ℕ × ℕ) × List ℕ

local instance (i : Fin 3) : Primcodable (Symbols (Γ:=Γ) (Q:=Q) (P₁:=P₁) (P₂:=P₂) k i) :=
  match i with
  | 0 => inferInstance
  | 1 => inferInstance
  | 2 => inferInstance
local instance (i : Fin 3) : Primcodable (Keys (Γ:=Γ) (Q:=Q) k i) :=
  match i with
  | 0 => inferInstance
  | 1 => inferInstance
  | 2 => inferInstance

def cost : (i : Fin 3) → Symbols (Γ:=Γ) (Q:=Q) (P₁:=P₁) (P₂:=P₂) k i → ℕ
  | 0 => fun _ => 0
  | 1 => ProductFamily.cost (Path.letterGrade Word.gradeCell)
  | 2 => (ops (Γ:=Γ) (Q:=Q) (P₁:=P₁) (P₂:=P₂)).letterCost

def code (i : Fin 3) := ThreeCodes.code i (cost (Γ:=Γ) (Q:=Q) (P₁:=P₁) (P₂:=P₂) (k:=k) i)
def search (i : Fin 3) := ThreeCodes.search i (cost (Γ:=Γ) (Q:=Q) (P₁:=P₁) (P₂:=P₂) (k:=k) i)

omit [Finite P₁] [Finite P₂] in
theorem primrec_cost (i : Fin 3) : Primrec (cost (Γ:=Γ) (Q:=Q) (P₁:=P₁) (P₂:=P₂) (k:=k) i) := by
  fin_cases i
  · exact Primrec.const 0
  · exact ProductFamily.primrec_cost (A:=Syntax (Γ:=Γ) (Q:=Q))
      (CommonCompiler.primrec_letterGrade (T:=Sigma) (Γ:=Γ) (Q:=Q))
  · exact EffectiveNames.Double.primrec_cost (P₁:=P₁) (P₂:=P₂) (k₀:=ZMod 2) (n:=7)
      (Word.grade (S:=Sigma) (Γ:=Bool × Γ) (Q:=ParameterCode.Control Q))
      (CommonCompiler.primrec_grade (T:=Sigma) (Γ:=Γ) (Q:=Q))

variable (e₁ : P₁ → EffectiveNames.Enlargement.Coeff.Name (ZMod 2))
  (e₂ : P₂ → EffectiveNames.Enlargement.Coeff.Name (ZMod 3))

def normal (n : ℕ) (w : List (Syntax (Γ:=Γ) (Q:=Q))) : Part (List (Syntax (Γ:=Γ) (Q:=Q))) :=
  CommonCompiler.service A M (.inr ()) (terminalAlphabet A) (fun x => raw x.1 x.2) (n,w)

theorem partrec_normal : Partrec₂ (normal A M) :=
  CommonCompiler.partrec_service A M (.inr ()) (terminalAlphabet A) partrec_raw

def test : (i : Fin 3) → ℕ → List (Symbols (Γ:=Γ) (Q:=Q) (P₁:=P₁) (P₂:=P₂) k i) →
    Part (Option (Keys (Γ:=Γ) (Q:=Q) k i))
  | 0 => fun _ => GroupFamily.test s
  | 1 => fun n => ProductFamily.test [.zero] (normal A M n)
  | 2 => fun n => EffectiveNames.Double.test e₁ e₂ Word.grade [.zero] (normal A M n)

def tables (n : ℕ) : ℕ → Part (List (List Sigma × List Sigma)) :=
  FamilyProgram.compute (r:=rel) (code (Γ:=Γ) (Q:=Q) (P₁:=P₁) (P₂:=P₂) (k:=k)) search
    none (fun i => test s A M e₁ e₂ i n)

theorem partrec_test (h : ComputablePred (fun w => FiniteAlgebraicEnvelopes.evalWord s w = 1))
    (i : Fin 3) : Partrec₂ (test s A M e₁ e₂ i) := by
  fin_cases i
  · exact (GroupFamily.partrec_test s h).comp Computable.snd
  · exact ProductFamily.partrec_test (A:=Syntax (Γ:=Γ) (Q:=Q)) [.zero] (partrec_normal A M)
  · exact EffectiveNames.Double.partrec_test (P₁:=P₁) (P₂:=P₂) (k₀:=ZMod 2) (n:=7)
      e₁ e₂ (Word.grade (S:=Sigma) (Γ:=Bool × Γ) (Q:=ParameterCode.Control Q)) [.zero]
      (partrec_normal A M)

theorem partrec_tables (h : ComputablePred (fun w => FiniteAlgebraicEnvelopes.evalWord s w = 1)) :
    Partrec₂ (tables s A M e₁ e₂) :=
  FamilyProgram.partrec_compute _ _ _
    (fun i => ThreeCodes.primrec_words i _ (primrec_cost i))
    (fun i => ThreeCodes.primrec_encode i _ (primrec_cost i)) primrec_shortlex
    (partrec_test s A M e₁ e₂ h)

theorem exists_fixed_point (h : ComputablePred (fun w => FiniteAlgebraicEnvelopes.evalWord s w = 1)) :
    ∃ n, raw n = tableNormal (tables s A M e₁ e₂ n) := by
  have hh := partrec_tableNormal_parameter (partrec_tables s A M e₁ e₂ h)
  have hc : Partrec₂ (fun c : Nat.Partrec.Code => tableNormal (tables s A M e₁ e₂ (Encodable.encode c))) :=
    hh.comp (Computable.encode.comp Computable.fst) Computable.snd
  obtain ⟨c,hc⟩ := WordProgramming.fixed_point hc
  exact ⟨Encodable.encode c, (raw_encode c).trans hc⟩

variable (decode : ∀ g a, (terminalAlphabet A).output g = some a → g = (terminalAlphabet A).input a)
  (realizes : ∀ index, Word.Realizes (terminalAlphabet A) (terminalMachine A M index) (raw index))
  (he₁ : ∀ p, EffectiveNames.Enlargement.Coeff.value (e₁ p) *
    EffectiveNames.Enlargement.Coeff.value (e₁ p) = EffectiveNames.Enlargement.Coeff.value (e₁ p))
  (he₂ : ∀ p, EffectiveNames.Enlargement.Coeff.value (e₂ p) *
    EffectiveNames.Enlargement.Coeff.value (e₂ p) = EffectiveNames.Enlargement.Coeff.value (e₂ p))

include decode realizes he₁ he₂

omit [Finite P₁] [Finite P₂] in
theorem certificate (index n : ℕ) (budget : PartialBudget (raw index) (3 * (n / 10)))
    (i : Fin 3) : TestCertificate (code (Γ:=Γ) (Q:=Q) (P₁:=P₁) (P₂:=P₂) (k:=k) i)
      (test s A M e₁ e₂ i index) n := by
  let C := CommonCompiler.calculus A M (.inr ()) (terminalAlphabet A) index decode
    (f:=fun x => raw x.1 x.2) budget (realizes index)
  have hf (u : List (Syntax (Γ:=Γ) (Q:=Q)))
      (hu : C.grade (FreeMonoid.ofList u) ≤ n / 10) :
      (C.normal (FreeMonoid.ofList u)).toList ∈ normal A M index u := by
    apply CommonCompiler.service_full A M (.inr ()) (terminalAlphabet A) index
      decode budget (realizes index) u
    exact hu.trans (by omega)
  fin_cases i
  · exact GroupFamily.certificate s _ n
  · exact ProductFamily.certificate C _ (Path.letterGrade Word.gradeCell)
      (ProductFamily.grade_cost C _ (fun _ => rfl))
      (ThreeCodes.cost_padding _ _) (by omega) hf
  · exact ActionFamily.certificate
      (EffectiveNames.Double.interpretation (k₀:=ZMod 2) (n:=7) e₁ e₂ C he₁ he₂)
      _ (ThreeCodes.cost_padding _ _) le_rfl _
      (fun w hw => EffectiveNames.Double.test_full e₁ e₂ _ C he₁ he₂ w hw hf)

omit [Finite P₁] [Finite P₂] in
theorem all_budgets (index : ℕ)
    (fixed : raw index = tableNormal (tables s A M e₁ e₂ index)) :
    ∀ n, GoodTable (r:=rel) (tables s A M e₁ e₂ index) n ∧ PartialBudget (raw index) n := by
  apply FamilyProgram.bootstrap _ _ _ _ wf_rel (raw index) fixed
    (fun i => ThreeCodes.zero_avoids i _) (fun i j h => ThreeCodes.disjoint h _ _)
  intro n hn budget
  have hc := certificate s A M e₁ e₂ decode realizes he₁ he₂ index n budget
  exact ⟨fun i => (hc i).total, fun i => (hc i).nonzero,
    fun i => (hc i).contextual, fun i => (hc i).ideal⟩

theorem exists_total_fixed_point
    (h : ComputablePred (fun w => FiniteAlgebraicEnvelopes.evalWord s w = 1)) :
    ∃ index, raw index = tableNormal (tables s A M e₁ e₂ index) ∧
      ∀ n, GoodTable (r:=rel) (tables s A M e₁ e₂ index) n ∧ PartialBudget (raw index) n := by
  obtain ⟨index, hi⟩ := exists_fixed_point s A M e₁ e₂ h
  exact ⟨index,hi,all_budgets s A M e₁ e₂ decode realizes he₁ he₂ index hi⟩

end
end SimpleFInftyOvergroups.ContextualEncoding.Source

end OAI