Datasets:

roseking
/

openAI-math-dataset

import Mathlib.Tactic.Linarith
import OAI.Computability.BinPacking.Hardness.LiteralSlotGraphEnumeration

namespace OAI

namespace BinPackingGap.LiteralSlotGraphMachine

section

open BinPackingGames.Foundations.Target BinPackingGames.Foundations.Complexity

theorem literal_variable_add_two_le_bits (literal : RawLiteral) :
    literal.1 + 2 ≤ (literalBits literal).length := by
  simp only [literalBits, List.length_append, encodeWord_length]
  omega

theorem two_mul_length_le_literalsBits_length (xs : List RawLiteral) :
    2 * xs.length ≤ (literalsBits xs).length := by
  induction xs with
  | nil => simp [literalsBits]
  | cons literal rest ih =>
      have hl := literal_variable_add_two_le_bits literal
      simp only [literalsBits_cons, List.length_append, List.length_cons]
      omega

theorem literal_bits_length_le_literalsBits {literal : RawLiteral}
    {xs : List RawLiteral} (h : literal ∈ xs) :
    (literalBits literal).length ≤ (literalsBits xs).length := by
  induction xs with
  | nil => simp at h
  | cons head rest ih =>
      rcases List.mem_cons.mp h with h | h
      · subst literal
        simp only [literalsBits_cons, List.length_append]
        omega
      · have ht := ih h
        simp only [literalsBits_cons, List.length_append]
        omega

theorem literal_variable_le_literalsBits {literal : RawLiteral}
    {xs : List RawLiteral} (h : literal ∈ xs) :
    literal.1 ≤ (literalsBits xs).length := by
  have h₁ := literal_variable_add_two_le_bits literal
  have h₂ := literal_bits_length_le_literalsBits h
  omega

theorem literalsBits_formula_length_le (F : Formula) :
    (literalsBits (formulaLiterals F)).length ≤ (formulaBits F).length := by
  rw [formulaBits_eq_formulaLiterals]
  simp only [List.length_append]
  omega

theorem formula_literal_variable_le_input (F : Formula) {literal : RawLiteral}
    (h : literal ∈ formulaLiterals F) :
    literal.1 ≤ (formulaBits F).length :=
  (literal_variable_le_literalsBits h).trans (literalsBits_formula_length_le F)

theorem natBits_length_le_unary (n : Nat) :
    (BinaryEncoding.natBits n).length ≤ 2 * n + 1 := by
  have hb := bits_length_le n
  rw [Nat.size_eq_bits_len] at hb
  rw [BinaryEncoding.natBits_length]
  omega

theorem pairRecord_length_le (u v B : Nat) (hu : u ≤ B) (hv : v ≤ B) :
    (pairRecord u v).length ≤ 4 * B + 3 := by
  have h₁ := natBits_length_le_unary u
  have h₂ := natBits_length_le_unary v
  simp only [pairRecord, List.length_cons, List.length_append]
  omega

theorem vertexRecord_length_le (i B : Nat) (hi : i ≤ B) :
    (vertexRecord i).length ≤ 2 * B + 2 := by
  have h := natBits_length_le_unary i
  simp only [vertexRecord, List.length_cons]
  omega

theorem vertexRecords_length_le (i n B : Nat) (h : i + n ≤ B) :
    (vertexRecords i n).length ≤ n * (2 * B + 2) := by
  induction n generalizing i with
  | zero => simp [vertexRecords]
  | succ n ih =>
      have hi := vertexRecord_length_le i B (by omega)
      have ht := ih (i + 1) (by omega)
      simp only [vertexRecords, List.length_append]
      nlinarith

theorem rowEdges_length_le (u v : Nat) (left : RawLiteral) (xs : List RawLiteral) :
    (rowEdges u v left xs).length ≤ xs.length := by
  induction xs generalizing v with
  | nil => simp [rowEdges]
  | cons right rest ih =>
      have ht := ih (v + 1)
      simp only [rowEdges]
      split_ifs <;> simp only [List.length_cons] <;> omega

theorem rowEdges_endpoint_bounds (u v : Nat) (left : RawLiteral)
    (xs : List RawLiteral) {edge : Nat × Nat} (h : edge ∈ rowEdges u v left xs) :
    edge.1 = u ∧ v ≤ edge.2 ∧ edge.2 < v + xs.length := by
  induction xs generalizing v with
  | nil => simp [rowEdges] at h
  | cons right rest ih =>
      simp only [rowEdges] at h
      split_ifs at h with hc
      · rcases List.mem_cons.mp h with he | he
        · subst edge
          simp only [List.length_cons]
          exact ⟨True.intro, le_rfl, by omega⟩
        · obtain ⟨hu, hv, ht⟩ := ih (v + 1) he
          simp only [List.length_cons]
          exact ⟨hu, by omega, by omega⟩
      · obtain ⟨hu, hv, ht⟩ := ih (v + 1) h
        simp only [List.length_cons]
        exact ⟨hu, by omega, by omega⟩

theorem suffixEdges_endpoint_bounds (u : Nat) (xs : List RawLiteral)
    {edge : Nat × Nat} (h : edge ∈ suffixEdges u xs) :
    u ≤ edge.1 ∧ edge.1 < edge.2 ∧ edge.2 < u + xs.length := by
  induction xs generalizing u with
  | nil => simp [suffixEdges] at h
  | cons literal rest ih =>
      simp only [suffixEdges, List.mem_append] at h
      rcases h with h | h
      · obtain ⟨hu, hv, ht⟩ := rowEdges_endpoint_bounds u (u + 1) literal rest h
        simp only [List.length_cons]
        exact ⟨by omega, by omega, by omega⟩
      · obtain ⟨hu, hv, ht⟩ := ih (u + 1) h
        simp only [List.length_cons]
        exact ⟨by omega, hv, by omega⟩

theorem suffixEdges_length_le_sq (u : Nat) (xs : List RawLiteral) :
    (suffixEdges u xs).length ≤ xs.length ^ 2 := by
  induction xs generalizing u with
  | nil => simp [suffixEdges]
  | cons literal rest ih =>
      have hr := rowEdges_length_le u (u + 1) literal rest
      have ht := ih (u + 1)
      simp only [suffixEdges, List.length_append, List.length_cons]
      nlinarith

theorem edgeRecords_length_le (edges : List (Nat × Nat)) (B : Nat)
    (bounded : ∀ edge ∈ edges, edge.1 ≤ B ∧ edge.2 ≤ B) :
    (edgeRecords edges).length ≤ edges.length * (4 * B + 3) := by
  induction edges with
  | nil => simp [edgeRecords]
  | cons edge rest ih =>
      have he := bounded edge (by simp)
      have hp := pairRecord_length_le edge.1 edge.2 B he.1 he.2
      have ht := ih (fun e he => bounded e (by simp [he]))
      simp only [edgeRecords, List.flatMap_cons, List.length_append, List.length_cons]
      change (pairRecord edge.1 edge.2).length + (edgeRecords rest).length ≤ _
      nlinarith

theorem rowEdgeRecords_length_le (u v : Nat) (left : RawLiteral)
    (xs : List RawLiteral) (B : Nat) (hu : u ≤ B) (hv : v + xs.length ≤ B) :
    (edgeRecords (rowEdges u v left xs)).length ≤ xs.length * (4 * B + 3) := by
  have he := edgeRecords_length_le (rowEdges u v left xs) B (by
    intro edge h
    obtain ⟨h₁, h₂, h₃⟩ := rowEdges_endpoint_bounds u v left xs h
    exact ⟨by omega, by omega⟩)
  exact he.trans (Nat.mul_le_mul_right _ (rowEdges_length_le u v left xs))

theorem suffixEdgeRecords_length_le (u : Nat) (xs : List RawLiteral) (B : Nat)
    (hB : u + xs.length ≤ B) :
    (edgeRecords (suffixEdges u xs)).length ≤ xs.length ^ 2 * (4 * B + 3) := by
  have he := edgeRecords_length_le (suffixEdges u xs) B (by
    intro edge h
    obtain ⟨h₁, h₂, h₃⟩ := suffixEdges_endpoint_bounds u xs h
    exact ⟨by omega, by omega⟩)
  exact he.trans (Nat.mul_le_mul_right _ (suffixEdges_length_le_sq u xs))

theorem formulaEdgeRecords_length_le (F : Formula) :
    (edgeRecords (suffixEdges 0 (formulaLiterals F))).length ≤
      (formulaBits F).length ^ 2 * (4 * (formulaBits F).length + 3) := by
  have hn : (formulaLiterals F).length ≤ (formulaBits F).length := by
    rw [formulaLiterals_length]
    exact literalSlots_le_formulaBits_length F
  have he := suffixEdgeRecords_length_le 0 (formulaLiterals F)
    (formulaBits F).length (by simpa using hn)
  have hs : (formulaLiterals F).length ^ 2 ≤ (formulaBits F).length ^ 2 := by
    nlinarith
  exact he.trans (Nat.mul_le_mul_right _ hs)

theorem formulaGraphWord_length_le (F : Formula) :
    (BinaryEncoding.natBits (2 * F.clauses.length) ++
      vertexRecords 0 (3 * F.clauses.length) ++ [false] ++
      edgeRecords (suffixEdges 0 (formulaLiterals F)) ++ [false]).length ≤
      4 * (formulaBits F).length ^ 3 + 5 * (formulaBits F).length ^ 2 +
        4 * (formulaBits F).length + 3 := by
  let s := (formulaBits F).length
  have hn : 3 * F.clauses.length ≤ s := literalSlots_le_formulaBits_length F
  have hh := natBits_length_le_unary (2 * F.clauses.length)
  have hv := vertexRecords_length_le 0 (3 * F.clauses.length) s (by omega)
  have hv' : (vertexRecords 0 (3 * F.clauses.length)).length ≤ s * (2 * s + 2) :=
    hv.trans (Nat.mul_le_mul_right _ hn)
  have he := formulaEdgeRecords_length_le F
  simp only [List.length_append, List.length_cons, List.length_nil]
  change _ ≤ 4 * s ^ 3 + 5 * s ^ 2 + 4 * s + 3
  change (edgeRecords (suffixEdges 0 (formulaLiterals F))).length ≤ s ^ 2 * (4 * s + 3) at he
  nlinarith

end

open Turing FiniteTapeProgram BinPackingGames.Foundations.Target
open BinPackingGames.Foundations.Complexity

theorem edgeRecords_listBits (edges : List (Nat × Nat)) :
    edgeRecords edges ++ [false] = BinaryEncoding.listBits
      (BinaryEncoding.pairBits BinaryEncoding.natBits BinaryEncoding.natBits) edges := by
  induction edges with
  | nil => rfl
  | cons edge rest ih =>
      change (pairRecord edge.1 edge.2 ++ edgeRecords rest) ++ [false] = _
      rw [List.append_assoc, ih]
      rfl

theorem rawInput_formula (F : Formula) :
    rawInput F.variables F.clauses.length (formulaLiterals F) = formulaBits F :=
  (formulaBits_eq_formulaLiterals F).symm

theorem rawGraphWord_graphBits (F : NonemptyFormula) :
    rawGraphWord F.val.clauses.length (formulaLiterals F.val) = graphBits (graphInput F) := by
  have vertices : vertexRecords 0 (3 * F.val.clauses.length) ++ [false] =
      BinaryEncoding.listBits BinaryEncoding.natBits (List.range (3 * F.val.clauses.length)) := by
    simpa only [← List.range_eq_range'] using
      vertexRecords_listBits 0 (3 * F.val.clauses.length)
  have edges := edgeRecords_listBits (suffixEdges 0 (formulaLiterals F.val))
  rw [suffixEdges_formulaLiterals] at edges
  change BinaryEncoding.natBits (2 * F.val.clauses.length) ++
      vertexRecords 0 (3 * F.val.clauses.length) ++ [false] ++
      edgeRecords (suffixEdges 0 (formulaLiterals F.val)) ++ [false] = _
  rw [show BinaryEncoding.natBits (2 * F.val.clauses.length) ++
      vertexRecords 0 (3 * F.val.clauses.length) ++ [false] ++
      edgeRecords (suffixEdges 0 (formulaLiterals F.val)) ++ [false] =
      BinaryEncoding.natBits (2 * F.val.clauses.length) ++
        (vertexRecords 0 (3 * F.val.clauses.length) ++ [false]) ++
        (edgeRecords (suffixEdges 0 (formulaLiterals F.val)) ++ [false]) by
      simp only [List.append_assoc]]
  rw [vertices, edgeRecords_listBits, suffixEdges_formulaLiterals]
  rfl

theorem rawCost_formula_le (F : Formula) :
    rawCost F.variables F.clauses.length (formulaLiterals F) ≤
      100 * ((formulaBits F).length + 1) ^ 3 := by
  let s := (formulaBits F).length
  have hcount : 3 * F.clauses.length ≤ s := literalSlots_le_formulaBits_length F
  have hlits : (formulaLiterals F).length ≤ s := by
    rw [formulaLiterals_length]
    exact hcount
  have htwo : 2 * F.clauses.length ≤ s := by omega
  have hvar : F.variables ≤ s := by
    have h := congrArg List.length (formulaBits_eq_formulaLiterals F)
    simp only [List.length_append, encodeWord_length] at h
    change s = _ at h
    omega
  have hqbits := (bits_length_le (2 * F.clauses.length)).trans htwo
  have hnbits := (bits_length_le (3 * F.clauses.length)).trans hcount
  have hlbits := (bits_length_le (formulaLiterals F).length).trans hlits
  have convert := UnaryToBinaryMachine.steps_le (2 * F.clauses.length) 0
  have convertMul := Nat.mul_le_mul htwo
    (show 2 * (0 + 2 * F.clauses.length) + 3 ≤ 2 * s + 3 by omega)
  have vertices := vertexLoopCost_le (3 * F.clauses.length) 0
  have verticesMul := Nat.mul_le_mul hcount
    (show 5 * (0 + 3 * F.clauses.length) + 13 ≤ 5 * s + 13 by omega)
  have outer := outerLoopCost_le initialControl 0 s (formulaLiterals F)
    (by simpa using hlits) (literalsBits_formula_length_le F)
    (fun literal h => formula_literal_variable_le_input F h)
  have outerMul := Nat.mul_le_mul_right (40 * (s + 1) ^ 2 + 1) hlits
  have output := formulaGraphWord_length_le F
  change (rawGraphWord F.clauses.length (formulaLiterals F)).length ≤
    4 * s ^ 3 + 5 * s ^ 2 + 4 * s + 3 at output
  have coarse : rawCost F.variables F.clauses.length (formulaLiterals F) ≤
      44 * s ^ 3 + 92 * s ^ 2 + 70 * s + 21 := by
    simp only [rawCost, phaseCosts, List.sum_cons, List.sum_nil]
    nlinarith
  change _ ≤ 100 * (s + 1) ^ 3
  nlinarith [Nat.zero_le (s ^ 3), Nat.zero_le (s ^ 2)]

def outputsInTime (F : NonemptyFormula) :
    TM2OutputsInTime machine (inputBits F) (some (graphBits (graphInput F)))
      (100 * ((inputBits F).length + 1) ^ 3) := by
  have run := program.outputsInTime Tape.input .output initialState
    (rawInput F.val.variables F.val.clauses.length (formulaLiterals F.val))
    (rawGraphWord F.val.clauses.length (formulaLiterals F.val))
    (rawCost F.val.variables F.val.clauses.length (formulaLiterals F.val))
    (100 * ((formulaBits F.val).length + 1) ^ 3)
    (raw_program_exec F.val.variables F.val.clauses.length (formulaLiterals F.val))
    (rawCost_formula_le F.val)
  simpa only [rawInput_formula, rawGraphWord_graphBits, machine, inputBits] using run

noncomputable def computation :
    TM2ComputableInPolyTime inputBits graphBits graphInput where
  tm := machine
  inputAlphabet := Equiv.refl Bool
  outputAlphabet := Equiv.refl Bool
  time := Polynomial.C 100 * (Polynomial.X + Polynomial.C 1) ^ 3
  outputsFun F := by
    change TM2OutputsInTime machine ((inputBits F).map id)
      (some ((graphBits (graphInput F)).map id))
      ((Polynomial.C 100 * (Polynomial.X + Polynomial.C 1) ^ 3 : Polynomial Nat).eval
        (inputBits F).length)
    simp only [List.map_id_fun, Polynomial.eval_mul, Polynomial.eval_pow,
      Polynomial.eval_add, Polynomial.eval_C, Polynomial.eval_X]
    change TM2OutputsInTime machine (inputBits F) (some (graphBits (graphInput F)))
      (100 * ((inputBits F).length + 1) ^ 3)
    exact outputsInTime F

theorem computation_finiteAlphabet :
    MachineFiniteAlphabet.FiniteAlphabet computation.tm := machine_finiteAlphabet

end BinPackingGap.LiteralSlotGraphMachine

end OAI

	import Mathlib.Tactic.Linarith
	import OAI.Computability.BinPacking.Hardness.LiteralSlotGraphEnumeration

	namespace OAI

	namespace BinPackingGap.LiteralSlotGraphMachine

	section

	open BinPackingGames.Foundations.Target BinPackingGames.Foundations.Complexity

	theorem literal_variable_add_two_le_bits (literal : RawLiteral) :
	literal.1 + 2 ≤ (literalBits literal).length := by
	simp only [literalBits, List.length_append, encodeWord_length]
	omega

	theorem two_mul_length_le_literalsBits_length (xs : List RawLiteral) :
	2 * xs.length ≤ (literalsBits xs).length := by
	induction xs with
	\| nil => simp [literalsBits]
	\| cons literal rest ih =>
	have hl := literal_variable_add_two_le_bits literal
	simp only [literalsBits_cons, List.length_append, List.length_cons]
	omega

	theorem literal_bits_length_le_literalsBits {literal : RawLiteral}
	{xs : List RawLiteral} (h : literal ∈ xs) :
	(literalBits literal).length ≤ (literalsBits xs).length := by
	induction xs with
	\| nil => simp at h
	\| cons head rest ih =>
	rcases List.mem_cons.mp h with h \| h
	· subst literal
	simp only [literalsBits_cons, List.length_append]
	omega
	· have ht := ih h
	simp only [literalsBits_cons, List.length_append]
	omega

	theorem literal_variable_le_literalsBits {literal : RawLiteral}
	{xs : List RawLiteral} (h : literal ∈ xs) :
	literal.1 ≤ (literalsBits xs).length := by
	have h₁ := literal_variable_add_two_le_bits literal
	have h₂ := literal_bits_length_le_literalsBits h
	omega

	theorem literalsBits_formula_length_le (F : Formula) :
	(literalsBits (formulaLiterals F)).length ≤ (formulaBits F).length := by
	rw [formulaBits_eq_formulaLiterals]
	simp only [List.length_append]
	omega

	theorem formula_literal_variable_le_input (F : Formula) {literal : RawLiteral}
	(h : literal ∈ formulaLiterals F) :
	literal.1 ≤ (formulaBits F).length :=
	(literal_variable_le_literalsBits h).trans (literalsBits_formula_length_le F)

	theorem natBits_length_le_unary (n : Nat) :
	(BinaryEncoding.natBits n).length ≤ 2 * n + 1 := by
	have hb := bits_length_le n
	rw [Nat.size_eq_bits_len] at hb
	rw [BinaryEncoding.natBits_length]
	omega

	theorem pairRecord_length_le (u v B : Nat) (hu : u ≤ B) (hv : v ≤ B) :
	(pairRecord u v).length ≤ 4 * B + 3 := by
	have h₁ := natBits_length_le_unary u
	have h₂ := natBits_length_le_unary v
	simp only [pairRecord, List.length_cons, List.length_append]
	omega

	theorem vertexRecord_length_le (i B : Nat) (hi : i ≤ B) :
	(vertexRecord i).length ≤ 2 * B + 2 := by
	have h := natBits_length_le_unary i
	simp only [vertexRecord, List.length_cons]
	omega

	theorem vertexRecords_length_le (i n B : Nat) (h : i + n ≤ B) :
	(vertexRecords i n).length ≤ n * (2 * B + 2) := by
	induction n generalizing i with
	\| zero => simp [vertexRecords]
	\| succ n ih =>
	have hi := vertexRecord_length_le i B (by omega)
	have ht := ih (i + 1) (by omega)
	simp only [vertexRecords, List.length_append]
	nlinarith

	theorem rowEdges_length_le (u v : Nat) (left : RawLiteral) (xs : List RawLiteral) :
	(rowEdges u v left xs).length ≤ xs.length := by
	induction xs generalizing v with
	\| nil => simp [rowEdges]
	\| cons right rest ih =>
	have ht := ih (v + 1)
	simp only [rowEdges]
	split_ifs <;> simp only [List.length_cons] <;> omega

	theorem rowEdges_endpoint_bounds (u v : Nat) (left : RawLiteral)
	(xs : List RawLiteral) {edge : Nat × Nat} (h : edge ∈ rowEdges u v left xs) :
	edge.1 = u ∧ v ≤ edge.2 ∧ edge.2 < v + xs.length := by
	induction xs generalizing v with
	\| nil => simp [rowEdges] at h
	\| cons right rest ih =>
	simp only [rowEdges] at h
	split_ifs at h with hc
	· rcases List.mem_cons.mp h with he \| he
	· subst edge
	simp only [List.length_cons]
	exact ⟨True.intro, le_rfl, by omega⟩
	· obtain ⟨hu, hv, ht⟩ := ih (v + 1) he
	simp only [List.length_cons]
	exact ⟨hu, by omega, by omega⟩
	· obtain ⟨hu, hv, ht⟩ := ih (v + 1) h
	simp only [List.length_cons]
	exact ⟨hu, by omega, by omega⟩

	theorem suffixEdges_endpoint_bounds (u : Nat) (xs : List RawLiteral)
	{edge : Nat × Nat} (h : edge ∈ suffixEdges u xs) :
	u ≤ edge.1 ∧ edge.1 < edge.2 ∧ edge.2 < u + xs.length := by
	induction xs generalizing u with
	\| nil => simp [suffixEdges] at h
	\| cons literal rest ih =>
	simp only [suffixEdges, List.mem_append] at h
	rcases h with h \| h
	· obtain ⟨hu, hv, ht⟩ := rowEdges_endpoint_bounds u (u + 1) literal rest h
	simp only [List.length_cons]
	exact ⟨by omega, by omega, by omega⟩
	· obtain ⟨hu, hv, ht⟩ := ih (u + 1) h
	simp only [List.length_cons]
	exact ⟨by omega, hv, by omega⟩

	theorem suffixEdges_length_le_sq (u : Nat) (xs : List RawLiteral) :
	(suffixEdges u xs).length ≤ xs.length ^ 2 := by
	induction xs generalizing u with
	\| nil => simp [suffixEdges]
	\| cons literal rest ih =>
	have hr := rowEdges_length_le u (u + 1) literal rest
	have ht := ih (u + 1)
	simp only [suffixEdges, List.length_append, List.length_cons]
	nlinarith

	theorem edgeRecords_length_le (edges : List (Nat × Nat)) (B : Nat)
	(bounded : ∀ edge ∈ edges, edge.1 ≤ B ∧ edge.2 ≤ B) :
	(edgeRecords edges).length ≤ edges.length * (4 * B + 3) := by
	induction edges with
	\| nil => simp [edgeRecords]
	\| cons edge rest ih =>
	have he := bounded edge (by simp)
	have hp := pairRecord_length_le edge.1 edge.2 B he.1 he.2
	have ht := ih (fun e he => bounded e (by simp [he]))
	simp only [edgeRecords, List.flatMap_cons, List.length_append, List.length_cons]
	change (pairRecord edge.1 edge.2).length + (edgeRecords rest).length ≤ _
	nlinarith

	theorem rowEdgeRecords_length_le (u v : Nat) (left : RawLiteral)
	(xs : List RawLiteral) (B : Nat) (hu : u ≤ B) (hv : v + xs.length ≤ B) :
	(edgeRecords (rowEdges u v left xs)).length ≤ xs.length * (4 * B + 3) := by
	have he := edgeRecords_length_le (rowEdges u v left xs) B (by
	intro edge h
	obtain ⟨h₁, h₂, h₃⟩ := rowEdges_endpoint_bounds u v left xs h
	exact ⟨by omega, by omega⟩)
	exact he.trans (Nat.mul_le_mul_right _ (rowEdges_length_le u v left xs))

	theorem suffixEdgeRecords_length_le (u : Nat) (xs : List RawLiteral) (B : Nat)
	(hB : u + xs.length ≤ B) :
	(edgeRecords (suffixEdges u xs)).length ≤ xs.length ^ 2 * (4 * B + 3) := by
	have he := edgeRecords_length_le (suffixEdges u xs) B (by
	intro edge h
	obtain ⟨h₁, h₂, h₃⟩ := suffixEdges_endpoint_bounds u xs h
	exact ⟨by omega, by omega⟩)
	exact he.trans (Nat.mul_le_mul_right _ (suffixEdges_length_le_sq u xs))

	theorem formulaEdgeRecords_length_le (F : Formula) :
	(edgeRecords (suffixEdges 0 (formulaLiterals F))).length ≤
	(formulaBits F).length ^ 2 * (4 * (formulaBits F).length + 3) := by
	have hn : (formulaLiterals F).length ≤ (formulaBits F).length := by
	rw [formulaLiterals_length]
	exact literalSlots_le_formulaBits_length F
	have he := suffixEdgeRecords_length_le 0 (formulaLiterals F)
	(formulaBits F).length (by simpa using hn)
	have hs : (formulaLiterals F).length ^ 2 ≤ (formulaBits F).length ^ 2 := by
	nlinarith
	exact he.trans (Nat.mul_le_mul_right _ hs)

	theorem formulaGraphWord_length_le (F : Formula) :
	(BinaryEncoding.natBits (2 * F.clauses.length) ++
	vertexRecords 0 (3 * F.clauses.length) ++ [false] ++
	edgeRecords (suffixEdges 0 (formulaLiterals F)) ++ [false]).length ≤
	4 * (formulaBits F).length ^ 3 + 5 * (formulaBits F).length ^ 2 +
	4 * (formulaBits F).length + 3 := by
	let s := (formulaBits F).length
	have hn : 3 * F.clauses.length ≤ s := literalSlots_le_formulaBits_length F
	have hh := natBits_length_le_unary (2 * F.clauses.length)
	have hv := vertexRecords_length_le 0 (3 * F.clauses.length) s (by omega)
	have hv' : (vertexRecords 0 (3 * F.clauses.length)).length ≤ s * (2 * s + 2) :=
	hv.trans (Nat.mul_le_mul_right _ hn)
	have he := formulaEdgeRecords_length_le F
	simp only [List.length_append, List.length_cons, List.length_nil]
	change _ ≤ 4 * s ^ 3 + 5 * s ^ 2 + 4 * s + 3
	change (edgeRecords (suffixEdges 0 (formulaLiterals F))).length ≤ s ^ 2 * (4 * s + 3) at he
	nlinarith

	end

	open Turing FiniteTapeProgram BinPackingGames.Foundations.Target
	open BinPackingGames.Foundations.Complexity

	theorem edgeRecords_listBits (edges : List (Nat × Nat)) :
	edgeRecords edges ++ [false] = BinaryEncoding.listBits
	(BinaryEncoding.pairBits BinaryEncoding.natBits BinaryEncoding.natBits) edges := by
	induction edges with
	\| nil => rfl
	\| cons edge rest ih =>
	change (pairRecord edge.1 edge.2 ++ edgeRecords rest) ++ [false] = _
	rw [List.append_assoc, ih]
	rfl

	theorem rawInput_formula (F : Formula) :
	rawInput F.variables F.clauses.length (formulaLiterals F) = formulaBits F :=
	(formulaBits_eq_formulaLiterals F).symm

	theorem rawGraphWord_graphBits (F : NonemptyFormula) :
	rawGraphWord F.val.clauses.length (formulaLiterals F.val) = graphBits (graphInput F) := by
	have vertices : vertexRecords 0 (3 * F.val.clauses.length) ++ [false] =
	BinaryEncoding.listBits BinaryEncoding.natBits (List.range (3 * F.val.clauses.length)) := by
	simpa only [← List.range_eq_range'] using
	vertexRecords_listBits 0 (3 * F.val.clauses.length)
	have edges := edgeRecords_listBits (suffixEdges 0 (formulaLiterals F.val))
	rw [suffixEdges_formulaLiterals] at edges
	change BinaryEncoding.natBits (2 * F.val.clauses.length) ++
	vertexRecords 0 (3 * F.val.clauses.length) ++ [false] ++
	edgeRecords (suffixEdges 0 (formulaLiterals F.val)) ++ [false] = _
	rw [show BinaryEncoding.natBits (2 * F.val.clauses.length) ++
	vertexRecords 0 (3 * F.val.clauses.length) ++ [false] ++
	edgeRecords (suffixEdges 0 (formulaLiterals F.val)) ++ [false] =
	BinaryEncoding.natBits (2 * F.val.clauses.length) ++
	(vertexRecords 0 (3 * F.val.clauses.length) ++ [false]) ++
	(edgeRecords (suffixEdges 0 (formulaLiterals F.val)) ++ [false]) by
	simp only [List.append_assoc]]
	rw [vertices, edgeRecords_listBits, suffixEdges_formulaLiterals]
	rfl

	theorem rawCost_formula_le (F : Formula) :
	rawCost F.variables F.clauses.length (formulaLiterals F) ≤
	100 * ((formulaBits F).length + 1) ^ 3 := by
	let s := (formulaBits F).length
	have hcount : 3 * F.clauses.length ≤ s := literalSlots_le_formulaBits_length F
	have hlits : (formulaLiterals F).length ≤ s := by
	rw [formulaLiterals_length]
	exact hcount
	have htwo : 2 * F.clauses.length ≤ s := by omega
	have hvar : F.variables ≤ s := by
	have h := congrArg List.length (formulaBits_eq_formulaLiterals F)
	simp only [List.length_append, encodeWord_length] at h
	change s = _ at h
	omega
	have hqbits := (bits_length_le (2 * F.clauses.length)).trans htwo
	have hnbits := (bits_length_le (3 * F.clauses.length)).trans hcount
	have hlbits := (bits_length_le (formulaLiterals F).length).trans hlits
	have convert := UnaryToBinaryMachine.steps_le (2 * F.clauses.length) 0
	have convertMul := Nat.mul_le_mul htwo
	(show 2 * (0 + 2 * F.clauses.length) + 3 ≤ 2 * s + 3 by omega)
	have vertices := vertexLoopCost_le (3 * F.clauses.length) 0
	have verticesMul := Nat.mul_le_mul hcount
	(show 5 * (0 + 3 * F.clauses.length) + 13 ≤ 5 * s + 13 by omega)
	have outer := outerLoopCost_le initialControl 0 s (formulaLiterals F)
	(by simpa using hlits) (literalsBits_formula_length_le F)
	(fun literal h => formula_literal_variable_le_input F h)
	have outerMul := Nat.mul_le_mul_right (40 * (s + 1) ^ 2 + 1) hlits
	have output := formulaGraphWord_length_le F
	change (rawGraphWord F.clauses.length (formulaLiterals F)).length ≤
	4 * s ^ 3 + 5 * s ^ 2 + 4 * s + 3 at output
	have coarse : rawCost F.variables F.clauses.length (formulaLiterals F) ≤
	44 * s ^ 3 + 92 * s ^ 2 + 70 * s + 21 := by
	simp only [rawCost, phaseCosts, List.sum_cons, List.sum_nil]
	nlinarith
	change _ ≤ 100 * (s + 1) ^ 3
	nlinarith [Nat.zero_le (s ^ 3), Nat.zero_le (s ^ 2)]

	def outputsInTime (F : NonemptyFormula) :
	TM2OutputsInTime machine (inputBits F) (some (graphBits (graphInput F)))
	(100 * ((inputBits F).length + 1) ^ 3) := by
	have run := program.outputsInTime Tape.input .output initialState
	(rawInput F.val.variables F.val.clauses.length (formulaLiterals F.val))
	(rawGraphWord F.val.clauses.length (formulaLiterals F.val))
	(rawCost F.val.variables F.val.clauses.length (formulaLiterals F.val))
	(100 * ((formulaBits F.val).length + 1) ^ 3)
	(raw_program_exec F.val.variables F.val.clauses.length (formulaLiterals F.val))
	(rawCost_formula_le F.val)
	simpa only [rawInput_formula, rawGraphWord_graphBits, machine, inputBits] using run

	noncomputable def computation :
	TM2ComputableInPolyTime inputBits graphBits graphInput where
	tm := machine
	inputAlphabet := Equiv.refl Bool
	outputAlphabet := Equiv.refl Bool
	time := Polynomial.C 100 * (Polynomial.X + Polynomial.C 1) ^ 3
	outputsFun F := by
	change TM2OutputsInTime machine ((inputBits F).map id)
	(some ((graphBits (graphInput F)).map id))
	((Polynomial.C 100 * (Polynomial.X + Polynomial.C 1) ^ 3 : Polynomial Nat).eval
	(inputBits F).length)
	simp only [List.map_id_fun, Polynomial.eval_mul, Polynomial.eval_pow,
	Polynomial.eval_add, Polynomial.eval_C, Polynomial.eval_X]
	change TM2OutputsInTime machine (inputBits F) (some (graphBits (graphInput F)))
	(100 * ((inputBits F).length + 1) ^ 3)
	exact outputsInTime F

	theorem computation_finiteAlphabet :
	MachineFiniteAlphabet.FiniteAlphabet computation.tm := machine_finiteAlphabet

	end BinPackingGap.LiteralSlotGraphMachine

	end OAI