Datasets:

roseking
/

openAI-math-dataset

import Mathlib
import OAI.Computability.VertexCover.Machines.InitialTable

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.InitialTable
open UniqueGames.Foundations
open PCP PCP.GraphTables FormulaParser TableMachine
open RawInitialTables

@[simp] theorem vertexOrder_variable (F : Target.Formula) (v : Fin F.variables) :
    (vertexOrder F (InitialGraph.variableVertex F v)).val = v.val := rfl
@[simp] theorem vertexOrder_clause (F : Target.Formula) (v : Fin F.clauses.length) :
    (vertexOrder F (InitialGraph.clauseVertex F v)).val = F.variables+v.val := rfl
@[simp] theorem vertexOrder_dummy (F : Target.Formula) :
    (vertexOrder F (InitialGraph.dummyVertex F)).val = F.variables+F.clauses.length := by
  change F.variables+F.clauses.length+0 = _
  omega

@[simp] theorem dartOrder_real (F : Target.Formula) (e : PCP.RandomEvent F) (b : Bool) :
    (dartOrder F (.inl (e,b))).val = (if b then 1 else 0)+2*((slotOrder e.2).val+3*e.1.val) := by
  cases b <;> rfl
@[simp] theorem dartOrder_dummy (F : Target.Formula) :
    (dartOrder F (InitialGraph.dummyDart F)).val = 6*F.clauses.length := by
  change F.clauses.length*3*2+0 = _
  omega

 theorem clause_lookup (F : Target.Formula) (j : Fin F.clauses.length) :
    (targetData F).2.getD j.val clauseDefault = targetClauseData (PCP.clauseAt F j) := by
  rw [List.getD_eq_getElem _ _ (by simp [targetData])]
  simp only [targetData,List.getElem_map,PCP.clauseAt]

 theorem lit_target (F : Target.Formula) (e : PCP.RandomEvent F) :
    (lit (targetClauseData (PCP.clauseAt F e.1)) (slotOrder e.2)).2 =
      (PCP.nameAt (PCP.clauseAt F e.1) e.2).val := by
  rcases e with ⟨j,s⟩
  cases s <;> rfl

 theorem relation_target (F : Target.Formula) (e : PCP.RandomEvent F) (b : Bool) :
    relation (signs (targetClauseData (PCP.clauseAt F e.1)),(slotOrder e.2,b)) =
      relationOf (fun a c => (raw64 F).accepts (.inl (e,b))
        (labelOrder.symm a) (labelOrder.symm c)) := by
  apply congrArg relationOf
  funext a c
  rcases e with ⟨j,s⟩
  cases s <;> cases b <;> rfl

 theorem real_row (F : Target.Formula) (e : PCP.RandomEvent F) (b : Bool) :
    row (targetData F,(dartOrder F (.inl (e,b))).val) =
      (((vertexOrder F ((raw64 F).tail (.inl (e,b)))).val,
        (dartOrder F ((raw64 F).reverse (.inl (e,b)))).val),
        relationOf (fun a c => (raw64 F).accepts (.inl (e,b))
          (labelOrder.symm a) (labelOrder.symm c))) := by
  let idx := (dartOrder F (.inl (e,b))).val
  have hs : (slotOrder e.2).val < 3 := (slotOrder e.2).isLt
  have hi : idx < 6*F.clauses.length := by
    dsimp [idx]; rw [dartOrder_real]
    have hj := e.1.isLt
    cases b <;> simp only [Bool.false_eq_true,↓reduceIte] <;> omega
  have hd : idx/6=e.1.val := by
    dsimp [idx]; rw [dartOrder_real]
    cases b <;> simp only [Bool.false_eq_true,↓reduceIte] <;> omega
  have hp : (⟨(idx/2)%3,Nat.mod_lt _ (by decide)⟩ : Fin 3)=slotOrder e.2 := by
    apply Fin.ext
    dsimp [idx]; rw [dartOrder_real]
    cases b <;> simp only [Bool.false_eq_true,↓reduceIte] <;> omega
  have hb : decide (idx%2=1)=b := by
    simp only [idx,dartOrder_real]
    cases b <;> simp only [Bool.false_eq_true,↓reduceIte,decide_eq_false_iff_not,decide_eq_true_eq] <;> omega
  change row (targetData F,idx) = _
  dsimp only [row]
  rw [show (targetData F).2.length=F.clauses.length by simp [targetData],ite_eq_left hi,hd,hp,hb,
    clause_lookup,lit_target,relation_target]
  apply Prod.ext
  · apply Prod.ext
    · cases b <;> rfl
    · cases b with
      | false =>
        change idx+1 = (dartOrder F (.inl (e,true))).val
        simp only [idx,dartOrder_real,Bool.false_eq_true,↓reduceIte]
        omega
      | true =>
        change idx-1 = (dartOrder F (.inl (e,false))).val
        simp only [idx,dartOrder_real,Bool.false_eq_true,↓reduceIte]
        omega
  · rfl

 theorem dummy_row (F : Target.Formula) :
    row (targetData F,(dartOrder F (InitialGraph.dummyDart F)).val) =
      (((vertexOrder F ((raw64 F).tail (InitialGraph.dummyDart F))).val,
        (dartOrder F ((raw64 F).reverse (InitialGraph.dummyDart F))).val),
        relationOf (fun a c => (raw64 F).accepts (InitialGraph.dummyDart F)
          (labelOrder.symm a) (labelOrder.symm c))) := by
  rw [dartOrder_dummy]
  simp only [row,targetData,List.length_map,lt_self_iff_false,↓reduceIte]
  change _ = ((F.variables+F.clauses.length+0,F.clauses.length*3*2+0),_)
  congr 2; omega

 theorem row_target (F : Target.Formula) (i : Fin (table F).darts) :
    row (targetData F,i.val) = rowData (table F).rows[i] := by
  obtain ⟨d,rfl⟩ := (dartOrder F).surjective i
  have he : rowData (table F).rows[dartOrder F d] =
      (((vertexOrder F ((raw64 F).tail d)).val,(dartOrder F ((raw64 F).reverse d)).val),
        relationOf (fun a c => (raw64 F).accepts d (labelOrder.symm a) (labelOrder.symm c))) := by
    have getrow {n m : ℕ} (G : ConstraintGraph (Fin n) (Fin m) Label) (j : Fin m) :
        rowData (graphRows G)[j] =
          ((G.tail j |>.val,G.reverse j |>.val),relationOf (G.accepts j)) := by
      change rowData (graphRows G)[j.val] = _
      simp only [graphRows,Vector.getElem_ofFn,rowData]
    change rowData (graphRows (enumeratedGraph (raw64 F) (vertexOrder F) (dartOrder F) labelOrder))[dartOrder F d] = _
    rw [getrow]
    simp only [enumeratedGraph,Equiv.trans_apply,Equiv.symm_apply_apply]
  apply Eq.trans _ he.symm
  cases d with
  | inl eb => exact real_row F eb.1 eb.2
  | inr u => cases u; exact dummy_row F

 theorem output_target (F : Target.Formula) : output (targetData F)=tableData (table F) := by
  apply Prod.ext
  · simp only [output,targetData,tableData,table_vertices,List.length_map]
  · apply List.ext_getElem
    · simp only [output,tableData,List.length_map,List.length_range,targetData]
      exact (table_darts F).symm.trans (Vector.length_toList (xs := (table F).rows)).symm
    · intro i h₁ h₂
      simp only [output,List.getElem_map,List.getElem_range,tableData] at *
      simpa only [Fin.getElem_fin,Vector.getElem_toList] using
        row_target F ⟨i,by simpa [output,targetData,table_darts] using h₁⟩

noncomputable def initialPoly : Poly targetCode tableCode table :=
  outputPoly.encodeCongr targetData (fun _ => rfl) (fun F => by
    change TableMachine.dataCode (output (targetData F)) = TableMachine.dataCode (tableData (table F))
    rw [output_target])

end VertexCover.Machine.InitialTable
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.Machines.InitialTable

	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.InitialTable
	open UniqueGames.Foundations
	open PCP PCP.GraphTables FormulaParser TableMachine
	open RawInitialTables

	@[simp] theorem vertexOrder_variable (F : Target.Formula) (v : Fin F.variables) :
	(vertexOrder F (InitialGraph.variableVertex F v)).val = v.val := rfl
	@[simp] theorem vertexOrder_clause (F : Target.Formula) (v : Fin F.clauses.length) :
	(vertexOrder F (InitialGraph.clauseVertex F v)).val = F.variables+v.val := rfl
	@[simp] theorem vertexOrder_dummy (F : Target.Formula) :
	(vertexOrder F (InitialGraph.dummyVertex F)).val = F.variables+F.clauses.length := by
	change F.variables+F.clauses.length+0 = _
	omega

	@[simp] theorem dartOrder_real (F : Target.Formula) (e : PCP.RandomEvent F) (b : Bool) :
	(dartOrder F (.inl (e,b))).val = (if b then 1 else 0)+2((slotOrder e.2).val+3e.1.val) := by
	cases b <;> rfl
	@[simp] theorem dartOrder_dummy (F : Target.Formula) :
	(dartOrder F (InitialGraph.dummyDart F)).val = 6*F.clauses.length := by
	change F.clauses.length32+0 = _
	omega

	theorem clause_lookup (F : Target.Formula) (j : Fin F.clauses.length) :
	(targetData F).2.getD j.val clauseDefault = targetClauseData (PCP.clauseAt F j) := by
	rw [List.getD_eq_getElem _ _ (by simp [targetData])]
	simp only [targetData,List.getElem_map,PCP.clauseAt]

	theorem lit_target (F : Target.Formula) (e : PCP.RandomEvent F) :
	(lit (targetClauseData (PCP.clauseAt F e.1)) (slotOrder e.2)).2 =
	(PCP.nameAt (PCP.clauseAt F e.1) e.2).val := by
	rcases e with ⟨j,s⟩
	cases s <;> rfl

	theorem relation_target (F : Target.Formula) (e : PCP.RandomEvent F) (b : Bool) :
	relation (signs (targetClauseData (PCP.clauseAt F e.1)),(slotOrder e.2,b)) =
	relationOf (fun a c => (raw64 F).accepts (.inl (e,b))
	(labelOrder.symm a) (labelOrder.symm c)) := by
	apply congrArg relationOf
	funext a c
	rcases e with ⟨j,s⟩
	cases s <;> cases b <;> rfl

	theorem real_row (F : Target.Formula) (e : PCP.RandomEvent F) (b : Bool) :
	row (targetData F,(dartOrder F (.inl (e,b))).val) =
	(((vertexOrder F ((raw64 F).tail (.inl (e,b)))).val,
	(dartOrder F ((raw64 F).reverse (.inl (e,b)))).val),
	relationOf (fun a c => (raw64 F).accepts (.inl (e,b))
	(labelOrder.symm a) (labelOrder.symm c))) := by
	let idx := (dartOrder F (.inl (e,b))).val
	have hs : (slotOrder e.2).val < 3 := (slotOrder e.2).isLt
	have hi : idx < 6*F.clauses.length := by
	dsimp [idx]; rw [dartOrder_real]
	have hj := e.1.isLt
	cases b <;> simp only [Bool.false_eq_true,↓reduceIte] <;> omega
	have hd : idx/6=e.1.val := by
	dsimp [idx]; rw [dartOrder_real]
	cases b <;> simp only [Bool.false_eq_true,↓reduceIte] <;> omega
	have hp : (⟨(idx/2)%3,Nat.mod_lt _ (by decide)⟩ : Fin 3)=slotOrder e.2 := by
	apply Fin.ext
	dsimp [idx]; rw [dartOrder_real]
	cases b <;> simp only [Bool.false_eq_true,↓reduceIte] <;> omega
	have hb : decide (idx%2=1)=b := by
	simp only [idx,dartOrder_real]
	cases b <;> simp only [Bool.false_eq_true,↓reduceIte,decide_eq_false_iff_not,decide_eq_true_eq] <;> omega
	change row (targetData F,idx) = _
	dsimp only [row]
	rw [show (targetData F).2.length=F.clauses.length by simp [targetData],ite_eq_left hi,hd,hp,hb,
	clause_lookup,lit_target,relation_target]
	apply Prod.ext
	· apply Prod.ext
	· cases b <;> rfl
	· cases b with
	\| false =>
	change idx+1 = (dartOrder F (.inl (e,true))).val
	simp only [idx,dartOrder_real,Bool.false_eq_true,↓reduceIte]
	omega
	\| true =>
	change idx-1 = (dartOrder F (.inl (e,false))).val
	simp only [idx,dartOrder_real,Bool.false_eq_true,↓reduceIte]
	omega
	· rfl

	theorem dummy_row (F : Target.Formula) :
	row (targetData F,(dartOrder F (InitialGraph.dummyDart F)).val) =
	(((vertexOrder F ((raw64 F).tail (InitialGraph.dummyDart F))).val,
	(dartOrder F ((raw64 F).reverse (InitialGraph.dummyDart F))).val),
	relationOf (fun a c => (raw64 F).accepts (InitialGraph.dummyDart F)
	(labelOrder.symm a) (labelOrder.symm c))) := by
	rw [dartOrder_dummy]
	simp only [row,targetData,List.length_map,lt_self_iff_false,↓reduceIte]
	change _ = ((F.variables+F.clauses.length+0,F.clauses.length32+0),_)
	congr 2; omega

	theorem row_target (F : Target.Formula) (i : Fin (table F).darts) :
	row (targetData F,i.val) = rowData (table F).rows[i] := by
	obtain ⟨d,rfl⟩ := (dartOrder F).surjective i
	have he : rowData (table F).rows[dartOrder F d] =
	(((vertexOrder F ((raw64 F).tail d)).val,(dartOrder F ((raw64 F).reverse d)).val),
	relationOf (fun a c => (raw64 F).accepts d (labelOrder.symm a) (labelOrder.symm c))) := by
	have getrow {n m : ℕ} (G : ConstraintGraph (Fin n) (Fin m) Label) (j : Fin m) :
	rowData (graphRows G)[j] =
	((G.tail j \|>.val,G.reverse j \|>.val),relationOf (G.accepts j)) := by
	change rowData (graphRows G)[j.val] = _
	simp only [graphRows,Vector.getElem_ofFn,rowData]
	change rowData (graphRows (enumeratedGraph (raw64 F) (vertexOrder F) (dartOrder F) labelOrder))[dartOrder F d] = _
	rw [getrow]
	simp only [enumeratedGraph,Equiv.trans_apply,Equiv.symm_apply_apply]
	apply Eq.trans _ he.symm
	cases d with
	\| inl eb => exact real_row F eb.1 eb.2
	\| inr u => cases u; exact dummy_row F

	theorem output_target (F : Target.Formula) : output (targetData F)=tableData (table F) := by
	apply Prod.ext
	· simp only [output,targetData,tableData,table_vertices,List.length_map]
	· apply List.ext_getElem
	· simp only [output,tableData,List.length_map,List.length_range,targetData]
	exact (table_darts F).symm.trans (Vector.length_toList (xs := (table F).rows)).symm
	· intro i h₁ h₂
	simp only [output,List.getElem_map,List.getElem_range,tableData] at *
	simpa only [Fin.getElem_fin,Vector.getElem_toList] using
	row_target F ⟨i,by simpa [output,targetData,table_darts] using h₁⟩

	noncomputable def initialPoly : Poly targetCode tableCode table :=
	outputPoly.encodeCongr targetData (fun _ => rfl) (fun F => by
	change TableMachine.dataCode (output (targetData F)) = TableMachine.dataCode (tableData (table F))
	rw [output_target])

	end VertexCover.Machine.InitialTable
	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