File size: 5,677 Bytes
e320e82 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 | import Mathlib
import OAI.Combinatorics.IndependentSets.PCP.TargetLC
import OAI.Combinatorics.IndependentSets.Reduction.TargetRead
namespace OAI
namespace LargeIndependentSets.TargetLC
open IndependentSetsGames.Foundations IndependentSetsGames.Foundations.Complexity
open IndependentSetsCut.CounterMachine
open Target PCP Hastad.SourceContexts Hastad.SourceGame UniformLC
open TargetRead TargetRepair
open scoped Classical BigOperators
noncomputable section
variable (u : ℕ)
def eventExpr (x : Expr) (k : Fin u) : Expr :=
Expr.remainder (Expr.quotient x (Expr.power (.mul clausesExpr (.const 3)) k.val))
(.mul clausesExpr (.const 3))
def clauseExpr (x : Expr) (k : Fin u) : Expr := Expr.quotient (eventExpr u x k) (.const 3)
def slotExpr (x : Expr) (k : Fin u) : Expr := Expr.remainder (eventExpr u x k) (.const 3)
lemma clauseExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
(hi : x.eval (Complexity.formulaBits F.val) a=i.val) (k : Fin u) :
(clauseExpr u x k).eval (Complexity.formulaBits F.val) a=
(((eventEquiv u F.val).symm i k).1).val := by
simp only [clauseExpr,eventExpr,Expr.remainder_eval,Expr.quotient_eval,Expr.power_eval,
Expr.eval,clausesExpr_eval,hi]
rfl
lemma slotExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
(hi : x.eval (Complexity.formulaBits F.val) a=i.val) (k : Fin u) :
(slotExpr u x k).eval (Complexity.formulaBits F.val) a=
(RawInitialTables.slotOrder (((eventEquiv u F.val).symm i k).2)).val := by
simp only [slotExpr,eventExpr,Expr.remainder_eval,Expr.quotient_eval,Expr.power_eval,
Expr.eval,clausesExpr_eval,hi]
change _=(RawInitialTables.slotOrder (RawInitialTables.slotOrder.symm _)).val
rw [Equiv.apply_symm_apply]
rfl
def sampledNameExpr (x : Expr) (k : Fin u) : Expr :=
selectSlot (slotExpr u x k) (nameExpr (clauseExpr u x k))
def projectedBitExpr (x : Expr) (j : J u) (k : Fin u) : Expr :=
selectSlot (slotExpr u x k) (repairExpr (clauseExpr u x k) (j k))
lemma sampledNameExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
(hi : x.eval (Complexity.formulaBits F.val) a=i.val) (k : Fin u) :
(sampledNameExpr u x k).eval (Complexity.formulaBits F.val) a=
(nameAt (clauseAt F.val (((eventEquiv u F.val).symm i k).1))
(((eventEquiv u F.val).symm i k).2)).val := by
rw [sampledNameExpr,selectSlot_eval _ _ _ _ _ (slotExpr_eval u F x a i hi k)]
exact nameExpr_eval F.val _ a _ (clauseExpr_eval u F x a i hi k) _
lemma projectedBitExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
(hi : x.eval (Complexity.formulaBits F.val) a=i.val) (j : J u) (k : Fin u) :
(projectedBitExpr u x j k).eval (Complexity.formulaBits F.val) a=
bit ((table u F).project i j k) := by
rw [projectedBitExpr,selectSlot_eval _ _ _ _ _ (slotExpr_eval u F x a i hi k)]
rw [repairExpr_eval _ _ _ _ (clauseExpr_eval u F x a i hi k)]
congr 1
exact (project_apply u F.val _ j k).symm
def rankExpr (base : Expr) (f : Fin u → Expr) : Expr :=
Expr.listSum (List.finRange u) (fun k => .mul (f k) (Expr.power base k.val))
lemma rankExpr_eval (s : List Bool) (a : ℕ → ℕ) (base : Expr) (f : Fin u → Expr)
{m : ℕ} (v : Fin u → Fin m) (hb : base.eval s a=m) (hf : ∀ k, (f k).eval s a=(v k).val) :
(rankExpr u base f).eval s a=(finFunctionFinEquiv v).val := by
simp only [rankExpr,Expr.listSum_eval,Expr.eval,Expr.power_eval,hb,hf,finFunctionFinEquiv_apply]
rw [← List.ofFn_eq_map,List.sum_ofFn]
def leftExpr (x : Expr) : Expr := rankExpr u clausesExpr (clauseExpr u x)
def rightExpr (x : Expr) : Expr := rankExpr u varsExpr (sampledNameExpr u x)
lemma leftExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
(hi : x.eval (Complexity.formulaBits F.val) a=i.val) :
(leftExpr u x).eval (Complexity.formulaBits F.val) a=((table u F).left i).val := by
exact rankExpr_eval u _ _ _ _ _ (clausesExpr_eval F.val a) (clauseExpr_eval u F x a i hi)
lemma rightExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
(hi : x.eval (Complexity.formulaBits F.val) a=i.val) :
(rightExpr u x).eval (Complexity.formulaBits F.val) a=((table u F).right i).val := by
exact rankExpr_eval u _ _ _ _ _ (varsExpr_eval F.val a) (sampledNameExpr_eval u F x a i hi)
def projectionTest (x : Expr) (f : J u → I u) : Expr :=
Expr.listAll (List.finRange (Fintype.card (J u))) fun i =>
Expr.listAll (List.finRange u) fun k =>
Expr.equal (projectedBitExpr u x ((Fintype.equivFin (J u)).symm i) k)
(.const (bit (f ((Fintype.equivFin (J u)).symm i) k)))
lemma projectionTest_nonzero (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
(hi : x.eval (Complexity.formulaBits F.val) a=i.val) (f : J u → I u) :
(projectionTest u x f).eval (Complexity.formulaBits F.val) a≠0 ↔ f=(table u F).project i := by
simp only [projectionTest,Expr.listAll_eval,List.mem_finRange,forall_true_left,
Expr.equal_eval,projectedBitExpr_eval u F x a i hi,Expr.eval,indicator_ne,bit_eq]
constructor
· intro h
funext j k
simpa using (h (Fintype.equivFin (J u) j) k).symm
· rintro rfl
exact fun _ _ => rfl
def projectExpr (x : Expr) : Expr := Expr.pick projectCode (projectionTest u x)
lemma projectExpr_eval (F : Input) (x : Expr) (a : ℕ → ℕ) (i : Fin (table u F).ne)
(hi : x.eval (Complexity.formulaBits F.val) a=i.val) :
(projectExpr u x).eval (Complexity.formulaBits F.val) a=projectCode ((table u F).project i) := by
apply Expr.pick_eval
exact projectionTest_nonzero u F x a i hi
end
end LargeIndependentSets.TargetLC
end OAI
|