| import Mathlib |
| import OAI.Computability.MinUncut.Estimates.Bridge |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| open scoped BigOperators |
| namespace MinUncut.Outer.LocalTemplate |
| open MinUncut.Inner MinUncut.Costed |
| open MinUncutGames.Foundations.Hastad.SourceOccurrences |
|
|
| def signatureEquiv (t : ℕ) : Signature (Fin t) ≃ |
| ((Fin t → F₂) × (Fin t → Fin 3 → Fin 3 → Bool)) where |
| toFun s := (s.rhs,s.same) |
| invFun p := ⟨p.1,p.2⟩ |
| left_inv _ := rfl |
| right_inv _ := rfl |
|
|
| def signatureEncoding (t : ℕ) : Encoding (Signature (Fin t)) := |
| let a := ((Encoding.fin t).function fieldEncoding).prod |
| ((Encoding.fin t).function ((Encoding.fin 3).function ((Encoding.fin 3).function Encoding.bool))) |
| ⟨a.size,(signatureEquiv t).trans a.code⟩ |
|
|
| def signatureNumber {t : ℕ} (s : Signature (Fin t)) : ℕ := |
| (∑i : Fin t,(∑p : Fin 3,(∑q : Fin 3,(s.same i p q).toNat*2^q.val)*(2^3)^p.val)*((2^3)^3)^i.val)+ |
| ((2^3)^3)^t*(∑i : Fin t,(s.rhs i).val*2^i.val) |
|
|
| lemma bool_code (b : Bool) : (Encoding.bool.code b).val=b.toNat := by cases b <;> rfl |
|
|
| lemma signature_code {t : ℕ} (s : Signature (Fin t)) : |
| ((signatureEncoding t).code s).val=signatureNumber s := by |
| change (∑i : Fin t,(∑p : Fin 3,(∑q : Fin 3,(Encoding.bool.code (s.same i p q)).val*2^q.val)*(2^3)^p.val)*((2^3)^3)^i.val)+_=_ |
| simp only [bool_code,signatureNumber] |
| rfl |
|
|
| def constantTable {α : Type} (e : Encoding α) (f : α → ℕ) : List (ℕ × ℕ) := |
| e.enumerate.map (fun a=>((e.code a).val,f a)) |
|
|
| lemma lookupValue_mem {xs : List (ℕ × ℕ)} (hn : (xs.map Prod.fst).Nodup) |
| {i x : ℕ} (h : (i,x)∈xs) : AExpr.lookupValue i xs=x := by |
| induction xs with |
| | nil => simp at h |
| | cons p xs ih => |
| rcases p with ⟨j,y⟩ |
| simp only [List.map_cons,List.nodup_cons] at hn |
| rcases List.mem_cons.mp h with h|h |
| · cases h |
| simp [AExpr.lookupValue] |
| · have hij : i≠j := by |
| intro he |
| subst i |
| exact hn.1 (List.mem_map.mpr ⟨(j,x),h,rfl⟩) |
| simp only [AExpr.lookupValue,ite_eq_right hij] |
| exact ih hn.2 h |
|
|
| lemma constantTable_lookup {α : Type} (e : Encoding α) (f : α → ℕ) (a : α) : |
| AExpr.lookupValue ((e.code a).val) (constantTable e f)=f a := by |
| apply lookupValue_mem |
| · simp only [constantTable,List.map_map,Function.comp_def] |
| exact List.Nodup.map (fun x y h=>e.code.injective (Fin.ext h)) e.nodup_enumerate |
| · exact List.mem_map.mpr ⟨a,e.mem_enumerate a,rfl⟩ |
|
|
| lemma constantTable_eval {α : Type} (e : Encoding α) (f : α → ℕ) (a : α) |
| (x : AExpr) (v : List ℕ) (hx : x.eval v=(e.code a).val) : |
| (x.lookup (constantTable e f)).eval v=f a := by |
| rw [AExpr.eval_lookup,hx,constantTable_lookup] |
|
|
| end MinUncut.Outer.LocalTemplate |
|
|
| end |
| end |
|
|
| end OAI |
|
|
