Potential partial fixes for issue #1

BoundsTheory.fs

@@ -218,14 +218,14 @@ let tbndsEvaluateAtLeast1U (s:State) (tRel:Ref<TheoryRelation>) =
     let pVal = s.bVal
     let rel = !tRel
     let boolVar = rel.getBoolVar
-    let bVal = (!pVal).getValueB boolVar
+    let bVal = (!pVal).getValueB boolVar    
 
     if bVal = Undefined then
         let holds = tbndsHolds (!tRel) s.bounds s.numeralDB
         if holds <> Undefined then
             let (expl, l) = tbndsGetImplication s tRel holds
             s.Push (Imp (ref expl, l))
-            assert(not s.IsConflicted || s.isInTempMode)
+            // assert(not s.IsConflicted || s.isInTempMode)
     else
         tbndsGetImpliedBounds s tRel bVal
 

RLEBVTheory.fs

@@ -353,8 +353,7 @@ let tEvaluate1U (s:State) (tRel:Ref<TheoryRelation>) =
             let holds = tHolds (!tRel) s.bvVal s.numeralDB
             if holds <> Undefined then
                 let (expl, l) = tGetImplication s tRel holds
-                s.Push (Imp (ref expl, l))
-                assert(not s.IsConflicted)
+                s.Push (Imp (ref expl, l))                
 
     | Z3_decl_kind.Z3_OP_ULEQ ->
         let bVal = (!pVal).getValueB boolVar

Trail.fs

@@ -462,18 +462,14 @@ type Trail (sz:int) =
                 else
                     // Negative PAPredicate
                     if not (value.isConcreteValue) then
-
                             let oldValue = (!bvVal).getValue v
                             let oldExpl = (!bvVal).getExplanation v
-                            let negPABool = Negate rel.getBoolVar
 
-                            let intersection =  BitVector.Intersect oldValue value
+                            let intersection = BitVector.Intersect oldValue value
 
                             if intersection.isInvalid then
-                                assert (oldExpl <> Negate negPABool)
-                                let cls = collectLiterals([ negPABool;
-                                                            Negate oldExpl;
-                                                            ])
+                                assert (oldExpl <> Negate l)
+                                let cls = collectLiterals([ Negate l; Negate oldExpl; ])
                                 cnflct <- Some (ref (newClauseFromList cls))
 
                             elif USE_BOUNDS then