Cubicle BRAB in Why3 index


theory FOL

   type t
   type structure

   predicate (|=) structure t

   constant ffalse : t
   
   constant ttrue : t

   function (~_) t : t
   function (&) t t : t
   function (++) t t : t
   function (=>) t t : t
   
   predicate (|==) t t

   axiom model_extensionality :
     forall f1 f2 : t.
       f1 |== f2 <-> (forall m : structure [m]. m |= f1 -> m |= f2)

   axiom extensionality :
     forall f1 f2 : t.
       (forall m : structure [m]. m |= f1 <-> m |= f2) -> f1 = f2
   
   (* Just for instantiation *)
   axiom structure_exists :
     exists m : structure [m]. exists f: t [f]. m |= f
     
   axiom true_false : ttrue <> ffalse
   
   axiom model_true :
     forall m : structure. m |= ttrue
     
   axiom model_false :
     forall m : structure. not (m |= ffalse)
          
   axiom model_neg :
     forall m : structure. forall f : t.
       m |= (~ f) <-> not (m |= f)
       
   axiom model_and :
      forall m : structure. forall f1 f2 : t.
        m |= (f1 & f2) <-> m |= f1 /\ m |= f2
        
   axiom model_or :
      forall m : structure. forall f1 f2 : t.
        m |= (f1 ++ f2) <-> m |= f1 \/ m |= f2
       
   predicate sat (f : t) = exists m: structure. m |= f
   
   predicate valid (f : t) = not (sat (~ f))

   lemma valid_def :
     forall f : t [valid (f)]. valid (f) <-> forall m: structure [m]. (m |= f)
   
   axiom imply_def :
     forall f1 f2 : t. f1 => f2 = (~ f1) ++ f2

   lemma imply_models :
     forall f1 f2 : t. valid (f1 => f2) <-> f1 |== f2
     
   lemma negneg : forall f: t [~ ~ f]. ~ ~ f = f

   lemma and_a : forall f1 f2 f3 : t. (f1 & f2) & f3 = f1 & (f2 & f3)
   
   lemma and_c : forall f1 f2 : t. f1 & f2 = f2 & f1
   
   lemma or_a : forall f1 f2 f3 : t. (f1 ++ f2) ++ f3 = f1 ++ (f2 ++ f3)
   
   lemma or_c : forall f1 f2 : t. f1 ++ f2 = f2 ++ f1

   lemma distr_and:
     forall f1 f2 f3 : t. f1 & (f2 ++ f3) = (f1 & f2) ++ (f1 & f3)
     
   lemma distr_or :
     forall f1 f2 f3 : t. f1 ++ (f2 & f3) = (f1 ++ f2) & (f1 ++ f3)
     
   lemma neutral_and : forall f: t. f & ttrue = f
   
   lemma neutral_or : forall f: t. f ++ ffalse = f
   
   lemma absorb_and : forall f: t. f & ffalse = ffalse
   
   lemma absorb_or : forall f: t. f ++ ttrue = ttrue

   
   lemma sat_def: forall f: t. sat f <-> not (valid (~ f))
   
   lemma unsat_invalid : forall f: t. not (valid f) -> sat (~ f)

   lemma valid_sat : forall f: t. valid f -> sat f
   
   lemma ttrue_valid : valid ttrue
   lemma ffaslse_invalid : not (valid ffalse)
   lemma ttrue_sat : sat ttrue
   lemma ffalse_unsat : not (sat ffalse)


   lemma sat_neg :
     forall f : t.  not (sat f) -> sat (~ f)
   
   lemma valid_neg :
     forall f : t. valid (~ f) -> not (valid f)
   
   lemma sat_or :
     forall f1 f2 : t.
       sat (f1 ++ f2) <-> (sat f1) \/ (sat f2)
   
   lemma valid_and :
     forall f1 f2 : t.
       valid (f1 & f2) <-> (valid f1) /\ (valid f2)
   
   lemma valid_or :
     forall f1 f2 : t.
       (valid f1) \/ (valid f2) -> valid (f1 ++ f2)
   
   lemma sat_and :
     forall f1 f2 : t.
       sat (f1 & f2) -> (sat f1) /\ (sat f2)


   lemma forget_subsumed :
     forall f v : t.
       f |== v -> f ++ v = v

   lemma forget_subsumed_imply :
     forall f v : t.
       valid (f => v) -> f ++ v = v
       
   lemma forget_subsumed_or :
     forall f v : t.
       valid ((~ f) ++ v) -> f ++ v = v

   lemma classic_neg : forall f : t. (~ f) ++ f = ttrue


   lemma imply_transitive :
     forall f1 f2 f3 : t. f1 |== f2 /\ f2 |== f3 -> f1 |== f3
     
   lemma imply_bigger :
     forall f1 f2 : t. f1 |== f1 ++ f2


   lemma imply_or:
      forall f1 f2 f3 : t. f1 |== f2 -> f1 ++ f3 |== f2 ++ f3


   lemma or_same : forall f : t. f ++ f = f
   
  (* Use AC builtin facility of Alt-Ergo but add AC axioms to others *)
  (* meta AC function (&) *)
  (* meta AC function (++) *)

end

Generated by why3doc 0.82+git