File size: 7,457 Bytes
2f887db | 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 | import Mathlib
import OAI.Computability.MinUncut.Estimates.UniformGrid
namespace OAI
noncomputable section
namespace MinUncut.Costed.SourceWords
open MinUncut.Inner MinUncut.Outer MinUncut.Outer.LocalTemplate
open MinUncutGames.Reduction MinUncut.SourceBridge
variable {t : ℕ} {h : Fin t → Bool}
def secondAddress (h : Fin t → Bool) (pos : Fin t → Fin 3) : AExpr :=
.add ((AExpr.mul ((AExpr.reg 1).pow 3) (.const 2)).pow t) (secondExpr h pos)
def leftExpr (T : Query h) (pos : Fin t → Fin 3) : AExpr :=
.add (signatureLookup (fun s=>tableNumber (T.leftTable pos s)))
(.mul (.const (2^((2^3)^t))) (if T.first then firstExpr t else secondAddress h pos))
def rightExpr (T : Query h) (pos : Fin t → Fin 3) : AExpr :=
.add (.const (tableNumber T.rightTable)) (.mul (.const (2^((2^3)^t))) (secondAddress h pos))
def signExpr (T : Query h) (pos : Fin t → Fin 3) : AExpr :=
signatureLookup (fun s=>(T.localSign pos s).toNat)
lemma secondAddress_eval (input : SourceEncoding.Input) (u : Fin t → Fin input.equations.length)
(h : Fin t → Bool) (pos : Fin t → Fin 3) :
(secondAddress h pos).eval (inputTuple input u)=
(input.«variables»^3*2)^t+secondNumber (fun j=>equations input (u j)) h pos := by
simp only [secondAddress,AExpr.eval,AExpr.eval_pow,inputTuple_reg1,secondExpr_eval]
lemma leftExpr_eval (input : SourceEncoding.Input) (u : Fin t → Fin input.equations.length)
(T : Query h) (pos : Fin t → Fin 3) :
(leftExpr T pos).eval (inputTuple input u)=T.leftNumber (fun j=>equations input (u j)) pos := by
simp only [leftExpr,AExpr.eval,signatureLookup_eval,Query.leftNumber]
cases T.first <;> simp only [Bool.false_eq_true,ite_false,ite_true,firstExpr_eval,secondAddress_eval]
lemma rightExpr_eval (input : SourceEncoding.Input) (u : Fin t → Fin input.equations.length)
(T : Query h) (pos : Fin t → Fin 3) :
(rightExpr T pos).eval (inputTuple input u)=T.rightNumber (fun j=>equations input (u j)) pos := by
simp only [rightExpr,AExpr.eval,secondAddress_eval,Query.rightNumber]
lemma signExpr_eval (input : SourceEncoding.Input) (u : Fin t → Fin input.equations.length)
(T : Query h) (pos : Fin t → Fin 3) :
(signExpr T pos).eval (inputTuple input u)=
((T.realize (fun j=>equations input (u j)) pos).signed familyBase).equal.toNat := by
rw [Query.signed_equal]
exact signatureLookup_eval input u _
def queryWords (T : Query h) (pos : Fin t → Fin 3) (v : List ℕ) : List ℕ :=
[(leftExpr T pos).eval v,(rightExpr T pos).eval v,(signExpr T pos).eval v]
def queryProgram (T : Query h) (pos : Fin t → Fin 3) : PolyProgram (queryWords T pos) :=
((leftExpr T pos).program.cons ((rightExpr T pos).program.cons
((signExpr T pos).program.cons PolyProgram.nil))).ofEq (by intro v; rfl)
lemma queryWords_eq (input : SourceEncoding.Input) (u : Fin t → Fin input.equations.length)
(T : Query h) (pos : Fin t → Fin 3) :
queryWords T pos (inputTuple input u)=
[(variableCode ((T.realize (fun j=>equations input (u j)) pos).signed familyBase).left).val,
(variableCode ((T.realize (fun j=>equations input (u j)) pos).signed familyBase).right).val,
((T.realize (fun j=>equations input (u j)) pos).signed familyBase).equal.toNat] := by
simp only [queryWords,leftExpr_eval,rightExpr_eval,signExpr_eval,Query.left_number,Query.right_number]
end MinUncut.Costed.SourceWords
namespace MinUncut.Preprocess.Syntax
open MinUncut.Costed MinUncut.Costed.SourceWords
open MinUncut.Outer MinUncut.Outer.LocalTemplate UEncoding
variable {P : Type} [Primcodable P] {A : P → Type} {c : UEncoding P A}
lemma O.demandDigit {i : ∀p,A p → ℕ} (hi : c.Out i) :
O c (fun p x=>MinUncut.Costed.SourceWords.tupleDigit (i p x)) :=
((O.fixed (.reg 0)).div ((O.fixed (.reg 2)).pow hi)).mod (O.fixed (.reg 2))
lemma O.slotExpr {i j : ∀p,A p → ℕ} (hi : c.Out i) (hj : c.Out j) :
O c (fun p x=>MinUncut.Costed.SourceWords.slotExpr (i p x) (j p x)) :=
((O.fixed (.const 3)).add ((O.fixed (.const 4)).mul (O.demandDigit hi))).add (O.const hj) |>.at
lemma O.equationExpr {i : ∀p,A p → ℕ} (hi : c.Out i) :
O c (fun p x=>MinUncut.Costed.SourceWords.equationExpr (i p x)) := by
have hp : (c.prod (fin (fun _ : P=>3) (Computable.const 3))).Out (fun _ x=>x.2.val) :=
(out_code (fin (P:=P) (fun _=>3) (Computable.const 3))).second
have hw := (O.slotExpr hi.first hp).mul ((O.fixed (.reg 1)).pow hp)
exact (O.slotExpr hi (out_const c (Computable.const 3))).add
((O.fixed (.const 2)).mul (hw.sum_fin (Computable.const 3)))
lemma c_firstExpr : C MinUncut.Costed.SourceWords.firstExpr := by
let c := unitN.prod (fin id Computable.id)
have hi : c.Out (fun _ x=>x.2.val) := (out_code (fin id Computable.id)).second
have hbase : O c (fun _ _=>.mul ((AExpr.reg 1).pow 3) (.const 2)) := O.fixed _
exact ((O.equationExpr hi).mul (hbase.pow hi) |>.sum_fin Computable.id).toC
lemma O.secondExpr {t : P → ℕ} (ht : Computable t) {h : ∀p,A p → Fin (t p) → Bool}
{pos : ∀p,A p → Fin (t p) → Fin 3}
(hh : c.Map ((fin t ht).function bool) h)
(hp : c.Map (Alphabet.positionsList t ht) pos) :
O c (fun p x=>MinUncut.Costed.SourceWords.secondExpr (h p x) (pos p x)) := by
let d:=c.prod (fin t ht)
have hi : d.Out (fun _ x=>x.2.val) := (out_code (fin t ht)).second
have hj := map_apply hp.first (map_snd c (fin t ht))
have hjn := (out_code (fin (fun _ : P=>3) (Computable.const 3))).comp hj
have hb:=map_apply hh.first (map_snd c (fin t ht))
have left:=O.slotExpr hi hjn
have right:=(O.fixed (.reg 1)).add (O.equationExpr hi)
have base : O d (fun _ _=>.add (.reg 1) (.mul ((AExpr.reg 1).pow 3) (.const 2))) := O.fixed _
exact ((O.choose hb left right).mul (base.pow hi)).sum_fin ht
lemma c_demandSignatureExpr : C MinUncut.Costed.SourceWords.signatureExpr := by
let axes:=fin (P:=ℕ) id Computable.id
let pos:=fin (P:=ℕ) (fun _=>3) (Computable.const 3)
let c:=unitN.prod axes
let d:=c.prod pos
let e:=d.prod pos
have hi : e.Out (fun _ x=>x.1.1.2.val) := (out_code axes).second.first.first
have hp : e.Out (fun _ x=>x.1.2.val) := (out_code pos).second.first
have hq : e.Out (fun _ x=>x.2.val) := (out_code pos).second
have eqs := (O.slotExpr hi hp).eq (O.slotExpr hi hq)
have powq := hq.map (ca_pow (Computable.const 2) Computable.id)
have inner := (eqs.mul (O.const powq)).sum_fin (Computable.const 3)
have pcode : d.Out (fun _ x=>x.2.val) := (out_code pos).second
have powp := pcode.map (ca_pow (Computable.const (2^3)) Computable.id)
have mid := (inner.mul (O.const powp)).sum_fin (Computable.const 3)
have ii : c.Out (fun _ x=>x.2.val) := (out_code axes).second
have outer := (mid.mul (O.const (ii.map (ca_pow (Computable.const ((2^3)^3)) Computable.id)))).sum_fin Computable.id
have rhs := ((O.slotExpr ii (out_const c (Computable.const 3))).mul
(O.const (ii.map (ca_pow (Computable.const 2) Computable.id)))).sum_fin Computable.id
have co := O.const (out_const unitN (ca_pow (Computable.const ((2^3)^3)) Computable.id))
exact (outer.add (co.mul rhs)).toC
lemma O.demandLookup {t : P → ℕ} (ht : Computable t)
{f : ∀p,A p × Signature (Fin (t p)) → ℕ}
(hf : (c.prod (Alphabet.signatures t ht)).Out f) :
O c (fun p x=>MinUncut.Costed.SourceWords.signatureLookup (fun s=>f p (x,s))) :=
(O.fromC (c_demandSignatureExpr.precomp ht)).lookup (out_constantTable hf)
end MinUncut.Preprocess.Syntax
end
end OAI
|