File size: 3,689 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 | 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
|