Datasets:

roseking
/

openAI-math-dataset

import Mathlib
import OAI.Computability.VertexCover.Encoding.FinalCNFPattern
import OAI.Computability.VertexCover.Machines.DenseParse
import OAI.Computability.VertexCover.Machines.TableBase

namespace OAI

section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
                                 
section

namespace VertexCover.Machine.FinalCNFMachine
open UniqueGames.Foundations
open PCP PCP.VerifierToCNF PCP.GraphTables Target FormulaParser TableMachine

def eraseLiteral {n : ℕ} (f : Fin n → ℕ) (l : Literal n) : Bool × ℕ := (l.positive,f l.variableIndex)
def eraseClause {n : ℕ} (f : Fin n → ℕ) (cl : Clause n) : Triple (Bool × ℕ) :=
  ((eraseLiteral f cl[0],eraseLiteral f cl[1]),eraseLiteral f cl[2])
def splitData : List (Bool × ℕ) → List ℕ → List (Triple (Bool × ℕ))
  | [a,b,c],[] => [((a,b),c)]
  | a::b::rest,y::ys => ((a,b),(true,y))::splitData ((false,y)::rest) ys
  | _,_ => []
 theorem erase_split {n : ℕ} (f : Fin n → ℕ) (ls : List (Literal n)) (ys : List (Fin n)) :
    (splitLong ls ys).map (eraseClause f) = splitData (ls.map (eraseLiteral f)) (ys.map f) := by
  induction ys generalizing ls with
  | nil =>
    cases ls with
    | nil => rfl
    | cons a ls =>
      cases ls with
      | nil => rfl
      | cons b ls =>
        cases ls with
        | nil => rfl
        | cons c ls => cases ls <;> rfl
  | cons y ys ih =>
    cases ls with
    | nil => rfl
    | cons a ls =>
      cases ls with
      | nil => rfl
      | cons b rest =>
        simpa [splitLong,eraseClause,eraseLiteral,splitData] using
          congrArg (List.cons ((eraseLiteral f a,eraseLiteral f b),(true,f y)))
            (ih (⟨y,false⟩::rest))

 theorem erase_block {q : ℕ} (V W : FiniteVerifier q) (hq : 3 ≤ q)
    (e : Fin V.events) (e' : Fin W.events) (p : PatternIndex q)
    (f : Fin (outputVariables V) → ℕ) (g : Fin (outputVariables W) → ℕ)
    (hquery : ∀ i, f (oldIndex V (V.query e i)) = g (oldIndex W (W.query e' i)))
    (hfresh : ∀ j, f (freshIndex V e p j) = g (freshIndex W e' p j))
    (haccept : V.accepts e (patternAt q p) = W.accepts e' (patternAt q p)) :
    (block V hq e p).map (eraseClause f) = (block W hq e' p).map (eraseClause g) := by
  unfold block
  rw [haccept]
  split
  · rw [List.map_replicate,List.map_replicate]
    congr 1
    simp [tautology,eraseClause,eraseLiteral,hquery]
  · rw [erase_split,erase_split]
    congr 1
    · simp only [forbiddenClause,List.map_ofFn]
      congr 1
      funext i
      exact Prod.ext rfl (hquery i)
    · simp only [auxiliaryNames,List.map_ofFn]
      congr 1
      funext j
      exact hfresh j

theorem oldIndex_value {q : ℕ} (V : FiniteVerifier q) (i : Fin V.variables) :
    (oldIndex V i).val = i.val := rfl

theorem erase_event {q : ℕ} (V W : FiniteVerifier q) (hq : 3 ≤ q)
    (e : Fin V.events) (e' : Fin W.events)
    (f : Fin (outputVariables V) → ℕ) (g : Fin (outputVariables W) → ℕ)
    (hquery : ∀ i, f (oldIndex V (V.query e i)) = g (oldIndex W (W.query e' i)))
    (hfresh : ∀ p j, f (freshIndex V e p j) = g (freshIndex W e' p j))
    (haccept : ∀ p, V.accepts e (patternAt q p) = W.accepts e' (patternAt q p)) :
    (eventBlock V hq e).map (eraseClause f) = (eventBlock W hq e').map (eraseClause g) := by
  simp only [eventBlock,List.map_flatMap]
  apply List.flatMap_congr
  intro p _
  exact erase_block V W hq e e' p f g hquery (hfresh p) (haccept p)

abbrev Shapes := 12+1*(patterns 12).length*(12-3)
def localVerifier (r : RelationTable) : FiniteVerifier 12 where
  «variables» := 12
  events := 1
  query := fun _ i => i
  accepts := fun _ bits => r[Complexity.FinalCNFPattern.relationAddress bits]
def skeleton (r : RelationTable) : List (Triple (Bool × ℕ)) :=
  (eventBlock (localVerifier r) (by decide) (0 : Fin 1)).map (eraseClause Fin.val)

def queryName (p : GraphTables.Table × ℕ) (i : Fin 12) : ℕ :=
  let rows := (tableData p.1).2
  let row := rows.getD p.2 rowDefault
  if i.val<6 then 6*row.1.1+i.val
  else 6*(rows.getD row.1.2 rowDefault).1.1+(i.val-6)

def rename (p : GraphTables.Table × ℕ) (j : ℕ) : ℕ :=
  if h : j<12 then queryName p ⟨j,h⟩
  else p.1.vertices*6+p.2*((patterns 12).length*9)+(j-12)
def renameLiteral (p : (GraphTables.Table × ℕ) × (Bool × ℕ)) : Bool × ℕ :=
  (p.2.1,rename p.1 p.2.2)
def renameClause (p : (GraphTables.Table × ℕ) × Triple (Bool × ℕ)) : Triple (Bool × ℕ) :=
  ((renameLiteral (p.1,p.2.1.1),renameLiteral (p.1,p.2.1.2)),renameLiteral (p.1,p.2.2))
theorem rename_erase {n : ℕ} (p : Table × ℕ) (cl : Clause n) :
    renameClause (p,eraseClause Fin.val cl) = eraseClause (rename p ∘ Fin.val) cl := rfl

def eventData (p : GraphTables.Table × ℕ) : List (Triple (Bool × ℕ)) :=
  (skeleton (((tableData p.1).2.getD p.2 rowDefault).2)).map (fun c => renameClause (p,c))
def output (T : GraphTables.Table) : FormulaData :=
  (T.vertices*6+T.darts*36864,(List.range T.darts).flatMap (fun e => eventData (T,e)))

 theorem queryName_correct (T : GraphTables.Table) (e : Fin T.darts) (i : Fin 12) :
    queryName (T,e.val) i = ((Complexity.FinalCNFPattern.tableVerifier T).query e i).val := by
  refine Fin.addCases (m := 6) (n := 6) ?_ ?_ i
  · intro j
    have hj := j.isLt
    simp only [queryName,lookup_valid,Fin.val_castAdd,ite_eq_left hj]
    rw [Fin.addCases_left]
    simp [FinalBooleanVerifier.bitIndex,finProdFinEquiv,rowData,Nat.add_comm]
  · intro j
    have hj : ¬6+j.val<6 := by omega
    simp only [queryName,lookup_valid,Fin.val_natAdd,ite_eq_right hj]
    change 6*((tableData T).2.getD T.rows[e].reverseIndex.val rowDefault).1.1+(6+j.val-6) = _
    rw [lookup_valid]
    rw [Fin.addCases_right]
    simp [FinalBooleanVerifier.bitIndex,finProdFinEquiv,rowData,Nat.add_comm,
      ConstraintGraph.head,Complexity.FinalCNFPattern.tableGraph]
    rfl

end VertexCover.Machine.FinalCNFMachine
end


end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end

end OAI

	import Mathlib
	import OAI.Computability.VertexCover.Encoding.FinalCNFPattern
	import OAI.Computability.VertexCover.Machines.DenseParse
	import OAI.Computability.VertexCover.Machines.TableBase

	namespace OAI

	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section
	section

	section

	namespace VertexCover.Machine.FinalCNFMachine
	open UniqueGames.Foundations
	open PCP PCP.VerifierToCNF PCP.GraphTables Target FormulaParser TableMachine

	def eraseLiteral {n : ℕ} (f : Fin n → ℕ) (l : Literal n) : Bool × ℕ := (l.positive,f l.variableIndex)
	def eraseClause {n : ℕ} (f : Fin n → ℕ) (cl : Clause n) : Triple (Bool × ℕ) :=
	((eraseLiteral f cl[0],eraseLiteral f cl[1]),eraseLiteral f cl[2])
	def splitData : List (Bool × ℕ) → List ℕ → List (Triple (Bool × ℕ))
	\| [a,b,c],[] => [((a,b),c)]
	\| a::b::rest,y::ys => ((a,b),(true,y))::splitData ((false,y)::rest) ys
	\| _,_ => []
	theorem erase_split {n : ℕ} (f : Fin n → ℕ) (ls : List (Literal n)) (ys : List (Fin n)) :
	(splitLong ls ys).map (eraseClause f) = splitData (ls.map (eraseLiteral f)) (ys.map f) := by
	induction ys generalizing ls with
	\| nil =>
	cases ls with
	\| nil => rfl
	\| cons a ls =>
	cases ls with
	\| nil => rfl
	\| cons b ls =>
	cases ls with
	\| nil => rfl
	\| cons c ls => cases ls <;> rfl
	\| cons y ys ih =>
	cases ls with
	\| nil => rfl
	\| cons a ls =>
	cases ls with
	\| nil => rfl
	\| cons b rest =>
	simpa [splitLong,eraseClause,eraseLiteral,splitData] using
	congrArg (List.cons ((eraseLiteral f a,eraseLiteral f b),(true,f y)))
	(ih (⟨y,false⟩::rest))

	theorem erase_block {q : ℕ} (V W : FiniteVerifier q) (hq : 3 ≤ q)
	(e : Fin V.events) (e' : Fin W.events) (p : PatternIndex q)
	(f : Fin (outputVariables V) → ℕ) (g : Fin (outputVariables W) → ℕ)
	(hquery : ∀ i, f (oldIndex V (V.query e i)) = g (oldIndex W (W.query e' i)))
	(hfresh : ∀ j, f (freshIndex V e p j) = g (freshIndex W e' p j))
	(haccept : V.accepts e (patternAt q p) = W.accepts e' (patternAt q p)) :
	(block V hq e p).map (eraseClause f) = (block W hq e' p).map (eraseClause g) := by
	unfold block
	rw [haccept]
	split
	· rw [List.map_replicate,List.map_replicate]
	congr 1
	simp [tautology,eraseClause,eraseLiteral,hquery]
	· rw [erase_split,erase_split]
	congr 1
	· simp only [forbiddenClause,List.map_ofFn]
	congr 1
	funext i
	exact Prod.ext rfl (hquery i)
	· simp only [auxiliaryNames,List.map_ofFn]
	congr 1
	funext j
	exact hfresh j

	theorem oldIndex_value {q : ℕ} (V : FiniteVerifier q) (i : Fin V.variables) :
	(oldIndex V i).val = i.val := rfl

	theorem erase_event {q : ℕ} (V W : FiniteVerifier q) (hq : 3 ≤ q)
	(e : Fin V.events) (e' : Fin W.events)
	(f : Fin (outputVariables V) → ℕ) (g : Fin (outputVariables W) → ℕ)
	(hquery : ∀ i, f (oldIndex V (V.query e i)) = g (oldIndex W (W.query e' i)))
	(hfresh : ∀ p j, f (freshIndex V e p j) = g (freshIndex W e' p j))
	(haccept : ∀ p, V.accepts e (patternAt q p) = W.accepts e' (patternAt q p)) :
	(eventBlock V hq e).map (eraseClause f) = (eventBlock W hq e').map (eraseClause g) := by
	simp only [eventBlock,List.map_flatMap]
	apply List.flatMap_congr
	intro p _
	exact erase_block V W hq e e' p f g hquery (hfresh p) (haccept p)

	abbrev Shapes := 12+1(patterns 12).length(12-3)
	def localVerifier (r : RelationTable) : FiniteVerifier 12 where
	«variables» := 12
	events := 1
	query := fun _ i => i
	accepts := fun _ bits => r[Complexity.FinalCNFPattern.relationAddress bits]
	def skeleton (r : RelationTable) : List (Triple (Bool × ℕ)) :=
	(eventBlock (localVerifier r) (by decide) (0 : Fin 1)).map (eraseClause Fin.val)

	def queryName (p : GraphTables.Table × ℕ) (i : Fin 12) : ℕ :=
	let rows := (tableData p.1).2
	let row := rows.getD p.2 rowDefault
	if i.val<6 then 6*row.1.1+i.val
	else 6*(rows.getD row.1.2 rowDefault).1.1+(i.val-6)

	def rename (p : GraphTables.Table × ℕ) (j : ℕ) : ℕ :=
	if h : j<12 then queryName p ⟨j,h⟩
	else p.1.vertices6+p.2((patterns 12).length*9)+(j-12)
	def renameLiteral (p : (GraphTables.Table × ℕ) × (Bool × ℕ)) : Bool × ℕ :=
	(p.2.1,rename p.1 p.2.2)
	def renameClause (p : (GraphTables.Table × ℕ) × Triple (Bool × ℕ)) : Triple (Bool × ℕ) :=
	((renameLiteral (p.1,p.2.1.1),renameLiteral (p.1,p.2.1.2)),renameLiteral (p.1,p.2.2))
	theorem rename_erase {n : ℕ} (p : Table × ℕ) (cl : Clause n) :
	renameClause (p,eraseClause Fin.val cl) = eraseClause (rename p ∘ Fin.val) cl := rfl

	def eventData (p : GraphTables.Table × ℕ) : List (Triple (Bool × ℕ)) :=
	(skeleton (((tableData p.1).2.getD p.2 rowDefault).2)).map (fun c => renameClause (p,c))
	def output (T : GraphTables.Table) : FormulaData :=
	(T.vertices6+T.darts36864,(List.range T.darts).flatMap (fun e => eventData (T,e)))

	theorem queryName_correct (T : GraphTables.Table) (e : Fin T.darts) (i : Fin 12) :
	queryName (T,e.val) i = ((Complexity.FinalCNFPattern.tableVerifier T).query e i).val := by
	refine Fin.addCases (m := 6) (n := 6) ?_ ?_ i
	· intro j
	have hj := j.isLt
	simp only [queryName,lookup_valid,Fin.val_castAdd,ite_eq_left hj]
	rw [Fin.addCases_left]
	simp [FinalBooleanVerifier.bitIndex,finProdFinEquiv,rowData,Nat.add_comm]
	· intro j
	have hj : ¬6+j.val<6 := by omega
	simp only [queryName,lookup_valid,Fin.val_natAdd,ite_eq_right hj]
	change 6*((tableData T).2.getD T.rows[e].reverseIndex.val rowDefault).1.1+(6+j.val-6) = _
	rw [lookup_valid]
	rw [Fin.addCases_right]
	simp [FinalBooleanVerifier.bitIndex,finProdFinEquiv,rowData,Nat.add_comm,
	ConstraintGraph.head,Complexity.FinalCNFPattern.tableGraph]
	rfl

	end VertexCover.Machine.FinalCNFMachine
	end


	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end
	end

	end OAI