Require mathcomp.ssreflect.ssreflect.
Require Import edone bcase fset base modular_hilbert.
Set Implicit Arguments.
Import Prenex Implicits.
Require Import edone bcase fset base modular_hilbert.
Set Implicit Arguments.
Import Prenex Implicits.
Record slClass (form:choiceType) :=
SLClass {
supp' : {fset form * bool} -> form -> bool -> bool;
supp_mon C D s : C `<=` D -> supp' C s.1 s.2 -> supp' D s.1 s.2;
lit' : form * bool -> bool;
supp_lit C s b : lit' (s,b) -> supp' C s b = ((s,b) \in C);
f_weight' : form -> nat;
sweight_lit s : f_weight' s.1 = 0 <-> lit' s
}.
Record slType := SLType { sl_form :> choiceType ; sl_class : slClass sl_form }.
Definition lit (form : slType) := lit' (sl_class form).
Definition supp (form : slType) := supp' (sl_class form).
Definition f_weight (form : slType) := f_weight' (sl_class form).
Section SuppC.
Variable form : slType.
Definition suppC (L C : clause) := [all s in C, supp L s.1 s.2].
Definition suppS S C := [some D in S, suppC D C].
Definition base S C := [fset D in S | suppC D C ].
Lemma suppCU L C C' : suppC L (C `|` C') = suppC L C && suppC L C'.
Lemma suppCD L C C' : suppC L C' -> suppC L (C `\` C') -> suppC L C.
Lemma suppCWL L1 L2 C : suppC L2 C -> suppC (L1 `|` L2) C.
Lemma suppC_sub L C C' : C `<=` C' -> suppC L C' -> suppC L C.
Definition s_weight := [fun s : form * bool => f_weight s.1].
Definition weight C := fsum s_weight C.
Definition literalC (L : clause) := [all s in L, lit s].
Lemma suppxx C : literalC C -> suppC C C.
Lemma weight0 L : (weight L = 0) -> literalC L.
Lemma weightS L : (0 < weight L) -> ~~ literalC L.
End SuppC.
Record slpType := SLPType { slp_form :> pSystem ; slp_class : slClass slp_form }.
Definition slType_of (form : slpType) := SLType (slp_class form).
Coercion slType_of : slpType >-> slType.
Canonical local_formSLType (form : slpType) : slType := form.
Section slpTheory.
Variable form : slpType.
Definition interp (f:slpType) (s : f * bool) := match s with (t,true) => t | (t,false) => ~~: t end.
Caveat: use of the lemmas below sometimes exposes an invisible (implicit)
slpType instance (propositional reasoning) and needs to be simplified to the
underlying formula type before further modal reasoning can be applied
Lemma af1p (s : form) : mprv (s ---> [af [fset s^+]]).
Lemma afp1 (s : form) : mprv ([af [fset s^+]] ---> s).
Lemma af1n (s : form) : mprv (Neg s ---> [af [fset s^-]]).
Lemma afn1 (s : form) : mprv ([af [fset s^-]] ---> Neg s).
Variable ssub : sform -> {fset sform}.
Inductive decomp (s : sform) : Type :=
| decomp_lit : @lit form s -> decomp s
| decomp_ab (S : {fset clause}) :
(forall (D : clause), D \in S -> D `<=` ssub s) ->
(forall (D : clause), D \in S -> weight D < s_weight s) ->
(forall (C D : clause), D \in S -> suppC C D -> supp C s.1 s.2) ->
mprv (interp s ---> \or_(D <- S) [af D])
-> decomp s.
Hypothesis decompP : forall s, decomp s.
Variable F : {fset sform}.
Hypothesis ssub_F : forall s, s \in F -> ssub s `<=` F.
Let LF : {fset clause} := [fset C in powerset F | literalC C].
Lemma supp_aux C : C \in powerset F -> mprv ([af C] ---> \or_(D <- base LF C) [af D]).
End slpTheory.
Notation "[ 'af' C ]" := (\and_(s <- C) interp s) (at level 0, format "[ 'af' C ]").