File size: 6,573 Bytes
92416a2 | 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 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 | import Mathlib
import OAI.Computability.VertexCover.Machines.ListSearch
import OAI.Computability.VertexCover.Machines.ListFilter
import OAI.Computability.VertexCover.Machines.Codec
import OAI.Computability.VertexCover.Machines.FixedOps
import OAI.Computability.VertexCover.Machines.LCData
import OAI.Computability.VertexCover.Machines.DescriptorMath
namespace OAI
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
namespace VertexCover.Machine
theorem foldl_and_all (xs : List Bool) (b : Bool) : xs.foldl (· && ·) b=(b && xs.all id) := by
induction xs generalizing b with
| nil => simp
| cons a xs ih => simp [ih,Bool.and_assoc]
noncomputable def Poly.boundAll {α : Type} (ea : α → List Bool) (a₀ : α)
{n : α → ℕ} {f : α × ℕ → Bool} (cn : Poly ea natBits n)
(cf : Poly (prodBits ea natBits) boolBits f) :
Poly ea boolBits (fun a => decide (∀ i, i<n a → f (a,i)=true)) :=
((Poly.tabulate ea boolBits a₀ false cn cf).comp Poly.listAnd).congr (fun a => by
apply Bool.eq_iff_iff.mpr
simp only [Function.comp_apply,foldl_and_all,Bool.true_and,List.all_eq_true,List.mem_map,
List.mem_range,decide_eq_true_iff]
constructor
· intro h i hi; exact h _ ⟨i,hi,rfl⟩
· rintro h b ⟨i,hi,rfl⟩; exact h i hi)
noncomputable def Poly.decideAnd {α : Type} (ea : α → List Bool)
(P Q : α → Prop) [DecidablePred P] [DecidablePred Q]
(cp : Poly ea boolBits (fun a => decide (P a)))
(cq : Poly ea boolBits (fun a => decide (Q a))) :
Poly ea boolBits (fun a => decide (P a ∧ Q a)) :=
((cp.pair cq).comp (Poly.bool₂ (fun p => p.1 && p.2))).congr (fun a => by simp)
noncomputable def Poly.decideForall {α ι : Type} [Fintype ι] (ea : α → List Bool)
(P : α → ι → Prop) [∀ a, DecidablePred (P a)]
(cp : ∀ i, Poly ea boolBits (fun a => decide (P a i))) :
Poly ea boolBits (fun a => decide (∀ i, P a i)) :=
(Poly.finiteAll ea (fun a i => decide (P a i)) cp).congr (fun a => by simp)
noncomputable def Poly.natEqual : Poly (prodBits natBits natBits) boolBits
(fun p : ℕ × ℕ => decide (p.1=p.2)) := Poly.natEq.congr (fun _ => rfl)
namespace GraphMachine
open LabelCover
variable {a b d : ℕ}
abbrev Weight (a b d : ℕ) := Fin d → Fin ((max a b)^(d-1)) → Fin (2*d+1)
abbrev RawVertex (a b d : ℕ) := ℕ × Weight a b d
abbrev Frame (a b d : ℕ) := FixedLC a b × (RawVertex a b d × RawVertex a b d)
noncomputable def weightCode : Weight a b d → List Bool := finiteCode _
noncomputable def vertexCode : RawVertex a b d → List Bool := prodBits natBits weightCode
noncomputable def frameCode : Frame a b d → List Bool := prodBits FixedLC.code (prodBits vertexCode vertexCode)
def defaultWeight : Weight a b d := fun _ _ => ⟨0,by omega⟩
def defaultFrame (ha : 0<a) (hb : 0<b) : Frame a b d :=
(FixedLC.one ha hb,((0,defaultWeight),(0,defaultWeight)))
noncomputable def seed (I : FixedLC a b) (n : ℕ) : I.toLC.Seeds d :=
fun e => ⟨n/I.M^(Fintype.equivFin (PositionPair d) e).val%I.M,Nat.mod_lt _ I.Mpos⟩
def vertexAt (p : Frame a b d) (x : Bool) : RawVertex a b d := if x then p.2.2 else p.2.1
noncomputable abbrev Q (p : Frame a b d) (x : TracePos d) : p.1.toLC.Query d :=
p.1.toLC.query (seed p.1 (vertexAt p x.1).1) x.2
def W (p : Frame a b d) : TraceWeights a b d := fun x => (vertexAt p x.1).2 x.2
noncomputable def rawVertex (I : FixedLC a b) (v : RawVertex a b d) : I.toLC.Vertex d :=
(seed I v.1,v.2)
noncomputable def descriptor (p : Frame a b d) : Descriptor a b d := diagram (Q p) (W p)
noncomputable def instancePoly : Poly (frameCode (a := a) (b := b) (d := d)) FixedLC.code Prod.fst :=
Poly.fst FixedLC.code (prodBits vertexCode vertexCode)
noncomputable def atPoly (x : Bool) : Poly (frameCode (a := a) (b := b) (d := d)) vertexCode (fun p => vertexAt p x) := by
let c := Poly.snd (FixedLC.code (a := a) (b := b)) (prodBits (vertexCode (a := a) (b := b) (d := d)) (vertexCode (a := a) (b := b) (d := d)))
cases x
· exact (c.comp (Poly.fst vertexCode vertexCode)).congr (fun _ => rfl)
· exact (c.comp (Poly.snd vertexCode vertexCode)).congr (fun _ => rfl)
noncomputable def seedNumberPoly (x : Bool) : Poly (frameCode (a := a) (b := b) (d := d)) natBits (fun p => (vertexAt p x).1) :=
(atPoly x).comp (Poly.fst natBits weightCode)
noncomputable def weightPoly : Poly (frameCode (a := a) (b := b) (d := d)) (finiteCode (TraceWeights a b d)) W := by
let c := ((atPoly (a := a) (b := b) (d := d) false).comp (Poly.snd natBits weightCode)).pair ((atPoly true).comp (Poly.snd natBits weightCode))
exact (c.comp (Poly.finite _ _ (prodBits_injective (finiteCode_injective _) (finiteCode_injective _))
(fun p : Weight a b d × Weight a b d => fun x : TracePos d => (if x.1 then p.2 else p.1) x.2))).congr
(fun p => by funext x; rcases x with ⟨x,j⟩; cases x <;> rfl)
noncomputable def samplePoly (hb : 0<b) (x : Bool) (e : PositionPair d) :
Poly (frameCode (a := a) (b := b) (d := d)) natBits
(fun p => (seed p.1 (vertexAt p x).1 e).val) := by
let cm := (instancePoly (a := a) (b := b) (d := d)).comp (FixedLC.MPoly hb)
exact ((((seedNumberPoly x).pair (cm.comp (Poly.natPow (Fintype.equivFin (PositionPair d) e).val))).comp
Poly.natDiv).pair cm |>.comp Poly.natMod)
noncomputable def questionUPoly (hb : 0<b) (x : TracePos d) (k : {k : Fin d // x.2 < k}) :
Poly (frameCode (a := a) (b := b) (d := d)) natBits (fun p => ((Q p x).2.1 k).val) :=
((instancePoly.pair (samplePoly hb x.1 ⟨(x.2,k.val),k.property⟩)).comp (FixedLC.leftPoly hb)).congr
(fun p => congrArg (fun r : FixedLC.Row a b => r.1.1)
(FixedLC.lookup_valid hb p.1 (seed p.1 (vertexAt p x.1).1 ⟨(x.2,k.val),k.property⟩)))
noncomputable def questionVPoly (hb : 0<b) (x : TracePos d) (k : {k : Fin d // k < x.2}) :
Poly (frameCode (a := a) (b := b) (d := d)) natBits (fun p => ((Q p x).2.2 k).val) :=
((instancePoly.pair (samplePoly hb x.1 ⟨(k.val,x.2),k.property⟩)).comp (FixedLC.rightPoly hb)).congr
(fun p => congrArg (fun r : FixedLC.Row a b => r.1.2)
(FixedLC.lookup_valid hb p.1 (seed p.1 (vertexAt p x.1).1 ⟨(k.val,x.2),k.property⟩)))
end GraphMachine
end VertexCover.Machine
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end OAI
|