| import Mathlib |
| import OAI.Computability.QuantumFactoring.BitStackListOps |
| import OAI.Computability.QuantumFactoring.BitStackDivision |
| import OAI.Computability.QuantumFactoring.BitStackOptions |
|
|
| namespace OAI |
|
|
|
|
|
|
| section |
|
|
| namespace ExactQuantumFactoring.BitStackProgram |
| variable {α β : Type} [DecidableEq α] |
| def assocLookup (k : α) : List (α×β)→Option β |
| | []=>none |
| | (a,v)::as=>if k=a then some v else assocLookup k as |
| def assocStep (x : (α×β)×(α×Option β)) : α×Option β := |
| (x.2.1,if x.2.1=x.1.1 then some x.1.2 else x.2.2) |
| lemma assocFold_reverse (xs : List (α×β)) (k : α) (o : Option β) : |
| xs.reverse.foldl (fun s a=>assocStep (a,s)) (k,o)= |
| (k,match assocLookup k xs with | none=>o | some b=>some b) := by |
| induction xs with |
| | nil=>rfl |
| | cons a as ih=> |
| rw [List.reverse_cons,List.foldl_append,List.foldl_cons,List.foldl_nil,ih] |
| by_cases h:k=a.1 <;> simp [assocStep,assocLookup,h] |
| lemma assocFold_size (ea : α→List Bool) (eb : β→List Bool) |
| (xs : List (α×β)) (s : α×Option β) : |
| (prodCode ea (optionCode eb) (xs.foldl (fun s a=>assocStep (a,s)) s)).length≤ |
| (prodCode ea (optionCode eb) s).length+(listCode (prodCode ea eb) xs).length := by |
| induction xs generalizing s with |
| | nil=>simp |
| | cons a as ih=> |
| have hh:=ih (assocStep (a,s)) |
| have hb : (prodCode ea (optionCode eb) (assocStep (a,s))).length≤ |
| (prodCode ea (optionCode eb) s).length+2*(prodCode ea eb a).length+2:=by |
| unfold assocStep |
| split <;> simp only [prodCode,pairBits_length,optionCode,List.length_cons] <;> omega |
| simp only [List.foldl_cons,listCode_length_cons] |
| omega |
|
|
| namespace Procedure |
| variable {ea : α→List Bool} {eb : β→List Bool} |
| noncomputable def association (da : α) (db : β) |
| (eqp : Procedure (prodCode ea ea) boolCode (fun x=>decide (x.1=x.2))) : |
| Procedure (prodCode ea (listCode (prodCode ea eb))) (optionCode eb) |
| (fun x=>assocLookup x.1 x.2) := by |
| let ent:=prodCode ea eb |
| let st:=prodCode ea (optionCode eb) |
| let e:=first ent st |
| let s:=second ent st |
| let key:=(first ea (optionCode eb)).comp s |
| let ky:=(first ea eb).comp e |
| let value:=(second ea eb).comp e |
| let upd:=conditional (eqp.comp (key.pair ky)) ((optionSome eb).comp value) |
| ((second ea (optionCode eb)).comp s) |
| let step : Procedure (prodCode ent st) st (assocStep (α:=α) (β:=β)):= |
| (key.pair upd).congrFun (by intro x; simp only [assocStep,Function.comp_apply,decide_eq_true_eq]) |
| let fold:=foldList (da,db) step Polynomial.X (by |
| intro xs s i |
| have hh:=assocFold_size ea eb (xs.take i) s |
| have ht:=listCode_length_take_le ent i xs |
| simp only [Polynomial.eval_X] |
| dsimp only [ent,st] at ht ⊢ |
| omega) |
| let start:=((listReverse ent (da,db)).comp (second ea (listCode ent))).pair |
| ((first ea (listCode ent)).pair (constant (prodCode ea (listCode ent)) (optionCode eb) none)) |
| exact ((second ea (optionCode eb)).comp (fold.comp start)).congrFun (by |
| intro x |
| change (x.2.reverse.foldl (fun s a=>assocStep (a,s)) (x.1,none)).2=assocLookup x.1 x.2 |
| rw [assocFold_reverse] |
| cases assocLookup x.1 x.2 <;> rfl) |
| end Procedure |
| end ExactQuantumFactoring.BitStackProgram |
|
|
| end |
|
|
|
|
|
|
| end OAI |
|
|
