File size: 6,775 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 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 | import Mathlib
import OAI.Combinatorics.IndependentSets.Geometry.GeometryLink
import OAI.Combinatorics.IndependentSets.Reduction.FloydLoop
namespace OAI
namespace IndependentSetsCut.CounterMachine.UnaryTables
lemma words_cons (f : ℕ → ℕ) (n : ℕ) :
words f (n+1)=IndependentSetsGames.Foundations.Complexity.encodeWord (f 0) ++ words (fun w => f (w+1)) n := by
simp [words,List.range_succ_eq_map,List.map_map,IndependentSetsGames.Foundations.Complexity.encodeWord,Function.comp_def]
end IndependentSetsCut.CounterMachine.UnaryTables
namespace LargeIndependentSets.GeometryNames
open IndependentSetsCut.CounterMachine UniformLC ShortestPaths
open IndependentSetsGames.Foundations.Complexity Turing
open scoped Classical BigOperators ENNReal
noncomputable section
variable (L R : Type) [Fintype L] [Fintype R] (n D : ℕ) [NeZero D]
def integerMatrix (t : Table L R) : ShortestPaths.Matrix (size L R n D t) :=
Vector.ofFn (fun i => Vector.ofFn (fun j =>
linkCost (layeredSystem t.lc n) (names L R n D t.nu t.nv i) (names L R n D t.nu t.nv j)))
def input (t : Table L R) : FloydCarry.Input D :=
⟨⟨size L R n D t,Capped.Matrix.ofInteger D (integerMatrix L R n D t)⟩,
(List.range (3+3*t.ne)).map t.value⟩
lemma payload_length (t : Table L R) : (input L R n D t).payload.length=3+3*t.ne := by simp [input]
lemma payload_get (t : Table L R) (w : ℕ) (hw : w<3+3*t.ne) :
(input L R n D t).payload[w]?.getD 0=t.value w := by simp [input,hw]
abbrev inputCount (t : Table L R) := 4+(size L R n D t)*(size L R n D t)+(3+3*t.ne)
def inputValue (t : Table L R) (w : ℕ) : ℕ :=
if w=0 then size L R n D t else (input L R n D t).initial.value (w-1)
lemma input_bits (t : Table L R) :
FloydCarry.Input.bits (input L R n D t)=UnaryTables.words (inputValue L R n D t) (inputCount L R n D t) := by
have hc : inputCount L R n D t=(input L R n D t).initial.count+1 := by
simp [inputCount,FloydCarry.State.count,FloydCarry.Input.initial,StoredFloyd.Input.initial,input]; omega
rw [hc,UnaryTables.words_cons]
simp only [inputValue,↓reduceIte,Nat.add_eq_zero_iff,one_ne_zero,and_false,Nat.add_sub_cancel]
rfl
def inputCountExpr : Expr := .add (.add (.const 4) (.mul (sizeExpr L R n D) (sizeExpr L R n D)))
(.add (.const 3) (.mul (.const 3) neExpr))
def inputValueExpr : Expr :=
Expr.cond (Expr.lt (.arg 0) (.const 2)) (sizeExpr L R n D)
(Expr.cond (Expr.equal (.arg 0) (.const 2)) (.const 0)
(Expr.cond (Expr.lt (.arg 0) (.add (.const 3) (.mul (sizeExpr L R n D) (sizeExpr L R n D))))
(costExpr L R n D (Expr.quotient (.sub (.arg 0) (.const 3)) (sizeExpr L R n D))
(Expr.remainder (.sub (.arg 0) (.const 3)) (sizeExpr L R n D)))
(Expr.cond (Expr.equal (.arg 0) (.add (.const 3) (.mul (sizeExpr L R n D) (sizeExpr L R n D))))
(.add (.const 3) (.mul (.const 3) neExpr))
(Expr.word (.sub (.arg 0) (.add (.const 4) (.mul (sizeExpr L R n D) (sizeExpr L R n D))))))))
@[simp] lemma inputCountExpr_eval (t : Table L R) (a : ℕ → ℕ) :
(inputCountExpr L R n D).eval t.bits a=inputCount L R n D t := by
simp [inputCountExpr,Expr.eval,inputCount]
lemma inputValueExpr_eval (t : Table L R) (w : ℕ) (hw : w < inputCount L R n D t) :
(inputValueExpr L R n D).eval t.bits (fun _ => w)=inputValue L R n D t w := by
let N := size L R n D t
have hN : 0<N := size_pos L R n D t
have hc : (input L R n D t).initial.core.n=N := rfl
have hk : (input L R n D t).initial.core.k=0 := rfl
have hp : (input L R n D t).initial.payload=(input L R n D t).payload := rfl
have indicator (P : Prop) [Decidable P] : (if P then (1:ℕ) else 0)≠0 ↔ P := by
split_ifs <;> simp_all
simp only [inputValueExpr,Expr.cond_eval,Expr.lt_eval,Expr.equal_eval,Expr.eval,sizeExpr_eval,neExpr_eval,indicator]
have hsize : N=size L R n D t := rfl
simp only [← hsize]
by_cases hsmall : w<2
· have hw' : w=0 ∨ w=1 := by omega
rcases hw' with rfl | rfl <;>
simp [inputValue,FloydCarry.State.value,StoredFloyd.State.value,hc,N]
· simp only [hsmall,ite_false,ne_eq,not_true_eq_false]
by_cases hw2 : w=2
· subst w
simp [inputValue,FloydCarry.State.value,StoredFloyd.State.value,hc,hk,N,show (1:ℕ)<2+N*N by omega]
· have hw3 : 3≤w := by omega
simp only [hw2,ite_false,not_true_eq_false]
by_cases hmat : w<3+N*N
· have hi : (w-3)/N<N := (Nat.div_lt_iff_lt_mul hN).mpr (by omega)
have hj : (w-3)%N<N := Nat.mod_lt _ hN
let i : Fin N := ⟨(w-3)/N,hi⟩
let j : Fin N := ⟨(w-3)%N,hj⟩
have hei : (Expr.quotient (.sub (.arg 0) (.const 3)) (sizeExpr L R n D)).eval t.bits (fun _ => w)=i.val := by
simp [Expr.quotient_eval,Expr.eval,i,N]
have hej : (Expr.remainder (.sub (.arg 0) (.const 3)) (sizeExpr L R n D)).eval t.bits (fun _ => w)=j.val := by
simp [Expr.remainder_eval,Expr.eval,j,N]
simp only [hmat,ite_true]
rw [costExpr_eval L R n D t _ _ _ i j hei hej]
simp [inputValue,FloydCarry.State.value,show w≠0 by omega,
show w-1<2+N*N by omega,StoredFloyd.State.value,show w-1≠0 by omega,
show w-1≠1 by omega,show w-1-2=w-3 by omega,
input,FloydCarry.Input.initial,StoredFloyd.Input.initial,StoredFloyd.entry,hi,hj,
Capped.Matrix.ofInteger,Capped.Matrix.get,integerMatrix,ShortestPaths.Matrix.get,i,j,N]
· simp only [hmat,ite_false]
by_cases hend : w=3+N*N
· simp only [hend,ite_true]
simp [inputValue,FloydCarry.State.value,hc,hp,payload_length,N]
· simp only [hend,ite_false,Expr.word_eval,Expr.eval,sizeExpr_eval]
have hoff : w-(4+N*N)<3+3*t.ne := by change w < 4+N*N+(3+3*t.ne) at hw; omega
rw [Table.bits,UnaryTables.wordValue_words _ _ _ hoff]
simp [inputValue,FloydCarry.State.value,hc,hp,show w≠0 by omega,
show ¬w-1<2+N*N by omega,show w-1≠2+N*N by omega,
show w-1-(3+N*N)=w-(4+N*N) by omega,payload_get L R n D t _ hoff,N]
lemma input_spec (t : Table L R) :
UnaryTables.words (fun w => (inputValueExpr L R n D).eval t.bits (fun _ => w))
((inputCountExpr L R n D).eval t.bits (fun _ => 0))=FloydCarry.Input.bits (input L R n D t) := by
rw [inputCountExpr_eval,input_bits]
exact UnaryTables.words_congr (inputValueExpr_eval L R n D t)
noncomputable def initializer : TM2ComputableInPolyTime Table.bits FloydCarry.Input.bits (input L R n D) :=
UnaryTables.encodedComputer _ _ _ (inputCountExpr L R n D) (inputValueExpr L R n D) (input_spec L R n D)
lemma initializer_finiteAlphabet : MachineFiniteAlphabet.FiniteAlphabet (initializer L R n D).tm :=
UnaryTables.encodedComputer_finiteAlphabet _ _ _ _ _ _
end
end LargeIndependentSets.GeometryNames
end OAI
|