vprover / vampire Goto Github PK

View Code? Open in Web Editor NEW

268.0 268.0 48.0 33.27 MB

The Vampire Theorem Prover

Home Page: https://vprover.github.io/

License: Other

C++ 92.67% Makefile 0.31% Shell 0.83% OpenEdge ABL 0.58% Python 1.34% Perl 0.01% CMake 0.45% SMT 3.81%

vampire's People

Contributors

Stargazers

Watchers

vampire's Issues

Downloading vampire-4.3.0

Hi, I downloaded the vampire-4.3.0 from here.
When I did make vampire in the directory, ERROR happened in Lib/Recycler.hpp.
For this reason, I copied the same file from vampire-4.4 and ran it again, and it worked.
However, the version of that vampire was 4.2.2, not 4.3.0.
What should I do to use vampire-4.3.0?

Segfault in Timer

A use-after-free occurs in the UNIX-implementation of Lib/Timer.cpp.
The bug is very hard to reproduce since it depends on a race condition, that will only occur during the teardown of the application. It occured definitely this commit of the branch integer-arithmetic, but I experienced this bug occasionally since I started working on vampire.

The problem is the following:
The Environment is deleted. The timer thread is still running (driven by system interrupts). The timer thread tries to access Environment::timeLimitReached() which results in a segmentation fault.

This is the allocator log of the segfault: vampire_segfault_log.txt

Newcnf forgets (or fails to propage) Boolean bindings

The satisfiable input:

? [X0 : 'USort()'] : ! [X1 : $o] : ? [X2 : 'USort()'] : ((X1 | X0 = X2) & (~X1 | X0 != X2))

gets clausified under newcnf as the unsatisfiable:

cnf(u6,hypothesis,sK0 != sK1(X1)).
cnf(u5,hypothesis,sK0 = sK1(X1)).

It seems the problem comes from the last step in which:

----------------- OUTPUT -----------------
GC(1) {T} X0 = X2 | X1 --> $false | X2 --> sK1(X1) | X0 --> sK0
GC(1) {F} X0 = X2 | X1 --> $true | X2 --> sK1(X1) | X0 --> sK0
----------------- OUTPUT -----------------

are turned into clauses, and the bindings for X1 do not get applied to those for X2, which is becoming a skolem with a dependence on X1.

Proof output

Does Vampire support the PCL2 protocol for proof output?

I would like to use https://www.mankier.com/1/epclextract# t help me understand a large proof.

non-monotonic behaviour

Given a set of axioms, I can prove a conjecture. Adding more axioms should not block the proof of the same conjecture, right?

The output-list.tptp file contains the lines 970804-970924 of output.tptp . Nevertheless, the last conjecture of output-list.tptp is proved by Vampire with the command

$ ~/work/vampire/vampire --mode casc -t 300 output-list.tptp
% dis+10_1_add=off:afp=4000:afq=1.2:anc=none:br=off:cond=on:gs=on:irw=on:lcm=reverse:nwc=10:sd=10:ss=axioms:sos=theory:sac=on:sp=occurrence:urr=on_2 on output-list
% Time limit reached!
% ------------------------------
% Version: Vampire 4.4.0 (commit 910d806b on 2019-09-08 13:31:29 +0200)
% Termination reason: Time limit
% Termination phase: Saturation

% Memory used [KB]: 17654
% Time elapsed: 0.500 s
% ------------------------------
% ------------------------------
% dis+10_3_add=large:afp=10000:afq=1.0:amm=sco:anc=none:gsp=input_only:gs=on:gsem=off:lcm=reverse:nwc=1:sos=on_6 on output-list
% Refutation not found, incomplete strategy
% ------------------------------
% Version: Vampire 4.4.0 (commit 910d806b on 2019-09-08 13:31:29 +0200)
% Termination reason: Refutation not found, incomplete strategy

% Memory used [KB]: 9594
% Time elapsed: 0.001 s
% ------------------------------
% ------------------------------
% dis+11_1_acc=on:afp=1000:afq=1.4:amm=sco:anc=all_dependent:bs=on:ccuc=small_ones:cond=fast:fde=none:gsp=input_only:nm=64:nwc=1:sac=on:urr=ec_only:updr=off:uhcvi=on_105 on output-list
% Refutation found. Thanks to Tanya!
% SZS status Theorem for output-list
% SZS output start Proof for output-list
...
% SZS output end Proof for output-list
% ------------------------------
% Version: Vampire 4.4.0 (commit 910d806b on 2019-09-08 13:31:29 +0200)
% Termination reason: Refutation

% Memory used [KB]: 5245
% Time elapsed: 0.082 s
% ------------------------------
% ------------------------------
% Success in time 0.591 s

How can I debug it?

examples.tar.gz

vampire_z3 SMT mode fails to find sat on a simple example

Consider the following SMT-LIB input:

(set-logic AUFNIRA)
(set-option :print-success false)
(declare-fun g_tt_0 () Int)
(define-fun |def_inv_0| () Bool (and (>= g_tt_0 0) (<= g_tt_0 10)))
(assert (! |def_inv_0| :named |inv0|))
(assert (! (= g_tt_0 8) :named goal))
(check-sat)
(exit)

vampire_z3 fails to find quickly that it is satisfiable, while z3 by itself does almost instantaneously. In this case, it has been called by the following script:

#!/bin/bash
ulimit -t 3
LD_LIBRARY_PATH=$HOME/lib:$LD_LIBRARY_PATH $HOME/bin/vampire_z3-4.4.0 --mode smtcomp $1

stack overflow at Lib/Int.cpp:48

Hi, fo this formula
overflow.txt

vampire 61a2a24

^[[OASAN:SIGSEGV
=================================================================
==131324==ERROR: AddressSanitizer: stack-overflow on address 0x7ffefbbfec38 (pc 0x7f6b511d3bb9 bp 0x7ffefbbff4f0 sp 0x7ffefbbfec40 T0)
    #0 0x7f6b511d3bb8  (/usr/lib/x86_64-linux-gnu/libasan.so.2+0x5fbb8)
    #1 0x7f6b511d5aae in __interceptor_vsprintf (/usr/lib/x86_64-linux-gnu/libasan.so.2+0x61aae)
    #2 0x7f6b511d5d09 in sprintf (/usr/lib/x86_64-linux-gnu/libasan.so.2+0x61d09)
    #3 0x5ff959 in Lib::Int::toString[abi:cxx11](int) Lib/Int.cpp:48
    #4 0x960eab in Kernel::Signature::key(std::__cxx11::basic_string<char, std::char_traits<char>, Lib::STLAllocator<char> > const&, int) Kernel/Signature.cpp:813
    #5 0x95e013 in Kernel::Signature::addPredicate(std::__cxx11::basic_string<char, std::char_traits<char>, Lib::STLAllocator<char> > const&, unsigned int, bool&) Kernel/Signature.cpp:666
    #6 0x95fcd7 in Kernel::Signature::addFreshPredicate(unsigned int, char const*, char const*) Kernel/Signature.cpp:755
    #7 0x15f6403 in FOOLElimination::introduceFreshSymbol(bool, char const*, Lib::Stack<unsigned int>, unsigned int) Shell/FOOLElimination.cpp:941
    #8 0x15f1d4a in FOOLElimination::process(Kernel::Term*, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:515
    #9 0x15f0a98 in FOOLElimination::process(Kernel::TermList, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:381
    #10 0x15f2813 in FOOLElimination::process(Kernel::Term*, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:631
    #11 0x15f0a98 in FOOLElimination::process(Kernel::TermList, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:381
    #12 0x15f309b in FOOLElimination::process(Kernel::Term*, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:681
    #13 0x15f0a98 in FOOLElimination::process(Kernel::TermList, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:381
    #14 0x15f309b in FOOLElimination::process(Kernel::Term*, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:681
    #15 0x15f0a98 in FOOLElimination::process(Kernel::TermList, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:381
    #16 0x15f309b in FOOLElimination::process(Kernel::Term*, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:681
    #17 0x15f0a98 in FOOLElimination::process(Kernel::TermList, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:381
    #18 0x15f309b in FOOLElimination::process(Kernel::Term*, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:681
    #19 0x15f0a98 in FOOLElimination::process(Kernel::TermList, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:381
    #20 0x15f309b in FOOLElimination::process(Kernel::Term*, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:681
    #21 0x15f0a98 in FOOLElimination::process(Kernel::TermList, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:381
    #22 0x15f309b in FOOLElimination::process(Kernel::Term*, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:681
    #23 0x15f0a98 in FOOLElimination::process(Kernel::TermList, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:381
    #24 0x15f309b in FOOLElimination::process(Kernel::Term*, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:681
    #25 0x15f0a98 in FOOLElimination::process(Kernel::TermList, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:381
    #26 0x15f309b in FOOLElimination::process(Kernel::Term*, bool, Kernel::TermList&, Kernel::Formula*&) Shell/FOOLElimination.cpp:681

Bug in DP part of splitting

The SAT solver produces a model that does not satisfy all clauses when using the congruence closure DP.

Notes

model minimisation is all (so not issue with sco minimisation)
SAT solver used is default i.e. vampire
Check whether unsatisfied clauses originate from DP

Branch: total_model_option
Commit: 126d8ac

Options:
~/git/vampire/vampire_dbg --decode lrs+10_1024_bd=off:br=off:bsr=unit_only:drc=off:fde=none:flr=on:gs=on:gsp=input_only:igrp=4000:igrpq=2.0:igrr=2/1:igwr=on:lcm=predicate:sd=4:sfv=off:sp=reverse_arity:ss=axioms:sscc=on:sser=off:ssfp=1000:ssfq=1.0:ssnc=all:stl=300:tbsr=off:tgawr=1/32:tipr=off:updr=off:urr=on_1800 --saturation_algorithm discount --time_statistics on Problems/SEU/SEU355+2

Output:
Condition in file Test/CheckedSatSolver.cpp, line 80 violated:
false
Value of "reported satisfiable assignment which does not satisfy all clauses" is: reported satisfiable assignment which does not satisfy all clauses
Value of *cl is: ~742 | 738 | ~740
----- stack dump -----
Control points passed: 2373013135
last control point:
-SATClause::toString (2373013135)
main
vampireMode()
doProving()
ProvingHelper::runVampireSaturation
ProvingHelper::runVampireSaturationImpl
MainLoop::run
SaturationAlgorithm::runImpl
SaturationAlgorithm::doOneAlgorithmStep
SaturationAlgorithm::doUnprocessedLoop
SaturationAlgorithm::onAllProcessed
SSplitter::onAllProcessed
SSplittingBranchSelector::addSatClauses
SSplittingBranchSelector::processDPConflicts
CheckedSatSolver::ensureChecked
CheckedSatSolver::doCheck

InterpretedNormalizer crashes when called for the second time, after some axioms were added (-tha on) and fool has not been eliminated (--newcnf on)

To reproduce, use debug mode and the following smtlib problem:

(set-logic LIA)
(define-fun xxx ((a (Int)) (b (Int))) (Int) (+ a b))
(define-fun yyy ((s (Int)) (t (Int))) Bool true )
(check-sat)
(exit)

Run "--input_syntax smtlib2 --newcnf on -tha on"

This will happen:

vampireMode()
doProving()
getPreprocessedProblem
Preprocess::preprocess
InterpretedNormalizer::apply(Problem&)
InterpretedNormalizer::apply(UnitList*& units)
LocalFormulaUnitTransformer::transform(FormulaUnit*)
FTFormulaUnitTransformer::transform(Formula*)
FormulaTransformar::transform
FormulaTransformer::apply(Formula*)
InterpretedNormalizer::NFormulaTransformer::applyLiteral
InterpretedNormalizer::NLiteralTransformer::apply
TermTransformer::transform(Literal* lit)
TermTransformer::transform(Term* term)
TermTransformer::transformSpecial(Term* term)
TermTransformer::transform(Formula* f)
FormulaTransformar::transform
FormulaTransformer::apply(Formula*)
TermTransformingFormulaTransformer::applyLiteral
TermTransformer::transform(Literal* lit)
TermTransformer::transform(Term* term)
System::handleSignal

The best top level entry point to study this is probably Preprocess::preprocess. Seems as if the first call to InterpretedNormalizer makes the formulas corrupt and the second call crashes. Why is the addition of theory axioms in between essential for the crash is for now a mystery.

Unnecessary Superposition Inferences?

The following code from EqHelper returns subterms suitable for rewriting by superposition

TermIterator EqHelper::getRewritableSubtermIterator(Literal* lit, const Ordering& ord)
{
  CALL("EqHelper::getRewritableSubtermIterator");

//  if (lit->isEquality()) {
//    if (lit->isNegative()) {
//      return TermIterator::getEmpty();
//    }
  if (lit->isEquality() && lit->isPositive()) {
    TermList sel;
    switch(ord.getEqualityArgumentOrder(lit)) {
    case Ordering::INCOMPARABLE:
      {
	NonVariableIterator nvi(lit);
	return getUniquePersistentIteratorFromPtr(&nvi);
      }
    case Ordering::EQUAL:
    case Ordering::GREATER:
    case Ordering::GREATER_EQ:
      sel=*lit->nthArgument(0);
      break;
    case Ordering::LESS:
    case Ordering::LESS_EQ:
      sel=*lit->nthArgument(1);
      break;
#if VDEBUG
    default:
      ASSERTION_VIOLATION;
#endif
    }
    if (!sel.isTerm()) {
      return TermIterator::getEmpty();
    }
    return getUniquePersistentIterator(getConcatenatedIterator(getSingletonIterator(sel),
							       vi(new NonVariableIterator(sel.term()))));
  }

  NonVariableIterator nvi(lit);
  return getUniquePersistentIteratorFromPtr(&nvi);
}

As can be seen, if the literal is a negative equality, we return subterms of both the left and right hand side. Theoretically, even with negative equalities, we only need to superpose onto the larger side (see Handbook of Automated Reasoning). Therefore, it seems as though we are returning unnecessary subterms and carrying out unnecessary inferences?

Remove need for ignore missing

We should modify the CASC code files to remove the options that cause errors without ignore missing being on.

Suggestion: write a script to scan the files and remove options not used in Shell/Options

Fiasco of your code.

This instruction fails with Floating point exception:

162│   inline Entry* firstEntryForCode(unsigned code) const
163│   {
164├───> return _entries + (code % _capacity);
165│   } // Map::firstEntryForCode
166│

code=3223832701
called from here:

126│     Entry* entry;
127├───> for (entry = firstEntryForCode(code); entry->occupied(); entry = nextEntry(entry)) {
128│       if (entry->code == code && Hash::equals(entry->key,key)) {
129│         found = entry->value;
130│         return true;
131│       }
132│     }

(gdb) bt
#0  0x00000000005fb2de in Lib::Map<Lib::Vector<unsigned int>*, Kernel::OperatorType*, Lib::PointerDereferencingHash>::firstEntryForCode (this=0x14b0308 <Kernel::OperatorType
::_operatorTypes>, code=3223832701) at ./Lib/Map.hpp:164
#1  0x00000000005f994f in Lib::Map<Lib::Vector<unsigned int>*, Kernel::OperatorType*, Lib::PointerDereferencingHash>::find (this=0x14b0308 <Kernel::OperatorType::_operatorTy
pes>, key=0x802667638, found=@0x7fffffffd500: 0x802667638) at ./Lib/Map.hpp:127
#2  0x00000000005f70e0 in Kernel::OperatorType::getTypeFromKey (key=0x802667638) at Kernel/Sorts.cpp:309
#3  0x00000000005e8606 in Kernel::OperatorType::getPredicateType (arity=2, sorts=0x0) at Kernel/Sorts.hpp:256
#4  0x00000000005dac28 in Kernel::Signature::Signature (this=0x802665d48) at Kernel/Signature.cpp:221
#5  0x00000000004344f3 in Lib::Environment::Environment (this=0x14b4b20 <Lib::env>) at Lib/Environment.cpp:67
#6  0x0000000000e4a777 in __cxx_global_var_init.12(void) () at Global.cpp:62
#7  0x0000000000e4a7ed in _GLOBAL__sub_I_Global.cpp () at /usr/include/c++/v1/__string:208
#8  0x0000000000e54e62 in __do_global_ctors_aux ()
#9  0x000000000040469e in _init ()
#10 0x00007fffffffdce0 in ?? ()
#11 0x00000008014636ba in objlist_call_init (list=<optimized out>, lockstate=<optimized out>) at /usr/src/libexec/rtld-elf/rtld.c:2647
#12 0x00000008014626ac in _rtld (sp=<optimized out>, exit_proc=0x7fffffffe7a0, objp=0x7fffffffe7a8) at /usr/src/libexec/rtld-elf/rtld.c:770
#13 0x00000008014606f9 in .rtld_start () at /usr/src/libexec/rtld-elf/amd64/rtld_start.S:39
#14 0x0000000000000000 in ?? ()

You access static variables from the static context which isn't allowed in C++.
This results in a static constructor fiasco.

Crashing when free variable is synonymous to a bound one inside the same formula

Normally, free variables are implicitly quantified at top level. However, when a free variable is synonymous to a bound one inside the same formula, Vampire crashes. An example to reproduce:

fof(1, axiom, (![X]: (X = i)) | (X = i)).

gives assertion violation in TPTP::sortOf.

Source of Non-determinism in Vampire

The following code occurs in TautologyDeletionISE:

int TautologyDeletionISE::compare(Literal* l1,Literal* l2)
{
  CALL("TautologyDeletionISE::compare");

  unsigned f1 = l1->functor();
  unsigned f2 = l2->functor();
  if (f1 < f2) {
    return -1;
  }
  if (f1 > f2) {
    return 1;
  }
  TermList* ts1 = l1->args();
  TermList* ts2 = l2->args();
  while (! ts1->isEmpty()) {
    unsigned c1 = ts1->content();
    unsigned c2 = ts2->content();
    if (c1 < c2) {
      return -1;
    }
    if (c1 > c2) {
      return 1;
    }
    ts1 = ts1->next();
    ts2 = ts2->next();
  }
  return 0;
} // Tautology::compare

Because it compares the raw contents of terms it is non-deterministic. Because TautologyDeletionISE makes many calls to Random::getInteger this non-determinism can and does lead to non-determinism in other parts of the code.

A Problem with the Universe

I am using Vampire (4.2.2) besides other theorem provers to evaluate the performance in a custom fragment of First-Order Logic (and some Description Logics).

I have a problem with Vampire (or possibly with TPTP format). I convert the actual problem to the simplest form that I can imagine.

I know that the following non-entailment is the case when we do not make any assumptions on the universe of discourse (If it it is possible that the universe of discourse is the empty set, then we can not make the conclusion):

Similarly:

However, when I try these examples in Vampire, I don't get the expected results. For example (for the second example):

Input file:

fof(abc,conjecture,( ? [A] : (x(A) | ~x(A)) )).

The output:

% Refutation found. Thanks to Tanya!
% SZS status Theorem for x
% SZS output start Proof for x

? [X0] : (~x(X0) | x(X0)) [input]

~? [X0] : (~x(X0) | x(X0)) [negated conjecture 1]

! [X0] : (x(X0) & ~x(X0)) [ennf transformation 2]

~x(X0) [cnf transformation 3]

x(X0) [cnf transformation 3]

$false [subsumption resolution 4,5]
% SZS output end Proof for x
% ------------------------------
% Version: Vampire 4.2.2 (commit e1949dd on 2017-12-14 18:39:21 +0000)
% Termination reason: Refutation

% Memory used [KB]: 4733
% Time elapsed: 0.018 s
% ------------------------------
% ------------------------------

Refutation is found for the negated conjecture. This means that we can safely make such a conclusion.

I believe that the problem lies in the "cnf transformation" steps: Vampire assumes that the universe of discourse is not empty. Thus, there is a problem with the universe 😋.

Am I doing it wrong? If I am right, is it possible to eliminate such an assumption?

This might be a TPTP-related question. However I couldn't find any TPTP-related solution either.

Note: I know the following way of fixing the problem, but, I still wonder if there is a more elegant solution. More importantly, I need to implement the problems in an efficient way.

fof(abc,conjecture,(? [A] : (in_universe(A) & (x(A) | ~x(A))) )).

.smt2 triggers assertion violation under vampire-dbg

Hello Vampire dev team,

it seems like under vampire-dbg build, .smt2 problems always trigger an assertion violation:

Condition in file Kernel/InterpretedLiteralEvaluator.cpp, line 122 violated:
!error
----- stack dump -----
Version : Vampire 4.3.0 (commit e96a41d7 on 2019-06-01 22:02:36 +0100)
Control points passed: 153654
last control point:
                  -InterpretedLiteralEvaluator::tryEvaluateFunc (153654)

and at the source location:

ASS(!error); //we want to be informed of evaluation failures in debug mode

while vampire-rel can handle .smt2 problems properly, I wonder if this assertion violation is intended outcome?

thanks in advance

Assertion Violation in Z3Interfacing

Condition in file SAT/Z3Interfacing.cpp, line 245 violated:
false
Value of assignment is: (= ((as const (Array 8 10)) |10!val!0|)
   (store ((as const (Array 8 10)) |10!val!2|) |8!val!0| |10!val!0|))
----- stack dump -----
Version : Vampire 4.5.1 (commit 5ef3f990 on 2020-09-10 10:33:39 +0100)
Control points passed: 1049099
last control point:
                 -DHSet::find (1049099)
main
 vampireMode()
  doProving()
   ProvingHelper::runVampireSaturation
    ProvingHelper::runVampireSaturationImpl
     MainLoop::run
      SaturationAlgorithm::runImpl
       SaturationAlgorithm::doOneAlgorithmStep
        SaturationAlgorithm::doUnprocessedLoop
         SaturationAlgorithm::onAllProcessed
          Splitter::onAllProcessed
           SplittingBranchSelector::recomputeModel
            SplittingBranchSelector::getSolverAssimentConsideringCCModel
             MinimizingSolver::getAssignment
              MinimizingSolver::updateAssignment
               MinimizingSolver::processInnerAssignmentChanges
                Z3Interfacing::getAssignment
----- end of stack dump -----

Commands to reproduce the bug:

$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree176.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/german/german46.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/f```mf-cav2013/agreement/agree88.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree168.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree152.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/german/german85.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree120.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree128.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree184.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree56.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/german/german111.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree192.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree144.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/german/german124.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree64.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree332.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree112.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/german/german33.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree160.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/german/german72.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/german/german98.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree48.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree324.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/agreement/agree450.smt2
$vampire -sas z3 --input_syntax smtlib2 $smtlib/AUFDTLIA/20172804-Barrett/fmf-cav2013/german/german7.smt2

I currently don't have time to look into that, so I'll leave it as an issue for now and revisit it later. Maybe someone has an idea what this could come from.

Vampire on Cygwin: compilation and runtime errors

I have tried to compile Vampire (master revisition 3893 from a few weeks ago) on Cygwin, so far without success. The compilation itself failed in a few places, due to undefined symbols in Unix headers (e.g. the "kill" function). It wasn't too hard to make things compile by changing two or three files, but when I tried to run "vampire_rel__.exe", without arguments, I immediately got this error:

Floating point exception (core dumped)

For us Isabelle developers, it is crucial to make all the binary tools we include with Isabelle available on all three main platforms (Linux, Mac, and Windows). I would be grateful for any help.

Inline distinct

TPTP has the $distinct declaration to assert that two constants are distinct. If there are a few distinct constants we can 'inline' these rather than use the inbuilt support for distinct.

To do this I suggest using the current support for distinctGroups in Signature to 'expand' groups after running Shell/DistinctProcessor i.e. a new preprocessing task Shell/DistinctExpander where 'small' groups are removed from Signature and the appropriate disjointness clauses added to the problem.

For an example see Problems/SYO/SYO561_1.p

Array(Int,Int) not detected as infinite sort

I'm filing the bug for documentation purposes (and to add it into regression tests at some point) - the bug is fixed in the wip-array-instantiation branch. Consider the following smtlib problem trying to prove the existence of two distinct arrays of type Array(Int,Int):

(set-logic ALIA)
(assert (not (exists ((a (Array Int Int)) (b (Array Int Int)))
                       (distinct a b))))
(check-sat)

We do not detect that Array(Int,Int) has an infinite domain which leads FMB to produce a spurious single element model (the arrays store(X,0,0) and store(X,0,1) always have a different interpretation due to extensionality -- there cannot be a model of size 1):

% fmb+10_1_av=off:bce=on:fmbes=contour:fmbsr=1.4:fde=unused:updr=off_900 on exists_two_arrays
TRYING [1]
Finite Model Found!
% SZS status Satisfiable for exists_two_arrays
% SZS output start FiniteModel for exists_two_arrays
tff(declare_$array($int,$int),type,$array($int,$int):$tType).
tff(declare_$array($int,$int)1,type,fmb_$array($int,$int)_1:$array($int,$int)).
tff(finite_domain,axiom,
      ! [X:$array($int,$int)] : (
         X = fmb_$array($int,$int)_1
      ) ).

% SZS output end FiniteModel for exists_two_arrays

The error is fixed by scanning the array arguments for problem properties as well.

Latex output leads to aborted signal SIGSEGV

If I run the following:
vampire --latex_output proof.tex test.p

Where test.p is simply:

fof(tree_B, hypothesis, ? [P0, G1, C2, L3] :
( p1(P0,play01)
  & ( p21(P0,G1) )
  & ( p20(P0,C2) )
  & ( p23(P0,L3) ) ) ).

fof(tree_B, conjecture, ? [P0, G1, C2, L3] :
( p1(P0,play01)
  & ( p21(P0,G1) )
  & ( p20(P0,C2) )
  & ( p23(P0,L3) ) ) ).

I get the following output:

...
% SZS output end Proof for test
39779 Aborted by signal SIGSEGV on test.p
% ------------------------------
% Version: Vampire 4.4.0 (commit 51cbd2f on 2019-08-29 00:55:07 +0200)
% Termination reason: Refutation

% Memory used [KB]: 4861
% Time elapsed: 0.0000 s
% ------------------------------
% ------------------------------

and proof.tex is empty.

Interestingly enough, if I use this TPTP file instead (changing L3 to C2 in the last line of each fof in the previous TPTP file):

fof(tree_B, hypothesis, ? [P0, G1, C2, L3] :
( p1(P0,play01)
  & ( p21(P0,G1) )
  & ( p20(P0,C2) )
  & ( p23(P0,C2) ) ) ).

fof(tree_B, conjecture, ? [P0, G1, C2, L3] :
( p1(P0,play01)
  & ( p21(P0,G1) )
  & ( p20(P0,C2) )
  & ( p23(P0,C2) ) ) ).

it is successful in outputting a Latex file.

Help for options

It would be good to make minimal change to Options so that '--show_options on' also prints a description of the options.

Suggestion:

Have a struct that contains long name, short name, description and an experimental flag (to indicate the option is experimental)
replace optionNames, shortNames and shortNameIndexes with an array of these structs
set and setShort would search this array
output would make use of this array to output nicely formatted help
output (via show_options) should exit after printing options
extend show_options so it only optionally prints experimental options

Then:

merge currently values for short names into this array
write option descriptions (see Google doc file to start)

Assertion violation at FMB/FiniteModelBuilder.cpp, line 886 (fmb)

(set-logic UF)
(declare-sort S0 0)
(assert (or (forall ((q9 S0) (q10 S0)) (not (distinct q10 q9 q9))) (exists ((q9 S0) (q10 S0)) (not (distinct q9 q9 q10 q10 q9)))))

vampire 61a2a24

Condition (*csig)[var1] == (*csig)[var2] in file FMB/FiniteModelBuilder.cpp, line 886 was violated, as:
(*csig)[var1] == 2
(*csig)[var2] == 1
----- stack dump -----
Version : Vampire 4.5.1 (commit 8ca2407 on 2020-07-30 19:28:11 +0800)
Control points passed: 118313
last control point:
       -DArray::operator[] (118313)
main
 vampireMode()
  doProving()
   ProvingHelper::runVampireSaturation
    ProvingHelper::runVampireSaturationImpl
     MainLoop::run
      FiniteModelBuilder::init
----- end of stack dump -----

ASAN stack-use-after-scope at Kernel/Term.hpp:98

Hi, for the following formula

(set-logic LRA)
(assert (distinct (distinct true true true true true true true (< 4229.0 0.0 1067292.0 0.0)) true true true true true true))
(check-sat)

ASAN detects a stack-use-after-scope issue in vampire_dbg_z3 (commit 2a17f46)
I use z3 4.8.5 for building vampire.

==56229==ERROR: AddressSanitizer: stack-use-after-scope on address 0x7ffeef04a7a0 at pc 0x000000537d71 bp 0x7ffeef04a2a0 sp 0x7ffeef04a290
READ of size 8 at 0x7ffeef04a7a0 thread T0
    #0 0x537d70 in Kernel::TermList::tag() const Kernel/Term.hpp:98
    #1 0x56000d in Kernel::TermList::isEmpty() const Kernel/Term.hpp:101
    #2 0x746f03 in Kernel::TermTransformer::transform(Kernel::Term*) Kernel/TermTransformer.cpp:59
    #3 0x7480ca in Kernel::TermTransformer::transform(Kernel::Literal*) Kernel/TermTransformer.cpp:149
    #4 0xbba5fb in Shell::InterpretedNormalizer::NLiteralTransformer::apply(Kernel::Literal*, bool&, Kernel::Literal*&, bool&) Shell/Interprete
dNormalizer.cpp:273
    #5 0xbbbb2e in Shell::InterpretedNormalizer::NFormulaTransformer::applyLiteral(Kernel::Formula*) Shell/InterpretedNormalizer.cpp:427
    #6 0x5834ac in Kernel::FormulaTransformer::apply(Kernel::Formula*) Kernel/FormulaTransformer.cpp:59
    #7 0x584a16 in Kernel::FormulaTransformer::applyJunction(Kernel::Formula*) Kernel/FormulaTransformer.cpp:168
    #8 0x58a380 in Kernel::FormulaTransformer::applyAnd(Kernel::Formula*) Kernel/FormulaTransformer.hpp:65
    #9 0x58354a in Kernel::FormulaTransformer::apply(Kernel::Formula*) Kernel/FormulaTransformer.cpp:62
    #10 0x58323a in Kernel::FormulaTransformer::transform(Kernel::Formula*) Kernel/FormulaTransformer.cpp:42
    #11 0xbbebfd in Kernel::FTFormulaUnitTransformer<Shell::InterpretedNormalizer::NFormulaTransformer>::transform(Kernel::Formula*) Kernel/For
mulaTransformer.hpp:176
    #12 0x5869e0 in Kernel::LocalFormulaUnitTransformer::transform(Kernel::FormulaUnit*) Kernel/FormulaTransformer.cpp:367
    #13 0xbb5f20 in Shell::InterpretedNormalizer::apply(Lib::List<Kernel::Unit*>*&) Shell/InterpretedNormalizer.cpp:498
    #14 0xbb5c0d in Shell::InterpretedNormalizer::apply(Kernel::Problem&) Shell/InterpretedNormalizer.cpp:462
    #15 0xdf31c0 in Shell::Preprocess::preprocess(Kernel::Problem&) Shell/Preprocess.cpp:205
    #16 0x13d0286 in getPreprocessedProblem() /home/rainoftime/Work/tofuzz/vampire/vampire.cpp:169
    #17 0x13d0798 in doProving() /home/rainoftime/Work/tofuzz/vampire/vampire.cpp:209
    #18 0x13d4756 in vampireMode() /home/rainoftime/Work/tofuzz/vampire/vampire.cpp:607
    #19 0x13d72f1 in main /home/rainoftime/Work/tofuzz/vampire/vampire.cpp:889
    #20 0x7f96299c782f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2082f)

Erroneous code in DHMultiset

The following code is to be found in DHMultiset:

inline
Val next(unsigned& multiplicity)
{
  CALL("DHMultiset::SetIterator::next/1");
  ASS_NEQ(_next, _afterLast);

  **multiplicity=_next->multiplicity;**
  return (_next++)->_val;
}

The erroneous line is in bold. It should be _next->_info.multiplicity;

Why the code compiles without this fix is not clear to me.

Condition in file FMB/SortInference.cpp, line 734 violated

./vampire_dbg_master_4779 --input_syntax smtlib2 --decode fmb+10_1_av=off:fmbes=contour:fmbsr=1.5:ile=on:updr=off_28 UF/sledgehammer/TwoSquares/uf.794486.smt2
Condition in file FMB/SortInference.cpp, line 734 violated:
createNew
----- stack dump -----
Version : Vampire 4.5.1 (commit 77e82df on 2020-07-31 17:57:13 +0200)
Control points passed: 21525231
last control point:
-DHMap::find/2 (21525231)
main
vampireMode()
doProving()
ProvingHelper::runVampireSaturation
ProvingHelper::runVampireSaturationImpl
MainLoop::run
FiniteModelBuilder::init
SortInference::doInference
SortInference::getDistinctSort
----- end of stack dump -----

What is the latest stable release?

I recently started maintaining the Vampire package for Arch Linux in the Arch User Repository (AUR). For now, I packaged Vampire 4.2.2, because this is the latest release with an actual version number to it 🙂.

Still, I’d like to know whether that’s the most recent stable Vampire release there is? That is, the one I should be using in productive use, for instance, when doing research experiments or benchmarks with Vampire.

I’ve seen the ijcar2018-data tag, which is marked as a prerelease version, but I’m not so sure about the smtcomp2018 tag. If it’s stable, could you give it an actual version number (4.2.3, 4.3.0, or whatever you prefer)? If not, could you instead flag it as a prerelease tag for clarity? Thanks 🙂.

The readme mentions an ltb_mode script but it's not in /scripts

Does the ltb_mode script still exist? Or is there another way to load a .tptp or .tff file and ask multiple queries without reloading?

signed integer overflow on QF_UFLRA instance (Random.cpp:67)

Hi, for the following formula, vampire d016bfb throws an overflow error

Lib/Random.cpp:67:22: runtime error: signed integer overflow: 2147483647 + 1 cannot be represented in type 'int'
Lib/Int.hpp:201:21: runtime error: signed integer overflow: 42230701 * 200000 cannot be represented in type 'int'
% Refutation found. Thanks to Tanya!
% SZS status Unsatisfiable for open_input-15_0_noinc_7_38_QF_UFLRA
...

(set-logic QF_UFLRA)
(declare-const v0 Bool)
(declare-const r4 Real)
(declare-const r7 Real)
(declare-const r10 Real)
(declare-const r12 Real)
(declare-const r14 Real)
(declare-const r15 Real)
(declare-sort S0 0)
(declare-const v1 Bool)
(declare-const r16 Real)
(assert (=> (<= 72499.0 72499.0 70.195 72499.0 0.07621) (<= 72499.0 72499.0 70.195 72499.0 0.07621)))
(declare-const v2 Bool)
(declare-const r17 Real)
(assert (=> (< 0.84461402 925.464585) (distinct v1 v0)))
(declare-const r18 Real)
(assert (<= 72499.0 72499.0 70.195 72499.0 0.07621))
(declare-const S0-0 S0)
(declare-const v3 Bool)
(declare-const v4 Bool)
(assert (=> (<= 72499.0 72499.0 70.195 72499.0 0.07621) (<= 72499.0 72499.0 70.195 72499.0 0.07621)))
(declare-const v5 Bool)
(declare-const v6 Bool)
(declare-const v7 Bool)
(assert (xor (< 0.84461402 925.464585) (xor (not v0) (<= 72499.0 72499.0 70.195 72499.0 0.07621) (or v1 v0 (< 0.84461402 925.464585) (= 925.464585 70.195 (- 0.84461402) (- 0.84461402) 2037897.0)) (=> (<= 72499.0 72499.0 70.195 72499.0 0.07621) (<= 72499.0 72499.0 70.195 72499.0 0.07621))) v2 v2 v3 (< 338.0 (- 0.84461402)) (=> (< 0.84461402 925.464585) (distinct v1 v0))))
(declare-const v8 Bool)
(assert (distinct (=> (< 0.84461402 925.464585) (distinct v1 v0)) v4 (xor v0 v0 v0 v0 v0 v0) (xor (< 0.84461402 925.464585) (xor (not v0) (<= 72499.0 72499.0 70.195 72499.0 0.07621) (or v1 v0 (< 0.84461402 925.464585) (= 925.464585 70.195 (- 0.84461402) (- 0.84461402) 2037897.0)) (=> (<= 72499.0 72499.0 70.195 72499.0 0.07621) (<= 72499.0 72499.0 70.195 72499.0 0.07621))) v2 v2 v3 (< 338.0 (- 0.84461402)) (=> (< 0.84461402 925.464585) (distinct v1 v0))) v8 (< 338.0 (- 0.84461402)) (not v0) (<= 72499.0 72499.0 70.195 72499.0 0.07621) v1))
(declare-const v9 Bool)
(assert (distinct (>= (- 0.84461402) (- 0.84461402) 2037897.0) (= 925.464585 70.195 (- 0.84461402) (- 0.84461402) 2037897.0) (distinct (distinct (=> (< 0.84461402 925.464585) (distinct v1 v0)) v4 (xor v0 v0 v0 v0 v0 v0) (xor (< 0.84461402 925.464585) (xor (not v0) (<= 72499.0 72499.0 70.195 72499.0 0.07621) (or v1 v0 (< 0.84461402 925.464585) (= 925.464585 70.195 (- 0.84461402) (- 0.84461402) 2037897.0)) (=> (<= 72499.0 72499.0 70.195 72499.0 0.07621) (<= 72499.0 72499.0 70.195 72499.0 0.07621))) v2 v2 v3 (< 338.0 (- 0.84461402)) (=> (< 0.84461402 925.464585) (distinct v1 v0))) v8 (< 338.0 (- 0.84461402)) (not v0) (<= 72499.0 72499.0 70.195 72499.0 0.07621) v1) (distinct S0-0 S0-0 S0-0 S0-0 S0-0))))
(declare-const v10 Bool)
(declare-const v11 Bool)
(assert (or (distinct v1 v0) v11 (not v0) (distinct S0-0 S0-0 S0-0 S0-0 S0-0) (= S0-0 S0-0 S0-0 S0-0) v8 (xor (< 0.84461402 925.464585) (xor (not v0) (<= 72499.0 72499.0 70.195 72499.0 0.07621) (or v1 v0 (< 0.84461402 925.464585) (= 925.464585 70.195 (- 0.84461402) (- 0.84461402) 2037897.0)) (=> (<= 72499.0 72499.0 70.195 72499.0 0.07621) (<= 72499.0 72499.0 70.195 72499.0 0.07621))) v2 v2 v3 (< 338.0 (- 0.84461402)) (=> (< 0.84461402 925.464585) (distinct v1 v0)))))
(declare-sort S1 0)
(assert (<= (- (- (- 0.84461402) 77755736368.0 9.220 (/ 70.195 2037897.0))) 925.464585 0.84461402 66.0))
(declare-const S0-1 S0)
(assert (=> (distinct (>= (- 0.84461402) (- 0.84461402) 2037897.0) (= 925.464585 70.195 (- 0.84461402) (- 0.84461402) 2037897.0) (distinct (distinct (=> (< 0.84461402 925.464585) (distinct v1 v0)) v4 (xor v0 v0 v0 v0 v0 v0) (xor (< 0.84461402 925.464585) (xor (not v0) (<= 72499.0 72499.0 70.195 72499.0 0.07621) (or v1 v0 (< 0.84461402 925.464585) (= 925.464585 70.195 (- 0.84461402) (- 0.84461402) 2037897.0)) (=> (<= 72499.0 72499.0 70.195 72499.0 0.07621) (<= 72499.0 72499.0 70.195 72499.0 0.07621))) v2 v2 v3 (< 338.0 (- 0.84461402)) (=> (< 0.84461402 925.464585) (distinct v1 v0))) v8 (< 338.0 (- 0.84461402)) (not v0) (<= 72499.0 72499.0 70.195 72499.0 0.07621) v1) (distinct S0-0 S0-0 S0-0 S0-0 S0-0))) (or (distinct v1 v0) v11 (not v0) (distinct S0-0 S0-0 S0-0 S0-0 S0-0) (= S0-0 S0-0 S0-0 S0-0) v8 (xor (< 0.84461402 925.464585) (xor (not v0) (<= 72499.0 72499.0 70.195 72499.0 0.07621) (or v1 v0 (< 0.84461402 925.464585) (= 925.464585 70.195 (- 0.84461402) (- 0.84461402) 2037897.0)) (=> (<= 72499.0 72499.0 70.195 72499.0 0.07621) (<= 72499.0 72499.0 70.195 72499.0 0.07621))) v2 v2 v3 (< 338.0 (- 0.84461402)) (=> (< 0.84461402 925.464585) (distinct v1 v0))))))
(check-sat)

retractAllAssumptions buggy in TWLSolver

See the unit test satSolver procedure testSATSolverInterface in tSATsolver.cpp

(the solver incorrectly claims to be UNSAT after the assumption that caused it has been retracted).

Finite model builder does not cope with updr removing functions / constants

On the following problem

when run as in

./vampire -sa fmb

finite-model-builder's preprocessing removes all the function symbols while removing predicates (updr). Then the followup code tries to query the signature and finds it empty:

Condition in file ./Lib/DHMap.hpp, line 244 violated:
e
----- stack dump -----
Version : Vampire 4.3.0 (commit 7f955da on 2018-08-16 17:06:37 +0100)
Control points passed: 36292
last control point:
-DHMap::findEntry (36292)
main
vampireMode()
doProving()
ProvingHelper::runVampireSaturation
ProvingHelper::runVampireSaturationImpl
MainLoop::run
FiniteModelBuilder::init
SortInference::doInference

large proof for simple resolution

Instead of reporting a proof of contradiction that should take just a few steps, it uses thousands with a massive avatar_sat_refutation step at the end .
The basic proof is about the rule "people can't have an average work week more than 70.0 hours" and uses three statements -

tff(f325,axiom,(
! [X327,X130 : $real] : (s__instance(X327,s__Human) => (s__avgWorkHours__2Re(X327,X130) => $less(X130,70.0)))),
file('/home/apease/.sigmakee/KBs/SUMO.tff',kb_SUMO_325)).

tff(f743,axiom,(
s__avgWorkHours__2Re(s__Human0,80.0)),
file('/home/apease/.sigmakee/KBs/SUMO.tff',kb_SUMO_743)).

tff(f1297,axiom,(
s__instance(s__Human0,s__Human)),
file('/home/apease/.sigmakee/KBs/SUMO.tff',kb_SUMO_1297)).

I executed with -

./vampire --mode casc -t 300 SUMO.tff

//vampire --version
Vampire 4.2.2 (commit 552c234 on 2018-07-02 14:53:33 +0100)

So, Vampire is correctly finding the contradiction, but reporting a decidedly non-minimal proof. Have I just used the wrong mode or option?

infout-huge.zip
SUMO.zip

Compile error in Shell/TrivialPredicateRemover.cpp

I'm getting the following compile error with the latest master branch (commit d51e4de). It seems that Clause::isGoal() was removed at some point but it is still being used in TrivialPredicateRemover.

../Shell/TrivialPredicateRemover.cpp:71:14: error: no member named 'isGoal' in 'Kernel::Clause'
       !(cl->isGoal() && env.options->ignoreConjectureInPreprocessing())) {
         ~~  ^
1 error generated.

mode casc_sat with propositional formulas

the command below gives me a model that satisfies the problem. Can I ask for more than one model? Can I ask for all models of a propositional problem?

~/work/vampire/vampire --mode casc_sat  hamiltonian.p

sort error on TPTP file

I've done a git pull and make vampire_rel to get the latest as of Dec 2. I have a test file I've pared down to just one axiom

fof(kb_SUMO_3,axiom,(( ( ! [V__ARG,V__N,V__VAL,V__ARGS2] : ( s__instance(V__VAL,s__Quantity)) => ((s__ListFn__1Fn(V__ARGS2) & (V__VAL = s__ListOrderFn(s__ListFn__1Fn(V__ARGS2),V__ARG))) => s__greaterThan(V__VAL,V__N))) ) ))).

the file extension is .tptp

I run Vampire and get

$ /home/apease/workspace/vampire/vampire --mode casc -t 30 /home/apease/.sigmakee/KBs/temp-comb-small.tptp
% Exception at proof search level
Parsing Error on line 1
The sort $o of function argument s__ListFn__1Fn(X3) does not match the expected sort $i

Since no sorts are given in the axiom, since it's TPTP, and no built in types or functions are used, why does Vampire think the argument should be an integer? Very sorry if I'm missing something obvious.

Condition n < _size in file ./Lib/DArray.hpp, line 121 was violated (perhaps related to #136)

./vampire_dbg_master_4779 --input_syntax smtlib2 --decode fmb+10_1_av=off:fmbes=contour:fmbsr=1.5:ile=on:updr=off_28 UF/sledgehammer/Fundamental_Theorem_Algebra/uf.717973.smt2
Condition n < _size in file ./Lib/DArray.hpp, line 121 was violated, as:
n == 0
_size == 0
----- stack dump -----
Version : Vampire 4.5.1 (commit 95d6624 on 2020-08-04 09:51:33 +0100)
Control points passed: 957353
last control point:
+DArray::operator[] const (957353)
main
PortfolioMode::perform
PortfolioMode::searchForProof
PortfolioMode::performStrategy
PortfolioMode::runSchedule
ScheduleExecutor::run
ScheduleExecutor::spawn
PortfolioSliceExecutor::runSlice
PortfolioMode::runSlice
PortfolioMode::runSlice(Option&)
ProvingHelper::runVampire
ProvingHelper::runVampireSaturationImpl
MainLoop::run
FiniteModelBuilder::init
DArray::operator[] const
----- end of stack dump -----

Make TPTP Vampire proofs GDV compliant

In Geoff's 'Service Tools' he has a proof checker called GDV... I'm not sure what GDV stands for.

This currently doesn't work for Vampire as it doesn't output the SZS status of each inference as suggested here: http://tptp.cs.miami.edu/TPTP/QuickGuide/Derivations.html

In that situation GDV assumes that the SZS status is "thm", i.e., the inferred formula is a logical consequence of its parents, and tests that with Otter.

However, when we negate the conjecture the status should be cth (countertheorem). There may be other cases where the thm status is too strong.

It would be nice to include the SZS status in TPTP proofs to make them work with GDV... shouldn't take much work.

Vampire reports countersat for ∃a:array(int,int) ∃b:array(int,int). a ≠ b

Consider the following conjecture:

tff(c, conjecture, ?[A:$array($int,$int)] : ?[B:$array($int,$int)] : (~ (A=B) )).

It produces:

% SZS status CounterSatisfiable for vbug01
% # SZS output start Saturation.
tff(u6,negated_conjecture,
    (![X1 : $array($int,$int), X0 : $array($int,$int)] : ((X0 = X1)))).

% # SZS output end Saturation.
% ------------------------------
% Version: Vampire 4.2.2 (commit 6588b357 on 2018-07-19 13:39:17 +0200)

It should report unknown or unsat.

Assertion violation at ./Lib/DHMap.hpp:244 (fmb)

Hi, fo this formula

(set-logic LIA)
(declare-const i12 Int)
(declare-const v16 Bool)
(assert (=> v16 v16))

vampire 61a2a24

The problem is propositional so there are no sorts!
Condition in file ./Lib/DHMap.hpp, line 244 violated:
e
----- stack dump -----
Version : Vampire 4.5.1 (commit 8ca2407 on 2020-07-30 19:28:11 +0800)
Control points passed: 25306
last control point:
        -DHMap::findEntry (25306)
main
 vampireMode()

~  doProving()
   ProvingHelper::runVampireSaturation
    ProvingHelper::runVampireSaturationImpl
     MainLoop::run
      FiniteModelBuilder::init
       SortInference::doInference
----- end of stack dump -----

Pointer dependent term comparison makes SubstitutionTrees non-reproducible (at least across platforms).

vampire/Indexing/SubstitutionTree.hpp

Line 148 in 84497b7

res=(ld1.term<ld2.term)? LESS : (ld1.term>ld2.term)? GREATER : EQUAL;

Semantic Web: OWL vs. TPTP

Dear community,

sorry for a very naive question from an amateur.
What is the recommended way to translate OWL2 into TPTP to be used with vampire, and which expressivity would be supported?

ACFunEvaluator bug

When running Vampire (debug version) on the following benchmark

(declare-fun s () (Int))
(declare-fun t () (Int))
(define-fun F ((s (Int)) (t (Int))) Bool
true
)

(assert
(not
(and
(=> (F s t) (exists ((x (Int))) (= (+ x s) t)))
(=> (exists ((x (Int))) (= (+ x s) t)) (F s t))
)
)
)
(check-sat)
(exit)

We get an assertion Violation as such

Condition in file ./Kernel/Signature.hpp, line 443 violated:
n < _funs.length()
Value of n is: 983295040
----- stack dump -----
Version : Vampire 4.3.0 (commit unknown)
Control points passed: 702421
last control point:
+Theory::isInterpretedFunction(unsigned) (702421)
main
vampireMode()
doProving()
ProvingHelper::runVampireSaturation
ProvingHelper::runVampireSaturationImpl
MainLoop::run
SaturationAlgorithm::runImpl
SaturationAlgorithm::doOneAlgorithmStep
SaturationAlgorithm::doUnprocessedLoop
SaturationAlgorithm::newClausesToUnprocessed
SaturationAlgorithm::addUnprocessedClause
SaturationAlgorithm::doImmediateSimplification
InterpretedEvaluation::perform
InterpretedEvaluation::evaluateLiteral
InterpretedLiteralEvaluator::evaluate
InterpretedLiteralEvaluator::balancable
Theory::isInterpretedFunction(TermList)
Theory::isInterpretedFunction(Term*)
Theory::isInterpretedFunction(unsigned)
----- end of stack dump -----

Note that this doesn't happen on Mac with default compilers.

So far this happens on Ubuntu 18.04.1 LTS with gcc (Ubuntu 7.3.0-16ubuntu3) 7.3.0 as a compiler.

Incomplete type inference during parsing

The type inference for free variables is a bit incomplete, e.g.

tff(u, axiom, ! [X0] : $greater(0,X0)).

gives a user error whereas parsing succeeds on this formula:

tff(u, axiom, ! [X0] : $greater(X0,0)).

AddressSanitizer failed to allocate 0x1000 (4096) bytes of InternalMmapVector (fmb)

Hi, fo this formula

(assert (not (exists ((q0 Int) (q1 Bool)) (not (= q1 q1)))))

vampire 61a2a24

Detected maximum model sizes of [2]
TRYING [1]
TRYING [2]
Finite Model Found!
% SZS status Satisfiable for xx
% SZS output start FiniteModel for xx
tff(declare_bool,type,$o:$tType).
tff(declare_bool1,type,$false:$o).
tff(declare_bool2,type,$true:$o).
tff(finite_domain,axiom,
      ! [X:$o] : (
         X = $false | X = $true
      ) ).

tff(distinct_domain,axiom,
         $false != $true
).

% SZS output end FiniteModel for xx
% ------------------------------
% Version: Vampire 4.5.1 (commit 8ca2407 on 2020-07-30 19:28:11 +0800)
% Termination reason: Satisfiable

% Memory used [KB]: 4861
% Time elapsed: 0.003 s
% ------------------------------
----  Runtime statistics ----
clauses created: 4
-----------------------------
% ------------------------------
==88504==ERROR: AddressSanitizer failed to allocate 0x1000 (4096) bytes of InternalMmapVector (errno: 12)
ERROR: Failed to mmap

Nondeterministic SEGV at Lib/IntUnionFind.cpp:101 (fmb)

101.txt

vampire 61a2a24

ASAN:SIGSEGV
=================================================================
==95300==ERROR: AddressSanitizer: SEGV on unknown address 0x7f3f99587a10 (pc 0x000000606d18 bp 0x7ffec8ad06a0 sp 0x7ffec8ad05c0 T0)
    #0 0x606d17 in Lib::IntUnionFind::root(int) const Lib/IntUnionFind.cpp:101
    #1 0x17539ae in FMB::SortInference::doInference() FMB/SortInference.cpp:356
    #2 0x17c202f in FMB::FiniteModelBuilder::init() FMB/FiniteModelBuilder.cpp:605
    #3 0x828c3f in Kernel::MainLoop::run() Kernel/MainLoop.cpp:76
    #4 0xfb627c in Saturation::ProvingHelper::runVampireSaturationImpl(Kernel::Problem&, Shell::Options const&) Saturation/ProvingHelper.cpp:152
    #5 0xfb4f64 in Saturation::ProvingHelper::runVampireSaturation(Kernel::Problem&, Shell::Options const&) Saturation/ProvingHelper.cpp:63
    #6 0x1b6239f in doProving() /home/peisen/test/tofuzz/vampire/vampire.cpp:217
    #7 0x1b6836f in vampireMode() /home/peisen/test/tofuzz/vampire/vampire.cpp:613
    #8 0x1b6ba14 in main /home/peisen/test/tofuzz/vampire/vampire.cpp:900
    #9 0x7f3e5936982f in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x2082f)
    #10 0x414138 in _start (/home/peisen/test/tofuzz/vampire/vampire_z3_dbg+0x414138)

AddressSanitizer can not provide additional info.
SUMMARY: AddressSanitizer: SEGV Lib/IntUnionFind.cpp:101 Lib::IntUnionFind::root(int) const
==95300==ABORTING

Support for Let-In

The support for Let-In in TPTP/Parser is outdated and does not conform to the latest TPTP. It is likely this will be superseded by the Boolean Sort work, so we can leave fixing it until then.

Error in code for creating a type with uniform range

OperatorType::OperatorKey* OperatorType::setupKeyUniformRange(unsigned arity, unsigned argsSort)
{
CALL("OperatorType::setupKeyUniformRange");

OperatorKey* key = OperatorKey::allocate(arity+1);

static Stack argSorts;
argSorts.reset();
for (unsigned i=0; i<arity; i++) {
argSorts.push(argsSort);
}

return key;
}

We add arguments to argSort stack, but then do nothing with it and return an empty key. Currently, nothing calls this function so the error doesn't affect any other code.

smtcomp mode and define-fun

I am not sure this is the right channel for "outsiders" to report issues with Vampire.

I have tried to use Vampire 4.2.2 on a file in SMTLIB2 syntax containing the following line:

(define-fun |def_B definitions_0| () Bool (and (forall ( (x_4 Int) ) (=> (and (<= 0 x_4) (<= x_4 MaxInt)) (and (>= x_4 0) (<= x_4 MaxInt)))) (forall ( (x_3 Int) ) (=> (and (>= x_3 0) (<= x_3 MaxInt)) (and (<= 0 x_3) (<= x_3 MaxInt))))))

Vampire 4.2.2 seems unable to handle the define-fun keyword while the binary used in SMT-COMP 2019 does.

Here is the output produced by 4.2.2:

ddeharbe@amsterdam:~/metrics/vampire-4.4-smtcomp-wrapped-sq/bin$ ~/bin/vampire4.2.2 --ignore_missing on --mode smtcomp ../../0008/dcg_cst_i_0_0.p.smt
% Exception at proof search level
User error: list expected: |def_B definitions_0|

Here is the output produced by the vampire binary available from Star-Exec:

ddeharbe@amsterdam:~/metrics/vampire-4.4-smtcomp-wrapped-sq/bin$ ./vampire --ignore_missing on --mode smtcomp ../../0008/dcg_cst_i_0_0.p.smt
unsat

For reference, the description of this binary is

This is vampire in git version 82ff932670d944eac2fc4e01926500f781f14961 linked against z3 4.8.4

It would be nice that the official release of Vampire matches the capabilities of the version used for SMTCOMP.

How can one disable the SZS proof output in casc mode?

When I run vampire (tested with 4.4 or 4.0) with the command

vampire --statistics none --time_statistics on --time_limit 300s --mode casc --proof off trivial_dumb.tptp

The output contains

% SZS status Theorem for trivial_dumb
% SZS output start Proof for trivial_dumb
fof(f507,plain,(
  $false),
  inference(avatar_sat_refutation,[],[f177,f184,f187,f237,f506])).
...
fof(f111,plain,(
  ~direct | sP0),
  inference(cnf_transformation,[],[f84])).
% SZS output end Proof for trivial_dumb

When I run the same command but with --proof on, I get the same output that includes a proof in tptp format (lines starting with fof).

On the other hand, if I change --mode vampire then --proof off doesn't display the proof, as intended.

vampire --statistics none --time_statistics on --time_limit 300s --mode vampire --proof off trivial_dumb.tptp

And --proof on displays a proof in a different format than tptp, e.g.,

369. $false <- (10, 12, 14, 20) [subsumption resolution 368,366]
370. ~10 | ~12 | ~14 | ~20 [avatar contradiction clause 369]
371. $false [avatar sat refutation 177,184,191,192,193,194,198,205,212,216,223,230,234,246,350,370]

So it seems to me that --mode casc just ignores the option --proof. Is that intended? If so, is there another option for me to not display the proof when I use mode casc?

Vampire zip download make warning

When downloading Vampire from Github and doing:

make vampire

the first line to the terminal is

fatal: not a git repository (or any of the parent directories): .git

vprover / vampire Goto Github PK

vampire's People

Contributors

Stargazers

Watchers

Forkers

vampire's Issues

Recommend Projects

Recommend Topics

Recommend Org

Jobs