File size: 4,917 Bytes
a2ee19a | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 | import OAI.Probability.SATComputability.ClauseClasses
namespace OAI
namespace FixedClauseThreshold.Computability
open scoped Classical
def classClause {n : ℕ} (c : TripleClasses (SignedLiteral n)) : Fin 3 → SignedLiteral (n+1) :=
(clauseClassesEquiv n).symm c
noncomputable def classBaseMask {n : ℕ} : TripleClasses (SignedLiteral n) → Finset (DeletionCandidate n)
| .inl c => clauseMask ((tripleVectorEquiv _).symm c)
| .inr _ => Finset.univ
noncomputable def classIncidentMask {n : ℕ} (v : Bool) :
TripleClasses (SignedLiteral n) → Finset (DeletionCandidate n)
| .inl _ => Finset.univ
| .inr (.inl (_,b,c,d)) => if v = b then Finset.univ else clauseMask ![c,d]
| .inr (.inr (.inl (_,a,b,c))) => if v = a ∨ v = b then Finset.univ else clauseMask ![c]
| .inr (.inr (.inr (a,b,c))) => if v = a ∨ v = b ∨ v = c then Finset.univ else ∅
theorem classClause_base {n : ℕ} (c : Triple (SignedLiteral n)) :
classClause (.inl c) = fun j => liftLiteral ((tripleVectorEquiv _).symm c j) := by
funext j
fin_cases j <;> rfl
theorem literalFalse_distinguished {n : ℕ} (x : DeletionCandidate n) (v : Option Bool) (b : Bool) :
literalFalse (restoreCandidate v x) (0,b) ↔ v = some (!b) := Iff.rfl
theorem literalFalse_restored {n : ℕ} (x : DeletionCandidate n) (v : Option Bool)
(l : SignedLiteral n) :
literalFalse (restoreCandidate v x) (liftLiteral l) ↔ literalFalse x l := Iff.rfl
theorem classClause_restored_base {n : ℕ} (c : Triple (SignedLiteral n)) :
clauseMask (classClause (.inl c)) = restoredMask (classBaseMask (.inl c))
(classIncidentMask false (.inl c)) (classIncidentMask true (.inl c)) := by
rw [classClause_base]
ext x
simp only [clauseMask_lift, classBaseMask, classIncidentMask, restoredMask,
Finset.mem_filter, Finset.mem_univ, true_and]
cases x 0 with
| none => simp
| some b => cases b <;> simp
theorem classClause_restored_single {n : ℕ} (i : Fin 3) (b : Bool)
(c d : SignedLiteral n) :
clauseMask (classClause (.inr (.inl (i,b,c,d)))) =
restoredMask (classBaseMask (.inr (.inl (i,b,c,d))))
(classIncidentMask false (.inr (.inl (i,b,c,d))))
(classIncidentMask true (.inr (.inl (i,b,c,d)))) := by
ext x
have hx : restoreCandidate (x 0) (Fin.tail x) = x := Fin.cons_self_tail x
conv_lhs => rw [← hx]
fin_cases i <;> cases b <;> rcases h0 : x 0 with _ | (_ | _)
all_goals simp [classClause, clauseClassesEquiv, tripleClassesEquiv, joinTriple,
tripleVectorEquiv, literalSplitEquiv, Equiv.arrowCongr, classBaseMask,
classIncidentMask, restoredMask, clauseMask, literalFalse, restoreCandidate,
Fin.forall_fin_succ, Fin.tail_def, h0, Bool.not_false, Bool.not_true]
theorem classClause_restored_double {n : ℕ} (i : Fin 3) (a b : Bool)
(c : SignedLiteral n) :
clauseMask (classClause (.inr (.inr (.inl (i,a,b,c))))) =
restoredMask (classBaseMask (.inr (.inr (.inl (i,a,b,c)))))
(classIncidentMask false (.inr (.inr (.inl (i,a,b,c)))))
(classIncidentMask true (.inr (.inr (.inl (i,a,b,c))))) := by
ext x
have hx : restoreCandidate (x 0) (Fin.tail x) = x := Fin.cons_self_tail x
conv_lhs => rw [← hx]
fin_cases i <;> cases a <;> cases b <;> rcases h0 : x 0 with _ | (_ | _)
all_goals simp [classClause, clauseClassesEquiv, tripleClassesEquiv, joinTriple,
tripleVectorEquiv, literalSplitEquiv, Equiv.arrowCongr, classBaseMask,
classIncidentMask, restoredMask, clauseMask, literalFalse, restoreCandidate,
Fin.forall_fin_succ, Fin.tail_def, h0, Bool.not_false, Bool.not_true]
theorem classClause_restored_triple {n : ℕ} (a b c : Bool) :
clauseMask (classClause (n := n) (.inr (.inr (.inr (a,b,c))))) =
restoredMask (classBaseMask (.inr (.inr (.inr (a,b,c)))))
(classIncidentMask false (.inr (.inr (.inr (a,b,c)))))
(classIncidentMask true (.inr (.inr (.inr (a,b,c))))) := by
ext x
have hx : restoreCandidate (x 0) (Fin.tail x) = x := Fin.cons_self_tail x
conv_lhs => rw [← hx]
cases a <;> cases b <;> cases c <;> rcases h0 : x 0 with _ | (_ | _)
all_goals simp [classClause, clauseClassesEquiv, tripleClassesEquiv, joinTriple,
tripleVectorEquiv, literalSplitEquiv, Equiv.arrowCongr, classBaseMask,
classIncidentMask, restoredMask, clauseMask, literalFalse, restoreCandidate,
Fin.forall_fin_succ, Fin.tail_def, h0, Bool.not_false, Bool.not_true]
theorem classClause_restored {n : ℕ} (c : TripleClasses (SignedLiteral n)) :
clauseMask (classClause c) = restoredMask (classBaseMask c)
(classIncidentMask false c) (classIncidentMask true c) := by
rcases c with c | (⟨i,b,c,d⟩ | (⟨i,a,b,c⟩ | ⟨a,b,c⟩))
· exact classClause_restored_base c
· exact classClause_restored_single i b c d
· exact classClause_restored_double i a b c
· exact classClause_restored_triple a b c
end FixedClauseThreshold.Computability
end OAI
|