lean/OAI/Computability/MinUncut/Encoding/QuestionEncoding.lean

import Mathlib
import OAI.Computability.MinUncut.PCP.Occurrences
import OAI.Computability.MinUncut.Search.FiniteQueryFamily

namespace OAI

section
namespace MinUncut.Outer
open MinUncut.Inner MinUncut.FiniteProof
open MinUncutGames.Foundations.Hastad.SourceOccurrences

def equationPair (N : ℕ) : Equation (Fin N) ≃ ((Fin 3 → Fin N) × F₂) where
  toFun E := (E.names,E.rhs)
  invFun p := ⟨p.1,p.2⟩
  left_inv _ := rfl
  right_inv _ := rfl

def fieldEncoding : Encoding F₂ := ⟨2,Equiv.refl _⟩

def equationEncoding (N : ℕ) : Encoding (Equation (Fin N)) :=
  let a := ((Encoding.fin 3).function (Encoding.fin N)).prod fieldEncoding
  ⟨a.size,(equationPair N).trans a.code⟩

def secondQuestionEncoding (N : ℕ) : Encoding (SecondQuestion (Fin N)) :=
  (Encoding.fin N).sum (equationEncoding N)

def questionEncoding (N t : ℕ) : Encoding (FamilyQuestion (Fin N) (Fin t)) :=
  ((Encoding.fin t).function (equationEncoding N)).sum
    ((Encoding.fin t).function (secondQuestionEncoding N))

def ambientEncoding (t : ℕ) : Encoding (Fin t → Triple) :=
  (Encoding.fin t).function ((Encoding.fin 3).function fieldEncoding)

instance validDecidable {N : ℕ} (E : Equation (Fin N)) (a : Triple) : Decidable (Valid E a) :=
  inferInstanceAs (Decidable (parity a=E.rhs ∧ ∀p p', E.names p=E.names p' → a p=a p'))

def encodeFirst {N t : ℕ} (U : Fin t → Equation (Fin N)) (a : FirstAlphabet U) : Fin t → Triple :=
  fun j => (a j).val

def decodeFirst {N t : ℕ} (U : Fin t → Equation (Fin N)) (x : Fin t → Triple) :
    Option (FirstAlphabet U) :=
  if h : ∀j, Valid (U j) (x j) then some (fun j => ⟨x j,h j⟩) else none

lemma decodeFirst_encodeFirst {N t : ℕ} (U : Fin t → Equation (Fin N)) (a : FirstAlphabet U) :
    decodeFirst U (encodeFirst U a)=some a := by
  have ha : ∀j, Valid (U j) (encodeFirst U a j) := fun j => (a j).property
  simp only [decodeFirst,dite_eq_left ha]
  rfl

lemma secondSlotCount_le {N : ℕ} (q : SecondQuestion (Fin N)) : secondSlotCount q≤3 := by
  cases q <;> norm_num [secondSlotCount]

def encodeSecond {N t : ℕ} (Q : Fin t → SecondQuestion (Fin N)) (a : SecondAlphabet Q) : Fin t → Triple :=
  fun j k => if h : k.val<secondSlotCount (Q j) then a j ⟨k.val,h⟩ else 0

def decodeSecond {N t : ℕ} (Q : Fin t → SecondQuestion (Fin N)) (x : Fin t → Triple) : SecondAlphabet Q :=
  fun j k => x j ⟨k.val,k.isLt.trans_le (secondSlotCount_le (Q j))⟩

lemma decodeSecond_encodeSecond {N t : ℕ} (Q : Fin t → SecondQuestion (Fin N)) (a : SecondAlphabet Q) :
    decodeSecond Q (encodeSecond Q a)=a := by
  funext j k
  exact dite_eq_left k.isLt

def encodeAlphabet {N t : ℕ} : (q : FamilyQuestion (Fin N) (Fin t)) → FamilyAlphabet q → (Fin t → Triple)
  | .inl U => encodeFirst U
  | .inr Q => encodeSecond Q

def decodeAlphabet {N t : ℕ} : (q : FamilyQuestion (Fin N) (Fin t)) → (Fin t → Triple) → Option (FamilyAlphabet q)
  | .inl U => decodeFirst U
  | .inr Q => fun x => some (decodeSecond Q x)

lemma decodeAlphabet_encodeAlphabet {N t : ℕ} (q : FamilyQuestion (Fin N) (Fin t)) (a : FamilyAlphabet q) :
    decodeAlphabet q (encodeAlphabet q a)=some a := by
  cases q with
  | inl U => exact decodeFirst_encodeFirst U a
  | inr Q => exact congrArg some (decodeSecond_encodeSecond Q a)

def extendTable {N t : ℕ} (q : FamilyQuestion (Fin N) (Fin t)) (R : FamilyAlphabet q → Bool) :
    (Fin t → Triple) → Bool := fun x => ((decodeAlphabet q x).map R).getD false

lemma extendTable_eval {N t : ℕ} (q : FamilyQuestion (Fin N) (Fin t)) (R : FamilyAlphabet q → Bool)
    (a : FamilyAlphabet q) : extendTable q R (encodeAlphabet q a)=R a := by
  simp only [extendTable,decodeAlphabet_encodeAlphabet,Option.map_some,Option.getD_some]

lemma extendTable_injective {N t : ℕ} (q : FamilyQuestion (Fin N) (Fin t)) :
    Function.Injective (extendTable q) := by
  intro R S h
  funext a
  simpa only [extendTable_eval] using congrFun h (encodeAlphabet q a)

def paddedVariableEncoding (N t : ℕ) :
    Encoding (FamilyQuestion (Fin N) (Fin t) × ((Fin t → Triple) → Bool)) :=
  (questionEncoding N t).prod ((ambientEncoding t).function Encoding.bool)

def variableCode {N t : ℕ} (v : FamilyVariable (Fin N) (Fin t)) : Fin (paddedVariableEncoding N t).size :=
  (paddedVariableEncoding N t).code (v.1,extendTable v.1 v.2.val)

lemma variableCode_injective {N t : ℕ} : Function.Injective (variableCode (N := N) (t := t)) := by
  rintro ⟨q,R⟩ ⟨s,S⟩ h
  have hp := (paddedVariableEncoding N t).code.injective h
  have hq : q=s := congrArg Prod.fst hp
  subst s
  have hR : R=S := Subtype.ext (extendTable_injective q (congrArg Prod.snd hp))
  subst S
  rfl

lemma paddedVariableEncoding_size (N t : ℕ) :
    (paddedVariableEncoding N t).size=
      ((N^3*2)^t+(N+N^3*2)^t)*2^((2^3)^t) := rfl

end MinUncut.Outer

end

end OAI