| import Mathlib.Algebra.BigOperators.Field |
| import Mathlib.Algebra.BigOperators.Fin |
| import Mathlib.Data.Fintype.Prod |
| import Mathlib.Data.Fintype.Sigma |
| import Mathlib.Data.Fintype.Sum |
| import Mathlib.Tactic.DeriveFintype |
| import Mathlib.Tactic.FieldSimp |
| import Mathlib.Tactic.Linarith |
| import Mathlib.Tactic.NormNum |
| import OAI.Computability.BinPacking.Computation.MachineCanonicalOutput |
| import OAI.Computability.BinPacking.PCP.OccurrenceGame |
|
|
| namespace OAI |
|
|
| namespace BinPackingCompleteness.SourceClause |
|
|
| open BinPackingGames.Foundations.Target |
|
|
| abbrev Triple := Bool × Bool × Bool |
|
|
| def Triple.at (t : Triple) (i : Fin 3) : Bool := |
| match i.val with |
| | 0 => t.1 |
| | 1 => t.2.1 |
| | _ => t.2.2 |
|
|
| def literalTruth (positive value : Bool) : Bool := |
| if positive then value else !value |
|
|
| def localEval (signs values : Triple) : Bool := |
| (literalTruth signs.1 values.1 || literalTruth signs.2.1 values.2.1) || |
| literalTruth signs.2.2 values.2.2 |
|
|
| def allTriples : List Triple := |
| [(false, false, false), (false, false, true), |
| (false, true, false), (false, true, true), |
| (true, false, false), (true, false, true), |
| (true, true, false), (true, true, true)] |
|
|
| def satisfyingTriples (signs : Triple) : List Triple := |
| allTriples.filter (localEval signs) |
|
|
| theorem mem_allTriples (t : Triple) : t ∈ allTriples := by |
| rcases t with ⟨a, b, c⟩ |
| cases a <;> cases b <;> cases c <;> decide |
|
|
| @[simp] theorem mem_satisfyingTriples (signs values : Triple) : |
| values ∈ satisfyingTriples signs ↔ localEval signs values = true := by |
| simp [satisfyingTriples, mem_allTriples] |
|
|
| theorem satisfyingTriples_nodup (signs : Triple) : |
| (satisfyingTriples signs).Nodup := by |
| rcases signs with ⟨a, b, c⟩ |
| cases a <;> cases b <;> cases c <;> decide |
|
|
| @[simp] theorem satisfyingTriples_length (signs : Triple) : |
| (satisfyingTriples signs).length = 7 := by |
| rcases signs with ⟨a, b, c⟩ |
| cases a <;> cases b <;> cases c <;> rfl |
|
|
| private theorem coordinate_truth_table : |
| ∀ s₀ s₁ s₂ : Bool, ∀ i : Fin 3, ∀ value : Bool, |
| ∃ a b c : Bool, |
| localEval (s₀, s₁, s₂) (a, b, c) = true ∧ |
| Triple.at (a, b, c) i = value := by |
| decide |
|
|
| theorem coordinate_surjective (signs : Triple) (i : Fin 3) (value : Bool) : |
| ∃ t ∈ satisfyingTriples signs, t.at i = value := by |
| obtain ⟨a, b, c, hs, hv⟩ := |
| coordinate_truth_table signs.1 signs.2.1 signs.2.2 i value |
| exact ⟨(a, b, c), (mem_satisfyingTriples signs _).mpr hs, hv⟩ |
|
|
| private theorem pair_truth_table : |
| ∀ s₀ s₁ s₂ : Bool, ∀ i j : Fin 3, i ≠ j → ∀ first second : Bool, |
| ∃ a b c : Bool, |
| localEval (s₀, s₁, s₂) (a, b, c) = true ∧ |
| Triple.at (a, b, c) i = first ∧ Triple.at (a, b, c) j = second := by |
| decide |
|
|
| theorem pair_surjective (signs : Triple) (i j : Fin 3) (distinct : i ≠ j) |
| (first second : Bool) : |
| ∃ t ∈ satisfyingTriples signs, t.at i = first ∧ t.at j = second := by |
| obtain ⟨a, b, c, hs, hv⟩ := |
| pair_truth_table signs.1 signs.2.1 signs.2.2 i j distinct first second |
| exact ⟨(a, b, c), (mem_satisfyingTriples signs _).mpr hs, hv⟩ |
|
|
| structure NormalizedClause («variables» : Nat) where |
| clause : Clause «variables» |
| distinct : ∀ i j : Fin 3, |
| clause[i].variableIndex = clause[j].variableIndex → i = j |
|
|
| def NormalizedClause.variable {n : Nat} (c : NormalizedClause n) (i : Fin 3) : Fin n := |
| c.clause[i].variableIndex |
|
|
| def NormalizedClause.signs {n : Nat} (c : NormalizedClause n) : Triple := |
| (c.clause[0].positive, c.clause[1].positive, c.clause[2].positive) |
|
|
| def NormalizedClause.restrict {n : Nat} (c : NormalizedClause n) |
| (assignment : Fin n → Bool) : Triple := |
| (assignment (c.variable 0), assignment (c.variable 1), assignment (c.variable 2)) |
|
|
| @[simp] theorem localEval_restrict {n : Nat} (c : NormalizedClause n) |
| (assignment : Fin n → Bool) : |
| localEval c.signs (c.restrict assignment) = c.clause.eval assignment := by |
| rfl |
|
|
| theorem variable_ne {n : Nat} (c : NormalizedClause n) {i j : Fin 3} |
| (different : i ≠ j) : c.variable i ≠ c.variable j := |
| fun same => different (c.distinct i j same) |
|
|
| def NormalizedClause.extend {n : Nat} (c : NormalizedClause n) (t : Triple) : |
| Fin n → Bool := |
| fun v => if v = c.variable 0 then t.1 else if v = c.variable 1 then t.2.1 else t.2.2 |
|
|
| @[simp] theorem restrict_extend {n : Nat} (c : NormalizedClause n) (t : Triple) : |
| c.restrict (c.extend t) = t := by |
| have h10 := variable_ne c (by decide : (1 : Fin 3) ≠ 0) |
| have h20 := variable_ne c (by decide : (2 : Fin 3) ≠ 0) |
| have h21 := variable_ne c (by decide : (2 : Fin 3) ≠ 1) |
| simp [NormalizedClause.restrict, NormalizedClause.extend, h10, h20, h21] |
|
|
| theorem satisfying_label_realized {n : Nat} (c : NormalizedClause n) (t : Triple) |
| (valid : t ∈ satisfyingTriples c.signs) : |
| ∃ assignment : Fin n → Bool, |
| c.restrict assignment = t ∧ c.clause.eval assignment = true := by |
| refine ⟨c.extend t, restrict_extend c t, ?_⟩ |
| rw [← localEval_restrict, restrict_extend] |
| exact (mem_satisfyingTriples c.signs t).mp valid |
|
|
| abbrev Occurrence (clauseCount : Nat) := Fin clauseCount × Fin 3 |
|
|
| def occurrenceVariable {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (e : Occurrence m) : Fin n := |
| (clauses e.1).variable e.2 |
|
|
| theorem occurrence_determined_by_endpoints {n m : Nat} |
| (clauses : Fin m → NormalizedClause n) (e e' : Occurrence m) |
| (sameClause : e.1 = e'.1) |
| (sameVariable : occurrenceVariable clauses e = occurrenceVariable clauses e') : |
| e = e' := by |
| rcases e with ⟨c, i⟩ |
| rcases e' with ⟨c', j⟩ |
| dsimp only at sameClause |
| subst c' |
| have samePosition : i = j := (clauses c).distinct i j sameVariable |
| subst j |
| rfl |
| |
| theorem projection_determined_by_endpoints {n m : Nat} |
| (clauses : Fin m → NormalizedClause n) (e e' : Occurrence m) |
| (sameClause : e.1 = e'.1) |
| (sameVariable : occurrenceVariable clauses e = occurrenceVariable clauses e') |
| (label : Triple) : label.at e.2 = label.at e'.2 := by |
| rw [occurrence_determined_by_endpoints clauses e e' sameClause sameVariable] |
|
|
| def agreementCount {n : Nat} (c : NormalizedClause n) (label : Triple) |
| (assignment : Fin n → Bool) : Nat := |
| (if label.1 = assignment (c.variable 0) then 1 else 0) + |
| (if label.2.1 = assignment (c.variable 1) then 1 else 0) + |
| (if label.2.2 = assignment (c.variable 2) then 1 else 0) |
|
|
| theorem agreementCount_le_three {n : Nat} (c : NormalizedClause n) (label : Triple) |
| (assignment : Fin n → Bool) : agreementCount c label assignment ≤ 3 := by |
| unfold agreementCount |
| split <;> split <;> split <;> omega |
|
|
| theorem agreementCount_le_two_of_unsatisfied {n : Nat} |
| (c : NormalizedClause n) (label : Triple) (assignment : Fin n → Bool) |
| (valid : localEval c.signs label = true) |
| (unsatisfied : c.clause.eval assignment = false) : |
| agreementCount c label assignment ≤ 2 := by |
| by_cases h0 : label.1 = assignment (c.variable 0) |
| · by_cases h1 : label.2.1 = assignment (c.variable 1) |
| · by_cases h2 : label.2.2 = assignment (c.variable 2) |
| · have same : label = c.restrict assignment := |
| Prod.ext h0 (Prod.ext h1 h2) |
| rw [same, localEval_restrict, unsatisfied] at valid |
| contradiction |
| · simp [agreementCount, h0, h1, h2] |
| · unfold agreementCount |
| simp only [h0, h1, ↓reduceIte] |
| split <;> omega |
| · unfold agreementCount |
| simp only [h0, ↓reduceIte] |
| split <;> split <;> omega |
|
|
| theorem agreementCount_le_two_add_satisfied {n : Nat} |
| (c : NormalizedClause n) (label : Triple) (assignment : Fin n → Bool) |
| (valid : localEval c.signs label = true) : |
| agreementCount c label assignment ≤ |
| 2 + (if c.clause.eval assignment then 1 else 0) := by |
| cases h : c.clause.eval assignment with |
| | false => simpa [h] using agreementCount_le_two_of_unsatisfied c label assignment valid h |
| | true => simpa [h] using agreementCount_le_three c label assignment |
|
|
| theorem totalAgreement_le {n : Nat} (states : List (NormalizedClause n × Triple)) |
| (assignment : Fin n → Bool) |
| (valid : ∀ p ∈ states, localEval p.1.signs p.2 = true) : |
| (states.map (fun p => agreementCount p.1 p.2 assignment)).sum ≤ |
| 2 * states.length + (states.filter (fun p => p.1.clause.eval assignment)).length := by |
| induction states with |
| | nil => simp |
| | cons p rest ih => |
| have hp := agreementCount_le_two_add_satisfied p.1 p.2 assignment |
| (valid p (by simp)) |
| have hr := ih (fun p h => valid p (by simp [h])) |
| cases h : p.1.clause.eval assignment <;> |
| simp [h] at hp ⊢ <;> omega |
|
|
| end BinPackingCompleteness.SourceClause |
|
|
| namespace BinPackingCompleteness.Normalization |
|
|
| open BinPackingGames.Foundations |
| open Target |
| open SourceClause |
|
|
| def tripleClause {n : Nat} (a b c : Fin n) (sa sb sc : Bool) : Clause n := |
| #v[⟨a, sa⟩, ⟨b, sb⟩, ⟨c, sc⟩] |
|
|
| def normalizedTriple {n : Nat} (a b c : Fin n) (sa sb sc : Bool) |
| (hab : a ≠ b) (hac : a ≠ c) (hbc : b ≠ c) : NormalizedClause n where |
| clause := tripleClause a b c sa sb sc |
| distinct := by |
| intro i j h |
| have hi : i = 0 ∨ i = 1 ∨ i = 2 := by omega |
| have hj : j = 0 ∨ j = 1 ∨ j = 2 := by omega |
| rcases hi with rfl | rfl | rfl <;> |
| rcases hj with rfl | rfl | rfl <;> |
| simp_all [tripleClause] |
|
|
| def outputVariables (F : Formula) : Nat := F.variables + 4 * F.clauses.length |
|
|
| def oldVariable (F : Formula) (v : Fin F.variables) : Fin (outputVariables F) := |
| ⟨v.val, by have := v.isLt; unfold outputVariables; omega⟩ |
|
|
| def freshVariable (F : Formula) (c : Fin F.clauses.length) (i : Fin 4) : |
| Fin (outputVariables F) := |
| ⟨F.variables + 4 * c.val + i.val, by |
| have hc := c.isLt |
| have hi := i.isLt |
| unfold outputVariables |
| omega⟩ |
|
|
| def copyVariable (F : Formula) (c : Fin F.clauses.length) (i : Fin 3) : |
| Fin (outputVariables F) := |
| freshVariable F c ⟨i.val, by have := i.isLt; omega⟩ |
|
|
| def paddingVariable (F : Formula) (c : Fin F.clauses.length) : |
| Fin (outputVariables F) := freshVariable F c 3 |
|
|
| theorem freshVariable_injective (F : Formula) |
| (c d : Fin F.clauses.length) (i j : Fin 4) |
| (h : freshVariable F c i = freshVariable F d j) : c = d ∧ i = j := by |
| have hv := congrArg Fin.val h |
| dsimp [freshVariable] at hv |
| have hi := i.isLt |
| have hj := j.isLt |
| have hc : c.val = d.val := by omega |
| have hij : i.val = j.val := by omega |
| exact ⟨Fin.ext hc, Fin.ext hij⟩ |
|
|
| theorem copy_ne_copy (F : Formula) (c : Fin F.clauses.length) |
| {i j : Fin 3} (hij : i ≠ j) : copyVariable F c i ≠ copyVariable F c j := by |
| intro h |
| have hv := congrArg Fin.val h |
| dsimp [copyVariable, freshVariable] at hv |
| apply hij |
| apply Fin.ext |
| omega |
|
|
| theorem copy_ne_old (F : Formula) (c : Fin F.clauses.length) |
| (i : Fin 3) (v : Fin F.variables) : copyVariable F c i ≠ oldVariable F v := by |
| intro h |
| have hv := congrArg Fin.val h |
| have hvlt := v.isLt |
| dsimp [copyVariable, freshVariable, oldVariable] at hv |
| omega |
|
|
| theorem copy_ne_padding (F : Formula) (c : Fin F.clauses.length) |
| (i : Fin 3) : copyVariable F c i ≠ paddingVariable F c := by |
| intro h |
| have hv := congrArg Fin.val h |
| have hi := i.isLt |
| dsimp [copyVariable, paddingVariable, freshVariable] at hv |
| omega |
|
|
| theorem old_ne_padding (F : Formula) (c : Fin F.clauses.length) |
| (v : Fin F.variables) : oldVariable F v ≠ paddingVariable F c := by |
| intro h |
| have hv := congrArg Fin.val h |
| have hvlt := v.isLt |
| dsimp [paddingVariable, freshVariable, oldVariable] at hv |
| omega |
|
|
| def mainClause (F : Formula) (c : Fin F.clauses.length) : |
| NormalizedClause (outputVariables F) := |
| normalizedTriple (copyVariable F c 0) (copyVariable F c 1) (copyVariable F c 2) |
| (PCP.clauseAt F c)[0].positive (PCP.clauseAt F c)[1].positive |
| (PCP.clauseAt F c)[2].positive |
| (copy_ne_copy F c (by decide)) (copy_ne_copy F c (by decide)) |
| (copy_ne_copy F c (by decide)) |
|
|
| def equalityClauses (F : Formula) (c : Fin F.clauses.length) (i : Fin 3) : |
| List (NormalizedClause (outputVariables F)) := |
| let x := copyVariable F c i |
| let v := oldVariable F (PCP.clauseAt F c)[i].variableIndex |
| let z := paddingVariable F c |
| let hxv := copy_ne_old F c i (PCP.clauseAt F c)[i].variableIndex |
| let hxz := copy_ne_padding F c i |
| let hvz := old_ne_padding F c (PCP.clauseAt F c)[i].variableIndex |
| [normalizedTriple x v z false true true hxv hxz hvz, |
| normalizedTriple x v z false true false hxv hxz hvz, |
| normalizedTriple x v z true false true hxv hxz hvz, |
| normalizedTriple x v z true false false hxv hxz hvz] |
|
|
| def gadget (F : Formula) (c : Fin F.clauses.length) : |
| List (NormalizedClause (outputVariables F)) := |
| [mainClause F c] ++ equalityClauses F c 0 ++ |
| equalityClauses F c 1 ++ equalityClauses F c 2 |
|
|
| def gadgetClauses (F : Formula) (c : Fin F.clauses.length) : |
| List (Clause (outputVariables F)) := |
| (gadget F c).map NormalizedClause.clause |
|
|
| @[simp] theorem equalityClauses_length (F : Formula) (c : Fin F.clauses.length) |
| (i : Fin 3) : (equalityClauses F c i).length = 4 := rfl |
|
|
| @[simp] theorem gadget_length (F : Formula) (c : Fin F.clauses.length) : |
| (gadget F c).length = 13 := by simp [gadget] |
|
|
| @[simp] theorem gadgetClauses_length (F : Formula) (c : Fin F.clauses.length) : |
| (gadgetClauses F c).length = 13 := by simp [gadgetClauses] |
|
|
| def restrictAssignment (F : Formula) (B : Fin (outputVariables F) → Bool) : |
| Fin F.variables → Bool := fun v => B (oldVariable F v) |
|
|
| def extendAssignment (F : Formula) (A : Fin F.variables → Bool) |
| (v : Fin (outputVariables F)) : Bool := |
| if old : v.val < F.variables then A ⟨v.val, old⟩ |
| else |
| let c : Fin F.clauses.length := ⟨(v.val - F.variables) / 4, by |
| have hv := v.isLt |
| unfold outputVariables at hv |
| omega⟩ |
| if slot : (v.val - F.variables) % 4 < 3 then |
| A (PCP.clauseAt F c)[(⟨(v.val - F.variables) % 4, slot⟩ : Fin 3)].variableIndex |
| else false |
|
|
| @[simp] theorem extend_oldVariable (F : Formula) (A : Fin F.variables → Bool) |
| (v : Fin F.variables) : extendAssignment F A (oldVariable F v) = A v := by |
| simp [extendAssignment, oldVariable, v.isLt] |
|
|
| @[simp] theorem extend_copyVariable (F : Formula) (A : Fin F.variables → Bool) |
| (c : Fin F.clauses.length) (i : Fin 3) : |
| extendAssignment F A (copyVariable F c i) = A (PCP.clauseAt F c)[i].variableIndex := by |
| have hi := i.isLt |
| have hold : ¬ F.variables + 4 * c.val + i.val < F.variables := by omega |
| have hdiv : (F.variables + 4 * c.val + i.val - F.variables) / 4 = c.val := by omega |
| have hmod : (F.variables + 4 * c.val + i.val - F.variables) % 4 = i.val := by omega |
| simp [extendAssignment, copyVariable, freshVariable, hold, hdiv, hmod, hi] |
|
|
| @[simp] theorem restrict_extend (F : Formula) (A : Fin F.variables → Bool) : |
| restrictAssignment F (extendAssignment F A) = A := by |
| funext v |
| exact extend_oldVariable F A v |
|
|
| theorem main_eval_of_copies_match (F : Formula) (c : Fin F.clauses.length) |
| (B : Fin (outputVariables F) → Bool) |
| (hcopy : ∀ i : Fin 3, |
| B (copyVariable F c i) = B (oldVariable F (PCP.clauseAt F c)[i].variableIndex)) : |
| (mainClause F c).clause.eval B = (PCP.clauseAt F c).eval (restrictAssignment F B) := by |
| simp [mainClause, normalizedTriple, tripleClause, Clause.eval, Literal.eval, |
| restrictAssignment, hcopy] |
|
|
| theorem equalityClauses_failures (F : Formula) (c : Fin F.clauses.length) |
| (i : Fin 3) (B : Fin (outputVariables F) → Bool) : |
| PCP.VerifierToCNF.clauseFailures |
| ((equalityClauses F c i).map NormalizedClause.clause) B = |
| if B (copyVariable F c i) = B (oldVariable F (PCP.clauseAt F c)[i].variableIndex) |
| then 0 else 1 := by |
| cases hx : B (copyVariable F c i) <;> |
| cases hv : B (oldVariable F (PCP.clauseAt F c)[i].variableIndex) <;> |
| cases hz : B (paddingVariable F c) <;> |
| simp only [Fin.getElem_fin] at hv <;> |
| simp [PCP.VerifierToCNF.clauseFailures, equalityClauses, normalizedTriple, |
| tripleClause, Clause.eval, Literal.eval, hx, hv, hz] |
|
|
| theorem gadget_failures (F : Formula) (c : Fin F.clauses.length) |
| (B : Fin (outputVariables F) → Bool) : |
| PCP.VerifierToCNF.clauseFailures (gadgetClauses F c) B = |
| (if (mainClause F c).clause.eval B then 0 else 1) + |
| (if B (copyVariable F c 0) = B (oldVariable F (PCP.clauseAt F c)[0].variableIndex) |
| then 0 else 1) + |
| (if B (copyVariable F c 1) = B (oldVariable F (PCP.clauseAt F c)[1].variableIndex) |
| then 0 else 1) + |
| (if B (copyVariable F c 2) = B (oldVariable F (PCP.clauseAt F c)[2].variableIndex) |
| then 0 else 1) := by |
| simp only [gadgetClauses, gadget, List.map_append, |
| PCP.VerifierToCNF.clauseFailures_append, equalityClauses_failures] |
| cases hmain : (mainClause F c).clause.eval B <;> |
| simp [PCP.VerifierToCNF.clauseFailures, hmain] |
|
|
| theorem clauseFailures_zero_iff {n : Nat} (cs : List (Clause n)) (B : Fin n → Bool) : |
| PCP.VerifierToCNF.clauseFailures cs B = 0 ↔ ∀ c ∈ cs, c.eval B = true := by |
| rw [PCP.VerifierToCNF.clauseFailures, PCP.VerifierToCNF.zero_false_count_iff_all] |
| simp only [List.all_map, Function.comp_def, id_eq, List.all_eq_true] |
|
|
| theorem gadget_complete_of_copies_match (F : Formula) (c : Fin F.clauses.length) |
| (B : Fin (outputVariables F) → Bool) |
| (hcopy : ∀ i : Fin 3, |
| B (copyVariable F c i) = B (oldVariable F (PCP.clauseAt F c)[i].variableIndex)) |
| (hsat : (PCP.clauseAt F c).eval (restrictAssignment F B) = true) : |
| ∀ d ∈ gadgetClauses F c, d.eval B = true := by |
| apply (clauseFailures_zero_iff _ B).1 |
| rw [gadget_failures, main_eval_of_copies_match F c B hcopy, hsat] |
| simp [hcopy] |
|
|
| theorem gadget_failure_domination (F : Formula) (c : Fin F.clauses.length) |
| (B : Fin (outputVariables F) → Bool) : |
| (if (PCP.clauseAt F c).eval (restrictAssignment F B) then 0 else 1) ≤ |
| PCP.VerifierToCNF.clauseFailures (gadgetClauses F c) B := by |
| rw [gadget_failures] |
| by_cases h0 : B (copyVariable F c 0) = |
| B (oldVariable F (PCP.clauseAt F c)[0].variableIndex) |
| · by_cases h1 : B (copyVariable F c 1) = |
| B (oldVariable F (PCP.clauseAt F c)[1].variableIndex) |
| · by_cases h2 : B (copyVariable F c 2) = |
| B (oldVariable F (PCP.clauseAt F c)[2].variableIndex) |
| · have hcopy : ∀ i : Fin 3, |
| B (copyVariable F c i) = |
| B (oldVariable F (PCP.clauseAt F c)[i].variableIndex) := by |
| intro i |
| have hi : i = 0 ∨ i = 1 ∨ i = 2 := by omega |
| rcases hi with rfl | rfl | rfl |
| · exact h0 |
| · exact h1 |
| · exact h2 |
| rw [main_eval_of_copies_match F c B hcopy] |
| simp [h0, h1, h2] |
| · cases (PCP.clauseAt F c).eval (restrictAssignment F B) <;> |
| simp [h0, h1, h2] |
| · cases (PCP.clauseAt F c).eval (restrictAssignment F B) <;> |
| simp [h0, h1] |
| omega |
| · cases (PCP.clauseAt F c).eval (restrictAssignment F B) <;> |
| simp [h0] |
| omega |
|
|
| theorem gadget_failed (F : Formula) (c : Fin F.clauses.length) |
| (B : Fin (outputVariables F) → Bool) |
| (unsatisfied : (PCP.clauseAt F c).eval (restrictAssignment F B) = false) : |
| 1 ≤ PCP.VerifierToCNF.clauseFailures (gadgetClauses F c) B := by |
| simpa [unsatisfied] using gadget_failure_domination F c B |
|
|
| def normalizedClauses (F : Formula) : List (NormalizedClause (outputVariables F)) := |
| (PCP.allIndices F).flatMap (gadget F) |
|
|
| def normalize (F : Formula) : Formula where |
| «variables» := outputVariables F |
| clauses := (PCP.allIndices F).flatMap (gadgetClauses F) |
|
|
| theorem normalize_clauses_eq_map (F : Formula) : |
| (normalize F).clauses = (normalizedClauses F).map NormalizedClause.clause := by |
| simp only [normalize, normalizedClauses, List.map_flatMap] |
| rfl |
|
|
| theorem normalize_distinct (F : Formula) (c : Clause (normalize F).variables) |
| (hc : c ∈ (normalize F).clauses) (i j : Fin 3) |
| (same : (c)[i].variableIndex = (c)[j].variableIndex) : i = j := by |
| rw [normalize_clauses_eq_map] at hc |
| obtain ⟨d, _, hd⟩ := List.mem_map.mp hc |
| subst c |
| exact d.distinct i j same |
|
|
| @[simp] theorem normalize_variables (F : Formula) : |
| (normalize F).variables = F.variables + 4 * F.clauses.length := rfl |
|
|
| @[simp] theorem normalize_clause_count (F : Formula) : |
| (normalize F).clauses.length = 13 * F.clauses.length := by |
| change ((PCP.allIndices F).flatMap (gadgetClauses F)).length = _ |
| rw [PCP.VerifierToCNF.length_flatMap_constant _ _ 13 |
| (fun c _ => gadgetClauses_length F c)] |
| simp [PCP.allIndices, Nat.mul_comm] |
|
|
| theorem normalize_nonempty (F : Formula) (hne : F.clauses ≠ []) : |
| (normalize F).clauses ≠ [] := by |
| have hm : 0 < F.clauses.length := List.length_pos_iff.mpr hne |
| have hout : 0 < (normalize F).clauses.length := by |
| rw [normalize_clause_count] |
| omega |
| exact List.ne_nil_of_length_pos hout |
|
|
| theorem normalize_completeness (F : Formula) (hs : F.Satisfiable) : |
| (normalize F).Satisfiable := by |
| obtain ⟨A, hA⟩ := hs |
| refine ⟨extendAssignment F A, ?_⟩ |
| intro d hd |
| obtain ⟨c, _, hd⟩ := List.mem_flatMap.mp hd |
| apply gadget_complete_of_copies_match F c (extendAssignment F A) ?_ ?_ d hd |
| · intro i |
| simp |
| · rw [restrict_extend] |
| exact hA _ (List.getElem_mem c.isLt) |
|
|
| theorem failedCount_domination (F : Formula) (B : Fin (normalize F).variables → Bool) : |
| PCP.NameCompaction.failedCount F (restrictAssignment F B) ≤ |
| PCP.NameCompaction.failedCount (normalize F) B := by |
| change Fin (outputVariables F) → Bool at B |
| change (PCP.NameCompaction.evaluationList F (restrictAssignment F B)).count false ≤ |
| PCP.VerifierToCNF.clauseFailures ((PCP.allIndices F).flatMap (gadgetClauses F)) B |
| rw [← PCP.NameCompaction.evaluations_allIndices F (restrictAssignment F B), |
| PCP.VerifierToCNF.count_false_map_sum, PCP.VerifierToCNF.clauseFailures_flatMap] |
| exact PCP.VerifierToCNF.nat_sum_map_le _ _ _ |
| (fun c _ => gadget_failure_domination F c B) |
|
|
| theorem normalize_reflects (F : Formula) (hs : (normalize F).Satisfiable) : |
| F.Satisfiable := by |
| obtain ⟨B, hB⟩ := hs |
| have hout : PCP.NameCompaction.failedCount (normalize F) B = 0 := |
| (clauseFailures_zero_iff (normalize F).clauses B).2 hB |
| have hin : PCP.NameCompaction.failedCount F (restrictAssignment F B) = 0 := by |
| have h := failedCount_domination F B |
| rw [hout] at h |
| omega |
| exact ⟨restrictAssignment F B, (clauseFailures_zero_iff F.clauses _).1 hin⟩ |
|
|
| theorem normalize_satisfiable_iff (F : Formula) : |
| (normalize F).Satisfiable ↔ F.Satisfiable := |
| ⟨normalize_reflects F, normalize_completeness F⟩ |
|
|
| theorem normalize_gap (F : Formula) (a b : Nat) |
| (gap : ∀ A, a * F.clauses.length ≤ b * PCP.NameCompaction.failedCount F A) |
| (B : Fin (normalize F).variables → Bool) : |
| a * (normalize F).clauses.length ≤ |
| (13 * b) * PCP.NameCompaction.failedCount (normalize F) B := by |
| have hsource := gap (restrictAssignment F B) |
| have hcount := Nat.mul_le_mul_left b (failedCount_domination F B) |
| rw [normalize_clause_count] |
| calc |
| a * (13 * F.clauses.length) = 13 * (a * F.clauses.length) := by ac_rfl |
| _ ≤ 13 * (b * PCP.NameCompaction.failedCount (normalize F) B) := |
| Nat.mul_le_mul_left 13 (hsource.trans hcount) |
| _ = (13 * b) * PCP.NameCompaction.failedCount (normalize F) B := by ac_rfl |
|
|
| end BinPackingCompleteness.Normalization |
|
|
| namespace BinPackingCompleteness.NormalizationWords |
|
|
| open BinPackingGames.Foundations |
| open Complexity |
|
|
| abbrev Signs := Fin 3 → Bool |
| abbrev Names := Fin 3 → Nat |
|
|
| inductive NameRef |
| | old (slot : Fin 3) |
| | fresh (slot : Fin 4) |
| deriving DecidableEq, Fintype |
|
|
| inductive SignRef |
| | source (slot : Fin 3) |
| | constant (sign : Bool) |
| deriving DecidableEq, Fintype |
|
|
| structure LiteralRecipe where |
| name : NameRef |
| sign : SignRef |
| deriving DecidableEq, Fintype |
|
|
| def sourceValue (names : Names) (freshBase : Nat) : NameRef → Nat |
| | .old i => names i |
| | .fresh _ => freshBase |
|
|
| def offset : NameRef → Nat |
| | .old _ => 0 |
| | .fresh i => i.val |
|
|
| def nameValue (names : Names) (freshBase : Nat) (name : NameRef) : Nat := |
| sourceValue names freshBase name + offset name |
|
|
| def signValue (signs : Signs) : SignRef → Bool |
| | .source i => signs i |
| | .constant sign => sign |
|
|
| def literalWords (signs : Signs) (names : Names) (freshBase : Nat) |
| (literal : LiteralRecipe) : List Nat := |
| [nameValue names freshBase literal.name, if signValue signs literal.sign then 1 else 0] |
|
|
| def literalBits (signs : Signs) (names : Names) (freshBase : Nat) |
| (literal : LiteralRecipe) : List Bool := |
| encodeWords (literalWords signs names freshBase literal) |
|
|
| def mainRecipe : List LiteralRecipe := |
| [⟨.fresh 0, .source 0⟩, ⟨.fresh 1, .source 1⟩, ⟨.fresh 2, .source 2⟩] |
|
|
| def equalityRecipe (i : Fin 3) : List LiteralRecipe := |
| [⟨.fresh i.castSucc, .constant false⟩, ⟨.old i, .constant true⟩, ⟨.fresh 3, .constant true⟩, |
| ⟨.fresh i.castSucc, .constant false⟩, ⟨.old i, .constant true⟩, ⟨.fresh 3, .constant false⟩, |
| ⟨.fresh i.castSucc, .constant true⟩, ⟨.old i, .constant false⟩, ⟨.fresh 3, .constant true⟩, |
| ⟨.fresh i.castSucc, .constant true⟩, ⟨.old i, .constant false⟩, ⟨.fresh 3, .constant false⟩] |
|
|
| def recipe : List LiteralRecipe := |
| mainRecipe ++ equalityRecipe 0 ++ equalityRecipe 1 ++ equalityRecipe 2 |
|
|
| @[simp] theorem recipe_length : recipe.length = 39 := by decide |
|
|
| def words (signs : Signs) (names : Names) (freshBase : Nat) : List Nat := |
| recipe.flatMap (literalWords signs names freshBase) |
|
|
| def bits (signs : Signs) (names : Names) (freshBase : Nat) : List Bool := |
| encodeWords (words signs names freshBase) |
|
|
| def clauseSigns {n : Nat} (clause : Target.Clause n) : Signs := fun i => clause[i].positive |
|
|
| def clauseNames {n : Nat} (clause : Target.Clause n) : Names := fun i => clause[i].variableIndex.val |
|
|
| theorem encodeWords_flatMap {α : Type} (xs : List α) (f : α → List Nat) : |
| encodeWords (xs.flatMap f) = xs.flatMap (fun x => encodeWords (f x)) := by |
| induction xs with |
| | nil => rfl |
| | cons x xs ih => simp only [List.flatMap_cons, encodeWords_append, ih] |
|
|
| theorem bits_eq_flatMap (signs : Signs) (names : Names) (freshBase : Nat) : |
| bits signs names freshBase = recipe.flatMap (literalBits signs names freshBase) := |
| encodeWords_flatMap _ _ |
|
|
| theorem gadget_words (formula : Target.Formula) (c : Fin formula.clauses.length) : |
| (Normalization.gadgetClauses formula c).flatMap Complexity.clauseWords = |
| words (clauseSigns (PCP.clauseAt formula c)) (clauseNames (PCP.clauseAt formula c)) |
| (formula.variables + 4 * c.val) := by |
| simp [Normalization.gadgetClauses, Normalization.gadget, Normalization.mainClause, |
| Normalization.equalityClauses, Normalization.normalizedTriple, Normalization.tripleClause, |
| Normalization.copyVariable, Normalization.freshVariable, Normalization.oldVariable, |
| Normalization.paddingVariable, Complexity.clauseWords, Complexity.literalWords, |
| words, recipe, mainRecipe, equalityRecipe, literalWords, nameValue, sourceValue, offset, |
| signValue, clauseSigns, clauseNames, Fin.getElem_fin] |
| exact ⟨rfl, rfl, rfl⟩ |
|
|
| theorem gadget_bits (formula : Target.Formula) (c : Fin formula.clauses.length) : |
| encodeWords ((Normalization.gadgetClauses formula c).flatMap Complexity.clauseWords) = |
| bits (clauseSigns (PCP.clauseAt formula c)) (clauseNames (PCP.clauseAt formula c)) |
| (formula.variables + 4 * c.val) := by |
| rw [gadget_words] |
| rfl |
|
|
| def body (formula : Target.Formula) : List Bool := |
| (PCP.allIndices formula).flatMap (fun c => |
| bits (clauseSigns (PCP.clauseAt formula c)) (clauseNames (PCP.clauseAt formula c)) |
| (formula.variables + 4 * c.val)) |
|
|
| theorem encoded_body (formula : Target.Formula) : |
| encodeWords ((Normalization.normalize formula).clauses.flatMap Complexity.clauseWords) = |
| body formula := by |
| change encodeWords (((PCP.allIndices formula).flatMap |
| (Normalization.gadgetClauses formula)).flatMap Complexity.clauseWords) = _ |
| rw [List.flatMap_assoc, encodeWords_flatMap] |
| simp only [gadget_bits, body] |
|
|
| theorem encoded_normalize (formula : Target.Formula) : |
| formulaBits (Normalization.normalize formula) = |
| encodeWord (formula.variables + 4 * formula.clauses.length) ++ |
| encodeWord (13 * formula.clauses.length) ++ body formula := by |
| have count : (Normalization.normalize formula).clauses.length = |
| 13 * formula.clauses.length := Normalization.normalize_clause_count formula |
| simp only [formulaBits, formulaWords, encodeWords_append, encodeWords, List.append_nil, |
| Normalization.normalize_variables, List.append_assoc] |
| erw [count, encoded_body] |
|
|
| end BinPackingCompleteness.NormalizationWords |
|
|
| namespace BinPackingCompleteness.SourceGame |
|
|
| open SourceClause BinPackingGames.Foundations.Games |
| open scoped BigOperators |
|
|
| def decodeLabel (signs : Triple) (label : Fin 7) : Triple := |
| (satisfyingTriples signs)[label.val]'(by |
| rw [satisfyingTriples_length] |
| exact label.isLt) |
| |
| theorem decodeLabel_mem (signs : Triple) (label : Fin 7) : |
| decodeLabel signs label ∈ satisfyingTriples signs := by |
| exact List.getElem_mem _ |
| |
| theorem decodeLabel_legal (signs : Triple) (label : Fin 7) : |
| localEval signs (decodeLabel signs label) = true := |
| (mem_satisfyingTriples signs _).mp (decodeLabel_mem signs label) |
| |
| theorem decodeLabel_injective (signs : Triple) : Function.Injective (decodeLabel signs) := by |
| intro a b same |
| apply Fin.ext |
| exact (List.Nodup.getElem_inj (satisfyingTriples_nodup signs)).mp same |
| |
| def encodeLabel (signs label : Triple) (legal : localEval signs label = true) : Fin 7 := |
| ⟨(satisfyingTriples signs).idxOf label, by |
| have h := List.idxOf_lt_length_of_mem ((mem_satisfyingTriples signs label).mpr legal) |
| simpa using h⟩ |
| |
| @[simp] theorem decodeLabel_encodeLabel (signs label : Triple) |
| (legal : localEval signs label = true) : |
| decodeLabel signs (encodeLabel signs label legal) = label := by |
| exact List.getElem_idxOf _ |
| |
| def projection {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (e : Occurrence m) (answer : Fin 7) : Bool := |
| (decodeLabel (clauses e.1).signs answer).at e.2 |
| |
| theorem projection_surjective {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (e : Occurrence m) (answer : Bool) : |
| ∃ label : Fin 7, projection clauses e label = answer := by |
| obtain ⟨t, legal, ht⟩ := coordinate_surjective (clauses e.1).signs e.2 answer |
| refine ⟨encodeLabel (clauses e.1).signs t |
| ((mem_satisfyingTriples _ _).mp legal), ?_⟩ |
| simpa [projection] using ht |
| |
| theorem projection_pair_surjective {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (c : Fin m) (i j : Fin 3) (different : i ≠ j) (first second : Bool) : |
| ∃ label : Fin 7, |
| projection clauses (c, i) label = first ∧ projection clauses (c, j) label = second := by |
| obtain ⟨t, legal, ht⟩ := pair_surjective (clauses c).signs i j different first second |
| refine ⟨encodeLabel (clauses c).signs t ((mem_satisfyingTriples _ _).mp legal), ?_⟩ |
| simpa [projection] using ht |
| |
| theorem leftAlphabet_card : Fintype.card (Fin 7) = 7 := by simp |
| theorem rightAlphabet_card : Fintype.card Bool = 2 := by decide |
| |
| noncomputable section |
| |
| def game {n m : Nat} [NeZero m] (clauses : Fin m → NormalizedClause n) : |
| OccurrenceGame (Occurrence m) (Fin m) (Fin n) (Fin 7) Bool := |
| OccurrenceGame.ofProjection (FiniteDistribution.uniform (Occurrence m)) |
| Prod.fst (occurrenceVariable clauses) (projection clauses) |
| |
| theorem endpointDetermined {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) : (game clauses).EndpointDetermined := by |
| intro e e' sameClause sameVariable a b |
| have same := occurrence_determined_by_endpoints clauses e e' sameClause sameVariable |
| subst e' |
| rfl |
|
|
| def endpointPredicate {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (c : Fin m) (v : Fin n) (a : Fin 7) (b : Bool) : Bool := |
| decide (∃ i : Fin 3, (clauses c).variable i = v ∧ |
| (decodeLabel (clauses c).signs a).at i = b) |
|
|
| theorem endpointPredicate_eq_true {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (c : Fin m) (v : Fin n) (a : Fin 7) (b : Bool) : |
| endpointPredicate clauses c v a b = true ↔ |
| ∃ i : Fin 3, (clauses c).variable i = v ∧ |
| (decodeLabel (clauses c).signs a).at i = b := by |
| exact decide_eq_true_iff |
|
|
| def presentation {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) : (game clauses).EndpointPresentation where |
| predicate := endpointPredicate clauses |
| agrees e a b := by |
| apply Bool.eq_iff_iff.mpr |
| rw [endpointPredicate_eq_true] |
| simp only [game, OccurrenceGame.ofProjection, occurrenceVariable, decide_eq_true_eq] |
| constructor |
| · intro h |
| exact ⟨e.2, rfl, h⟩ |
| · rintro ⟨i, sameVariable, h⟩ |
| have samePosition : i = e.2 := (clauses e.1).distinct i e.2 sameVariable |
| simpa [projection, samePosition] using h |
|
|
| def questionGame {n m : Nat} [NeZero m] (clauses : Fin m → NormalizedClause n) : |
| Game (Fin m) (Fin n) (Fin 7) Bool := |
| (game clauses).toGame (presentation clauses) |
|
|
| @[simp] theorem questionGame_success {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) (strategy : Strategy (Fin m) (Fin n) (Fin 7) Bool) : |
| (questionGame clauses).success strategy = (game clauses).success strategy := |
| (game clauses).toGame_success (presentation clauses) strategy |
|
|
| theorem restrict_at {n : Nat} (c : NormalizedClause n) |
| (assignment : Fin n → Bool) (i : Fin 3) : |
| (c.restrict assignment).at i = assignment (c.variable i) := by |
| have cases_three : ∀ i : Fin 3, i = 0 ∨ i = 1 ∨ i = 2 := by decide |
| rcases cases_three i with rfl | rfl | rfl <;> rfl |
|
|
| def completenessStrategy {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (assignment : Fin n → Bool) (satisfying : ∀ c, (clauses c).clause.eval assignment = true) : |
| Strategy (Fin m) (Fin n) (Fin 7) Bool := |
| (fun c => encodeLabel (clauses c).signs ((clauses c).restrict assignment) |
| (by simpa using satisfying c), assignment) |
|
|
| theorem completeness_wins {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) (assignment : Fin n → Bool) |
| (satisfying : ∀ c, (clauses c).clause.eval assignment = true) (e : Occurrence m) : |
| (game clauses).wins (completenessStrategy clauses assignment satisfying) e = true := by |
| simp only [game, OccurrenceGame.ofProjection, OccurrenceGame.wins, completenessStrategy, |
| projection, decodeLabel_encodeLabel, decide_eq_true_eq] |
| exact restrict_at (clauses e.1) assignment e.2 |
|
|
| theorem completeness_success {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) (assignment : Fin n → Bool) |
| (satisfying : ∀ c, (clauses c).clause.eval assignment = true) : |
| (game clauses).success (completenessStrategy clauses assignment satisfying) = 1 := by |
| have h : (game clauses).wins (completenessStrategy clauses assignment satisfying) = |
| fun _ => true := funext (completeness_wins clauses assignment satisfying) |
| unfold OccurrenceGame.success |
| rw [h, FiniteDistribution.probability_true] |
|
|
| theorem completeness_value {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) (assignment : Fin n → Bool) |
| (satisfying : ∀ c, (clauses c).clause.eval assignment = true) : |
| (game clauses).value = 1 := by |
| apply le_antisymm (game clauses).value_le_one |
| rw [← completeness_success clauses assignment satisfying] |
| exact (game clauses).success_le_value _ |
|
|
| def winCount {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (strategy : Strategy (Fin m) (Fin n) (Fin 7) Bool) : Nat := |
| ∑ c, agreementCount (clauses c) (decodeLabel (clauses c).signs (strategy.1 c)) strategy.2 |
|
|
| def violatedCount {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (assignment : Fin n → Bool) : Nat := |
| ∑ c, if (clauses c).clause.eval assignment then 0 else 1 |
|
|
| theorem winCount_add_violated_le {n m : Nat} (clauses : Fin m → NormalizedClause n) |
| (strategy : Strategy (Fin m) (Fin n) (Fin 7) Bool) : |
| winCount clauses strategy + violatedCount clauses strategy.2 ≤ 3 * m := by |
| unfold winCount violatedCount |
| rw [← Finset.sum_add_distrib] |
| calc |
| _ ≤ ∑ _c : Fin m, 3 := by |
| apply Finset.sum_le_sum |
| intro c _ |
| have h := agreementCount_le_two_add_satisfied (clauses c) |
| (decodeLabel (clauses c).signs (strategy.1 c)) strategy.2 |
| (decodeLabel_legal _ _) |
| cases heval : (clauses c).clause.eval strategy.2 <;> |
| simp [heval] at h ⊢ <;> omega |
| _ = 3 * m := by simp [Nat.mul_comm] |
|
|
| private theorem probability_uniform {E : Type*} [Fintype E] [Nonempty E] |
| (event : E → Bool) : |
| (FiniteDistribution.uniform E).probability event = |
| (∑ e, if event e then (1 : ℝ) else 0) / (Fintype.card E : ℝ) := by |
| unfold FiniteDistribution.probability FiniteDistribution.uniform |
| rw [Finset.sum_div] |
| apply Finset.sum_congr rfl |
| intro e _ |
| cases event e <;> simp |
|
|
| theorem success_eq_winCount_div {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) |
| (strategy : Strategy (Fin m) (Fin n) (Fin 7) Bool) : |
| (game clauses).success strategy = (winCount clauses strategy : ℝ) / (3 * (m : ℝ)) := by |
| have hsum : |
| (∑ e : Occurrence m, if (game clauses).wins strategy e then (1 : ℝ) else 0) = |
| (winCount clauses strategy : ℝ) := by |
| rw [Fintype.sum_prod_type] |
| simp only [winCount, Nat.cast_sum] |
| apply Finset.sum_congr rfl |
| intro c _ |
| rw [Fin.sum_univ_three] |
| simp [game, OccurrenceGame.ofProjection, OccurrenceGame.wins, projection, |
| occurrenceVariable, agreementCount, Triple.at, Nat.cast_add, Nat.cast_ite] |
| change (FiniteDistribution.uniform (Occurrence m)).probability |
| ((game clauses).wins strategy) = _ |
| rw [probability_uniform, hsum] |
| congr 1 |
| simp [Occurrence, mul_comm] |
|
|
| theorem success_le_one_sub_third_violations {n m : Nat} [NeZero m] |
| (clauses : Fin m → NormalizedClause n) |
| (strategy : Strategy (Fin m) (Fin n) (Fin 7) Bool) : |
| (game clauses).success strategy ≤ |
| 1 - ((violatedCount clauses strategy.2 : ℝ) / (m : ℝ)) / 3 := by |
| have hm : (0 : ℝ) < m := by exact_mod_cast Nat.pos_of_neZero m |
| have hden : (0 : ℝ) < 3 * (m : ℝ) := mul_pos (by norm_num) hm |
| have hcount : (winCount clauses strategy : ℝ) + |
| (violatedCount clauses strategy.2 : ℝ) ≤ 3 * (m : ℝ) := by |
| exact_mod_cast winCount_add_violated_le clauses strategy |
| rw [success_eq_winCount_div] |
| apply (div_le_iff₀ hden).mpr |
| have hidentity : |
| (1 - ((violatedCount clauses strategy.2 : ℝ) / (m : ℝ)) / 3) * (3 * (m : ℝ)) = |
| 3 * (m : ℝ) - (violatedCount clauses strategy.2 : ℝ) := by |
| field_simp [ne_of_gt hm] |
| rw [hidentity] |
| linarith |
|
|
| end |
| end BinPackingCompleteness.SourceGame |
|
|
| namespace BinPackingCompleteness.NormalizationEmitMachine |
|
|
| open Turing |
| open BinPackingGames.Foundations.Complexity |
| open MachineComposition |
| open BinPackingGames.Reduction.MachineTransfer |
| open BinPackingGames.Reduction.MachineSubstitution |
| open NormalizationWords |
|
|
| variable {K Λ A : Type} [DecidableEq K] |
|
|
| abbrev Alphabet (_ : K) := Bool |
| abbrev State (A : Type) := (A × Signs) × Option Bool |
|
|
| def clean (ambient : A) (signs : Signs) : State A := ((ambient, signs), none) |
|
|
| def sourceIndex : NameRef → Fin 6 |
| | .old i => ⟨i.val + 1, by have := i.isLt; omega⟩ |
| | .fresh _ => 0 |
|
|
| theorem sourceIndex_ne_scratch (name : NameRef) : sourceIndex name ≠ 4 := by |
| cases name with |
| | old i => |
| intro h |
| have hi := i.isLt |
| have hv := congrArg Fin.val h |
| simp only [sourceIndex] at hv |
| omega |
| | fresh i => simp [sourceIndex] |
|
|
| theorem sourceIndex_ne_output (name : NameRef) : sourceIndex name ≠ 5 := by |
| cases name with |
| | old i => |
| intro h |
| have hi := i.isLt |
| have hv := congrArg Fin.val h |
| simp only [sourceIndex] at hv |
| omega |
| | fresh i => simp [sourceIndex] |
|
|
| inductive LocalLabel |
| | copyOut |
| | copyBack |
| | emit |
| deriving DecidableEq |
|
|
| protected abbrev LocalLabel.enumList : List LocalLabel := [.copyOut, .copyBack, .emit] |
|
|
| protected theorem LocalLabel.enumList_getElem?_ctorIdx_eq (x : LocalLabel) : |
| LocalLabel.enumList[x.ctorIdx]? = some x := by |
| cases x <;> rfl |
|
|
| protected theorem LocalLabel.enumList_nodup : LocalLabel.enumList.Nodup := by decide |
|
|
| instance : Fintype LocalLabel where |
| elems := ⟨LocalLabel.enumList, LocalLabel.enumList_nodup⟩ |
| complete x := by cases x <;> decide |
|
|
| def emitSign (output : K) (sign : SignRef) (exit : Option Λ) : |
| TM2.Stmt (Alphabet (K := K)) Λ (State A) := |
| .branch (fun state => signValue state.1.2 sign) |
| (.push output (fun _ => true) |
| (.push output (fun _ => false) (exitAt output exit))) |
| (.push output (fun _ => false) (exitAt output exit)) |
|
|
| def emit (output : K) (literal : LiteralRecipe) (exit : Option Λ) : |
| TM2.Stmt (Alphabet (K := K)) Λ (State A) := |
| pushWord output (List.replicate (offset literal.name) true ++ [false]) |
| (emitSign output literal.sign exit) |
|
|
| def localInstruction (tape : Fin 6 → K) (literal : LiteralRecipe) |
| (labels : LocalLabel → Λ) (exit : Option Λ) : |
| LocalLabel → TM2.Stmt (Alphabet (K := K)) Λ (State A) |
| | .copyOut => loopAt (tape (sourceIndex literal.name)) (tape 4) id false |
| (labels .copyOut) (some (labels .copyBack)) |
| | .copyBack => MachineCopy.forkLoop (tape 4) (tape (sourceIndex literal.name)) |
| (tape 5) false (labels .copyBack) (some (labels .emit)) |
| | .emit => emit (tape 5) literal exit |
|
|
| private theorem joinTrace {X : Type*} {f : X → X} {a b c : X} {n m : Nat} |
| (first : f^[n] a = b) (second : f^[m] b = c) : f^[n + m] a = c := by |
| rw [Nat.add_comm, Function.iterate_add_apply, first, second] |
|
|
| theorem stepAux_emit (output : K) (literal : LiteralRecipe) (exit : Option Λ) |
| (base : K → List Bool) (ambient : A) (signs : Signs) (names : Names) (freshBase : Nat) : |
| TM2.stepAux (emit output literal exit) (clean ambient signs) |
| (Function.update base output |
| (List.replicate (sourceValue names freshBase literal.name) true ++ base output)) = |
| ⟨exit, clean ambient signs, Function.update base output |
| ((literalBits signs names freshBase literal).reverse ++ base output)⟩ := by |
| have nameOrder : nameValue names freshBase literal.name = |
| offset literal.name + sourceValue names freshBase literal.name := by |
| exact Nat.add_comm _ _ |
| have swapped : List.replicate (offset literal.name) true ++ |
| (List.replicate (sourceValue names freshBase literal.name) true ++ base output) = |
| List.replicate (sourceValue names freshBase literal.name) true ++ |
| (List.replicate (offset literal.name) true ++ base output) := by |
| calc |
| _ = List.replicate |
| (offset literal.name + sourceValue names freshBase literal.name) true ++ base output := by |
| rw [List.replicate_add, List.append_assoc] |
| _ = List.replicate |
| (sourceValue names freshBase literal.name + offset literal.name) true ++ base output := by |
| rw [Nat.add_comm (offset literal.name) (sourceValue names freshBase literal.name)] |
| _ = _ := by rw [List.replicate_add, List.append_assoc] |
| unfold emit |
| rw [stepAux_pushWord] |
| cases hs : signValue signs literal.sign <;> cases exit <;> |
| simp [emitSign, clean, TM2.stepAux, exitAt, hs, literalBits, |
| NormalizationWords.literalWords, encodeWords, encodeWord, nameOrder, |
| List.reverse_append, List.reverse_replicate, List.replicate_add, List.append_assoc, |
| -List.replicate_append_replicate] <;> |
| rw [swapped] |
|
|
| theorem literalTrace (tape : Fin 6 → K) (distinct : Function.Injective tape) |
| (literal : LiteralRecipe) (labels : LocalLabel → Λ) (exit : Option Λ) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A)) |
| (atLabels : ∀ l, program (labels l) = localInstruction tape literal labels exit l) |
| (base : K → List Bool) (ambient : A) (signs : Signs) (names : Names) (freshBase : Nat) |
| (sourceWord : base (tape (sourceIndex literal.name)) = |
| List.replicate (sourceValue names freshBase literal.name) true) |
| (scratchEmpty : base (tape 4) = []) : |
| (advance (TM2.step program))^[2 * (sourceValue names freshBase literal.name + 1) + 1] |
| (some ⟨some (labels .copyOut), clean ambient signs, base⟩) = |
| some ⟨exit, clean ambient signs, Function.update base (tape 5) |
| ((literalBits signs names freshBase literal).reverse ++ base (tape 5))⟩ := by |
| have hd (i j : Fin 6) (hne : i ≠ j) : tape i ≠ tape j := fun h => hne (distinct h) |
| have copied := MachineCopy.copyTrace (tape (sourceIndex literal.name)) (tape 5) (tape 4) |
| (hd _ _ (sourceIndex_ne_output _)) (hd _ _ (sourceIndex_ne_scratch _)) |
| (hd 5 4 (by decide)) false (labels .copyOut) (labels .copyBack) |
| (some (labels .emit)) program (atLabels .copyOut) (atLabels .copyBack) |
| base scratchEmpty (ambient, signs) none |
| rw [sourceWord, List.length_replicate] at copied |
| have emitted : (advance (TM2.step program))^[1] |
| (some ⟨some (labels .emit), clean ambient signs, |
| Function.update base (tape 5) |
| (List.replicate (sourceValue names freshBase literal.name) true ++ base (tape 5))⟩) = |
| some ⟨exit, clean ambient signs, Function.update base (tape 5) |
| ((literalBits signs names freshBase literal).reverse ++ base (tape 5))⟩ := by |
| change some (TM2.stepAux (program (labels .emit)) _ _) = _ |
| rw [atLabels .emit] |
| exact congrArg some (stepAux_emit (tape 5) literal exit base ambient signs names freshBase) |
| exact joinTrace copied emitted |
|
|
| def result (signs : Signs) (names : Names) (freshBase : Nat) |
| (literal : LiteralRecipe) (output : List Bool) : List Bool := |
| (literalBits signs names freshBase literal).reverse ++ output |
|
|
| def cost (names : Names) (freshBase : Nat) (literal : LiteralRecipe) (_ : List Bool) : Nat := |
| 2 * (sourceValue names freshBase literal.name + 1) + 1 |
|
|
| def commandSteps (names : Names) (freshBase : Nat) (commands : List LiteralRecipe) : Nat := |
| (commands.map (fun literal => 2 * (sourceValue names freshBase literal.name + 1) + 1)).sum |
|
|
| theorem resultOf_eq (signs : Signs) (names : Names) (freshBase : Nat) |
| (commands : List LiteralRecipe) (output : List Bool) : |
| MachineFiniteSequence.resultOf (result signs names freshBase) commands output = |
| (commands.flatMap (literalBits signs names freshBase)).reverse ++ output := by |
| induction commands generalizing output with |
| | nil => rfl |
| | cons literal commands ih => |
| simp only [MachineFiniteSequence.resultOf, ih, result, List.flatMap_cons, |
| List.reverse_append, List.append_assoc] |
|
|
| theorem sequenceSteps_eq (signs : Signs) (names : Names) (freshBase : Nat) |
| (commands : List LiteralRecipe) (output : List Bool) : |
| MachineFiniteSequence.steps (result signs names freshBase) (cost names freshBase) |
| commands output = commandSteps names freshBase commands := by |
| induction commands generalizing output with |
| | nil => rfl |
| | cons literal commands ih => |
| simp only [MachineFiniteSequence.steps, ih, commandSteps, List.map_cons, |
| List.sum_cons, cost] |
|
|
| theorem sourceValue_le (names : Names) (freshBase maximum : Nat) |
| (freshBound : freshBase ≤ maximum) (nameBounds : ∀ i, names i ≤ maximum) |
| (name : NameRef) : sourceValue names freshBase name ≤ maximum := by |
| cases name with |
| | old i => exact nameBounds i |
| | fresh i => exact freshBound |
|
|
| theorem commandSteps_le (names : Names) (freshBase maximum : Nat) |
| (freshBound : freshBase ≤ maximum) (nameBounds : ∀ i, names i ≤ maximum) |
| (commands : List LiteralRecipe) : |
| commandSteps names freshBase commands ≤ commands.length * (2 * maximum + 3) := by |
| induction commands with |
| | nil => simp [commandSteps] |
| | cons literal commands ih => |
| have current := sourceValue_le names freshBase maximum freshBound nameBounds literal.name |
| simp only [commandSteps, List.map_cons, List.sum_cons, List.length_cons, |
| Nat.add_mul, Nat.one_mul] at ih ⊢ |
| omega |
|
|
| abbrev Labels (commands : List LiteralRecipe) := |
| MachineFiniteSequence.Label (fun _ : LiteralRecipe => LocalLabel) commands |
|
|
| def sequenceInstruction (tape : Fin 6 → K) (commands : List LiteralRecipe) |
| (labels : Labels commands → Λ) (exit : Option Λ) : |
| Labels commands → TM2.Stmt (Alphabet (K := K)) Λ (State A) := |
| MachineFiniteSequence.instruction (fun _ => LocalLabel) (fun _ => LocalLabel.copyOut) |
| (localInstruction tape) commands labels exit |
|
|
| def sequenceEntry (commands : List LiteralRecipe) (labels : Labels commands → Λ) |
| (exit : Option Λ) : Option Λ := |
| MachineFiniteSequence.entry (fun _ => LocalLabel) (fun _ => LocalLabel.copyOut) |
| commands labels exit |
|
|
| theorem sequenceTrace (tape : Fin 6 → K) (distinct : Function.Injective tape) |
| (commands : List LiteralRecipe) (labels : Labels commands → Λ) (exit : Option Λ) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A)) |
| (atLabels : ∀ l, program (labels l) = sequenceInstruction tape commands labels exit l) |
| (base : K → List Bool) (ambient : A) (signs : Signs) (names : Names) (freshBase : Nat) |
| (sourceWords : ∀ name, base (tape (sourceIndex name)) = |
| List.replicate (sourceValue names freshBase name) true) |
| (scratchEmpty : base (tape 4) = []) : |
| (advance (TM2.step program))^[commandSteps names freshBase commands] |
| (some ⟨sequenceEntry commands labels exit, clean ambient signs, base⟩) = |
| some ⟨exit, clean ambient signs, Function.update base (tape 5) |
| ((commands.flatMap (literalBits signs names freshBase)).reverse ++ base (tape 5))⟩ := by |
| have hd (i j : Fin 6) (hne : i ≠ j) : tape i ≠ tape j := fun h => hne (distinct h) |
| have native := MachineFiniteSequence.trace (fun _ : LiteralRecipe => LocalLabel) |
| (fun _ => LocalLabel.copyOut) (localInstruction tape) |
| (result signs names freshBase) (cost names freshBase) program |
| (fun _ => True) (fun _ => clean ambient signs) |
| (fun output => Function.update base (tape 5) output) commands |
| (fun _ _ _ _ => True.intro) |
| (fun literal _ localLabels localExit localEquations output _ => by |
| have actual := literalTrace tape distinct literal localLabels localExit program |
| localEquations (Function.update base (tape 5) output) ambient signs names freshBase |
| (by simp [hd (sourceIndex literal.name) 5 (sourceIndex_ne_output literal.name), sourceWords]) |
| (by simp [hd 4 5 (by decide), scratchEmpty]) |
| simpa only [cost, result, Function.update_self, Function.update_idem] using actual) |
| labels exit atLabels (base (tape 5)) True.intro |
| simpa only [sequenceSteps_eq, resultOf_eq, Function.update_eq_self, |
| sequenceEntry] using native |
|
|
| abbrev Label := Labels recipe |
|
|
| def main : Label := .inl .copyOut |
|
|
| def instruction (tape : Fin 6 → K) (labels : Label → Λ) (exit : Option Λ) : |
| Label → TM2.Stmt (Alphabet (K := K)) Λ (State A) := |
| sequenceInstruction tape recipe labels exit |
|
|
| def steps (names : Names) (freshBase : Nat) : Nat := commandSteps names freshBase recipe |
|
|
| theorem steps_le (names : Names) (freshBase maximum : Nat) |
| (freshBound : freshBase ≤ maximum) (nameBounds : ∀ i, names i ≤ maximum) : |
| steps names freshBase ≤ 39 * (2 * maximum + 3) := by |
| simpa only [steps, recipe_length] using |
| commandSteps_le names freshBase maximum freshBound nameBounds recipe |
|
|
| theorem gadgetTrace (tape : Fin 6 → K) (distinct : Function.Injective tape) |
| (labels : Label → Λ) (exit : Option Λ) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A)) |
| (atLabels : ∀ l, program (labels l) = instruction tape labels exit l) |
| (base : K → List Bool) (ambient : A) (signs : Signs) (names : Names) (freshBase : Nat) |
| (freshWord : base (tape 0) = List.replicate freshBase true) |
| (oldWords : ∀ i, base (tape (sourceIndex (.old i))) = List.replicate (names i) true) |
| (scratchEmpty : base (tape 4) = []) : |
| (advance (TM2.step program))^[steps names freshBase] |
| (some ⟨some (labels main), clean ambient signs, base⟩) = |
| some ⟨exit, clean ambient signs, Function.update base (tape 5) |
| ((bits signs names freshBase).reverse ++ base (tape 5))⟩ := by |
| have sources : ∀ name, base (tape (sourceIndex name)) = |
| List.replicate (sourceValue names freshBase name) true := by |
| intro name |
| cases name with |
| | old i => exact oldWords i |
| | fresh i => exact freshWord |
| have trace := sequenceTrace tape distinct recipe labels exit program atLabels |
| base ambient signs names freshBase sources scratchEmpty |
| have entry : sequenceEntry recipe labels exit = some (labels main) := rfl |
| rw [← bits_eq_flatMap] at trace |
| simpa only [steps, entry] using trace |
|
|
| def gadgetInTime (tape : Fin 6 → K) (distinct : Function.Injective tape) |
| (labels : Label → Λ) (exit : Option Λ) |
| (program : Λ → TM2.Stmt (Alphabet (K := K)) Λ (State A)) |
| (atLabels : ∀ l, program (labels l) = instruction tape labels exit l) |
| (base : K → List Bool) (ambient : A) (signs : Signs) (names : Names) |
| (freshBase maximum : Nat) |
| (freshWord : base (tape 0) = List.replicate freshBase true) |
| (oldWords : ∀ i, base (tape (sourceIndex (.old i))) = List.replicate (names i) true) |
| (scratchEmpty : base (tape 4) = []) |
| (freshBound : freshBase ≤ maximum) (nameBounds : ∀ i, names i ≤ maximum) : |
| StateTransition.EvalsToInTime (TM2.step program) |
| ⟨some (labels main), clean ambient signs, base⟩ |
| (some ⟨exit, clean ambient signs, Function.update base (tape 5) |
| ((bits signs names freshBase).reverse ++ base (tape 5))⟩) |
| (39 * (2 * maximum + 3)) where |
| steps := steps names freshBase |
| evals_in_steps := gadgetTrace tape distinct labels exit program atLabels base ambient |
| signs names freshBase freshWord oldWords scratchEmpty |
| steps_le_m := steps_le names freshBase maximum freshBound nameBounds |
|
|
| theorem label_finite : Finite Label := inferInstance |
|
|
| theorem state_finite [Finite A] : Finite (State A) := inferInstance |
|
|
| end BinPackingCompleteness.NormalizationEmitMachine |
|
|
| end OAI |
|
|
