| import OAI.Probability.SATComputability.ClassMasks |
|
|
| namespace OAI |
|
|
| namespace FixedClauseThreshold.Computability |
|
|
| open scoped Classical |
|
|
| abbrev IncidentClass (n : ℕ) := |
| (Fin 3 × SignedLiteral n × SignedLiteral n) ⊕ (Fin 3 × SignedLiteral n) ⊕ Unit |
| abbrev ActiveClause (n : ℕ) := Triple (SignedLiteral n) ⊕ Bool × IncidentClass n |
|
|
| def activeClass {n : ℕ} : ActiveClause n → TripleClasses (SignedLiteral n) |
| | .inl c => .inl c |
| | .inr (b,.inl (i,c,d)) => .inr (.inl (i,b,c,d)) |
| | .inr (b,.inr (.inl (i,c))) => .inr (.inr (.inl (i,b,b,c))) |
| | .inr (b,.inr (.inr _)) => .inr (.inr (.inr (b,b,b))) |
|
|
| theorem activeClass_injective (n : ℕ) : Function.Injective (activeClass (n := n)) := by |
| intro c d h |
| rcases c with c | ⟨b,c | (c | c)⟩ <;> |
| rcases d with d | ⟨a,d | (d | d)⟩ <;> |
| simp_all [activeClass] |
| all_goals exact Prod.ext h.1 h.2.2 |
|
|
| noncomputable def incidentMask {n : ℕ} : IncidentClass n → Finset (DeletionCandidate n) |
| | .inl (_,c,d) => clauseMask ![c,d] |
| | .inr _ => ∅ |
|
|
| noncomputable def strongerClassMask {n : ℕ} : ActiveClause n → Finset (DeletionCandidate (n+1)) |
| | .inl c => restoredMask (clauseMask ((tripleVectorEquiv _).symm c)) Finset.univ Finset.univ |
| | .inr (false,c) => restoredMask Finset.univ Finset.univ (incidentMask c) |
| | .inr (true,c) => restoredMask Finset.univ (incidentMask c) Finset.univ |
|
|
| theorem restoredMask_mono {n : ℕ} |
| {B F T B' F' T' : Finset (DeletionCandidate n)} |
| (hB : B ⊆ B') (hF : F ⊆ F') (hT : T ⊆ T') : |
| restoredMask B F T ⊆ restoredMask B' F' T' := by |
| intro x hx |
| obtain ⟨hb,hx⟩ := (Finset.mem_filter.mp hx).2 |
| apply Finset.mem_filter.mpr |
| refine ⟨Finset.mem_univ _,hB hb,?_⟩ |
| rcases h0 : x 0 with _ | (_ | _) |
| · trivial |
| · exact hF (by simpa only [h0] using hx) |
| · exact hT (by simpa only [h0] using hx) |
|
|
| theorem strongerClassMask_subset {n : ℕ} (c : ActiveClause n) : |
| strongerClassMask c ⊆ clauseMask (classClause (activeClass c)) := by |
| rw [classClause_restored] |
| rcases c with c | ⟨b,c | (⟨i,c⟩ | u)⟩ |
| · exact Finset.Subset.refl _ |
| · rcases c with ⟨i,c,d⟩ |
| cases b <;> exact Finset.Subset.refl _ |
| · cases b <;> |
| simp only [strongerClassMask, activeClass, classBaseMask, classIncidentMask, |
| Bool.false_eq_true, Bool.true_eq_false, or_self, ite_true, ite_false, incidentMask] |
| all_goals apply restoredMask_mono <;> first | exact Finset.Subset.refl _ | exact Finset.empty_subset _ |
| · cases b <;> exact Finset.Subset.refl _ |
|
|
| theorem inactiveClass_trivial {n : ℕ} (c : TripleClasses (SignedLiteral n)) |
| (hc : c ∉ Set.range (activeClass (n := n))) : |
| clauseMask (classClause c) = Finset.univ := by |
| rcases c with c | (⟨i,b,c,d⟩ | (⟨i,a,b,c⟩ | ⟨a,b,c⟩)) |
| · exact False.elim (hc ⟨.inl c,rfl⟩) |
| · exact False.elim (hc ⟨.inr (b,.inl (i,c,d)),rfl⟩) |
| · by_cases hab : a = b |
| · subst b |
| exact False.elim (hc ⟨.inr (a,.inr (.inl (i,c))),rfl⟩) |
| · rw [classClause_restored_double] |
| clear hc |
| cases a <;> cases b <;> try contradiction |
| all_goals |
| ext x |
| rcases h0 : x 0 with _ | (_ | _) |
| all_goals simp [classBaseMask, classIncidentMask, restoredMask, h0] |
| · by_cases habc : a = b ∧ b = c |
| · rcases habc with ⟨hab,hbc⟩ |
| subst b |
| subst c |
| exact False.elim (hc ⟨.inr (a,.inr (.inr ())),rfl⟩) |
| · rw [classClause_restored_triple] |
| clear hc |
| cases a <;> cases b <;> cases c <;> try simp_all |
| all_goals |
| ext x |
| rcases h0 : x 0 with _ | (_ | _) |
| all_goals simp [classBaseMask, classIncidentMask, restoredMask, h0] |
|
|
| end FixedClauseThreshold.Computability |
|
|
| end OAI |
|
|
