File size: 3,613 Bytes
ea76aac | 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 | import Mathlib
import OAI.Computability.MaxCut.PCP.TableIteration
import OAI.Computability.MaxCut.Machines.GraphCounterFinish
namespace OAI
/-! One polynomial bounds every actual intermediate encoding in the concrete
logarithmic graph iteration. The linear recurrence is on graph size. -/
namespace MaxCutGames.Foundations.Complexity.GraphIterationBounds
open PCP RoundTables
def inputBits (input : Input) : List Bool := GraphTables.tableBits input.val
def countedBits (input : Input) : List Bool := GraphCounterPrefix.output input.val
def words (H : BaseTable) (input : Input) (i : Nat) : List Bool :=
GraphTables.tableBits (TableIteration.runTables H i input.val)
def count (input : Input) : Nat := GraphCounterPrefix.count input.val
noncomputable def lengthPolynomial : Polynomial Nat :=
(GraphTableComplexity.encodingPolynomial 64).comp (PCPIterationMachine.sizePolynomial sizeFactor)
theorem inputBits_le_countedBits (input : Input) : (inputBits input).length ≤ (countedBits input).length := by
simp only [inputBits, countedBits, GraphCounterPrefix.output, List.length_append]
omega
theorem size_le_inputBits (input : Input) : size input ≤ (inputBits input).length := by
have h := GraphTableComplexity.size_add_two_le_bits input.val
unfold size inputBits
omega
theorem count_le (input : Input) : count input ≤ (countedBits input).length + 1 :=
(PCPIterationMachine.rounds_le (size input)).trans
(Nat.add_le_add_right ((size_le_inputBits input).trans (inputBits_le_countedBits input)) 1)
theorem intermediate_size (H : BaseTable) (input : Input) (i : Nat) (hi : i ≤ count input) :
size (TableIteration.run H i input) ≤ PCPIterationMachine.sizeEnvelope sizeFactor (size input) := by
apply PCPIterationMachine.semanticSize_bound
(fun j => size (TableIteration.run H j input)) sizeFactor (size input)
sizeFactor_positive (Nat.le_succ _) _ i hi
intro j _
exact step_size H (TableIteration.run H j input)
theorem intermediate_bits (H : BaseTable) (input : Input) (i : Nat) (hi : i ≤ count input) :
(words H input i).length ≤ lengthPolynomial.eval (countedBits input).length := by
have hsize := intermediate_size H input i hi
have hinput := (size_le_inputBits input).trans (inputBits_le_countedBits input)
have heval := MachineComposition.natPolynomial_eval_mono
(PCPIterationMachine.sizePolynomial sizeFactor) hinput
rw [PCPIterationMachine.sizePolynomial_eval, PCPIterationMachine.sizePolynomial_eval] at heval
have hs := hsize.trans heval
have htable : (TableIteration.runTables H i input.val).vertices +
(TableIteration.runTables H i input.val).darts ≤
PCPIterationMachine.sizeEnvelope sizeFactor (countedBits input).length := by
rw [← TableIteration.run_val]
exact hs
rw [lengthPolynomial, Polynomial.eval_comp, PCPIterationMachine.sizePolynomial_eval]
exact GraphTableComplexity.bits_le_of_size_le _ htable
noncomputable def runtimePolynomial (bodyTime : Polynomial Nat) : Polynomial Nat :=
(Polynomial.X + 1) * (bodyTime.comp lengthPolynomial + 2 * lengthPolynomial + 4) +
2 * lengthPolynomial + 4
theorem runtimePolynomial_eval (bodyTime : Polynomial Nat) (N : Nat) :
(runtimePolynomial bodyTime).eval N =
(N + 1) * (bodyTime.eval (lengthPolynomial.eval N) + 2 * lengthPolynomial.eval N + 4) +
2 * lengthPolynomial.eval N + 4 := by
simp only [runtimePolynomial, Polynomial.eval_add, Polynomial.eval_mul, Polynomial.eval_X,
Polynomial.eval_one, Polynomial.eval_ofNat, Polynomial.eval_comp]
end MaxCutGames.Foundations.Complexity.GraphIterationBounds
end OAI
|