Loading ARI120=1.p ...
Preprocessing ...
Proving ...

VALID

Loading ARI496=1.p ...
Preprocessing ...
Constructing countermodel ...

VALID

Loading ARI595=1.p ...
Preprocessing ...
Proving ...

VALID

Loading ARI616=1.p ...
Preprocessing ...
Proving ...

VALID

Loading ARI620=1.p ...
Preprocessing ...
Proving ...

VALID

Loading ARI526=1.p ...
Warning: Problem contains reals, using incomplete axiomatisation
Warning: Problem contains rationals, using incomplete axiomatisation
Preprocessing ...
Constructing countermodel ...

VALID

Loading ARI522=1.p ...
Warning: Problem contains reals, using incomplete axiomatisation
Warning: Problem contains rationals, using incomplete axiomatisation
Preprocessing ...
Constructing countermodel ...

VALID

Loading GEG021=1.p ...
Preprocessing ...
Proving ...

VALID

Loading PUZ001+1.p ...
Preprocessing ...
Proving ...

VALID

Loading PUZ133=2.p ...
Preprocessing ...
Proving ...

VALID

Loading SYN050-1.p ...
Preprocessing ...
Proving ...

VALID

Loading SYO561_1.p ...
Preprocessing ...
Constructing countermodel ...

VALID

Loading SYO563+1.p ...
Preprocessing ...
Constructing countermodel ...

VALID

Loading SYO563+2.p ...
Preprocessing ...
Constructing countermodel ...

VALID

Loading let-tests.p ...
Preprocessing ...
Constructing countermodel ...

VALID

Loading quotes.p ...
Preprocessing ...
Constructing countermodel ...

INVALID

Countermodel:
green:\\'Color' = Color!4 & red:Color = Color!2

Loading multiple-conjectures.p ...
Preprocessing ...
Constructing countermodel ...

VALID

Loading unsat-core.p ...
Preprocessing ...
Warning: ignoring some quantifiers
Constructing countermodel ...
Found proof (size 88)

VALID

Unsatisfiable core:
{DIFF-row1-row2, DIFF-row1-row3, DIFF-row2-row3, DIFF-tempty-tcons, EQ-tcons, rawDifference-INV, rawDifference2, rawDifference4, rowIn-true-INV, rowIn0, rowIn1, test-4}

Loading unsat-core.p ...
Preprocessing ...
Warning: ignoring some quantifiers
Constructing countermodel ...
Found proof (size 88)

VALID

% SZS output start Proof for theBenchmark
Assumptions after simplification:
---------------------------------

  (DIFF-row1-row2)
   ~ (vrow1 = vrow2)

  (DIFF-row1-row3)
   ~ (vrow3 = vrow1)

  (DIFF-row2-row3)
   ~ (vrow3 = vrow2)

  (DIFF-tempty-tcons)
   ! [v0: $int] :  ! [v1: $int] :  ~ (vtcons(v0, v1) = vtempty)

  (EQ-tcons)
   ! [v0: $int] :  ! [v1: $int] :  ! [v2: $int] :  ! [v3: $int] :  ! [v4: $int]
  : ( ~ (vtcons(v1, v3) = v4) |  ~ (vtcons(v0, v2) = v4) | (v3 = v2 & v1 = v0))
  &  ! [v0: $int] :  ! [v1: $int] :  ! [v2: $int] :  ! [v3: $int] : (v3 = v2 | 
    ~ (vtcons(v0, v1) = v3) |  ~ (vtcons(v0, v1) = v2))

  (rawDifference-INV)
   ! [v0: $int] :  ! [v1: $int] :  ! [v2: $int] : ( ~ (vrawDifference(v0, v1) =
      v2) |  ? [v3: $int] :  ? [v4: $int] :  ? [v5: $int] :  ? [v6: $int] : ( ~
      (v6 = 0) &  ~ (v4 = vtempty) & vrawDifference(v4, v1) = v3 & vrowIn(v5,
        v1) = v6 & vtcons(v5, v4) = v0 & vtcons(v5, v3) = v2) |  ? [v3: $int] : 
    ? [v4: $int] : (v2 = v0 &  ~ (v4 = 0) & vrowIn(v3, v1) = v4 & vtcons(v3,
        vtempty) = v0) |  ? [v3: $int] :  ? [v4: $int] : ( ~ (v3 = vtempty) &
      vrawDifference(v3, v1) = v2 & vrowIn(v4, v1) = 0 & vtcons(v4, v3) = v0) | 
    ? [v3: $int] : (v2 = vtempty & vrowIn(v3, v1) = 0 & vtcons(v3, vtempty) =
      v0) | (v2 = v0 & v1 = vtempty) | (v2 = vtempty & v0 = vtempty))

  (rawDifference2)
   ! [v0: $int] :  ! [v1: $int] :  ! [v2: $int] :  ! [v3: $int] : (v3 = v2 |  ~
    (vrawDifference(v2, v1) = v3) |  ~ (vtcons(v0, vtempty) = v2) | vrowIn(v0,
      v1) = 0)

  (rawDifference4)
   ! [v0: $int] :  ! [v1: $int] :  ! [v2: $int] :  ! [v3: $int] :  ! [v4: $int]
  :  ! [v5: $int] :  ! [v6: $int] : (v6 = v5 | v1 = vtempty |  ~
    (vrawDifference(v4, v2) = v5) |  ~ (vtcons(v3, v1) = v4) |  ~ (vtcons(v3,
        v0) = v6) |  ? [v7: $int] :  ? [v8: $int] : ((v8 = 0 & vrowIn(v3, v2) =
        0) | ( ~ (v7 = v0) & vrawDifference(v1, v2) = v7)))

  (rowIn-true-INV)
   ! [v0: $int] :  ! [v1: $int] : ( ~ (vrowIn(v0, v1) = 0) |  ? [v2: $int] :  ?
    [v3: $int] :  ? [v4: $int] : (vtcons(v2, v3) = v1 & (v2 = v0 | (v4 = 0 &
          vrowIn(v0, v3) = 0))))

  (rowIn0)
   ! [v0: $int] :  ~ (vrowIn(v0, vtempty) = 0)

  (rowIn1)
   ! [v0: $int] :  ! [v1: $int] :  ! [v2: $int] :  ! [v3: $int] :  ! [v4: $int]
  : (v4 = 0 |  ~ (vrowIn(v0, v3) = v4) |  ~ (vtcons(v1, v2) = v3) | ( ~ (v1 =
        v0) &  ? [v5: $int] : ( ~ (v5 = 0) & vrowIn(v0, v2) = v5))) &  ! [v0:
    $int] :  ! [v1: $int] :  ! [v2: $int] :  ! [v3: $int] : (v1 = v0 |  ~
    (vrowIn(v0, v3) = 0) |  ~ (vtcons(v1, v2) = v3) | vrowIn(v0, v2) = 0)

  (test-4)
   ? [v0: $int] :  ? [v1: $int] :  ? [v2: $int] :  ? [v3: $int] : (vtcons(vrow3,
      v2) = v3 & vtcons(vrow1, v0) = v1 & vtcons(vrow1, vtempty) = v2 &
    vtcons(vrow2, vtempty) = v0 &  ? [v4: $int] : ( ~ (v4 = v0) &
      vrawDifference(v1, v3) = v4))

Further assumptions not needed in the proof:
--------------------------------------------
DIFF-Intersection-Difference, DIFF-SelectAllFrom-Difference,
DIFF-SelectAllFrom-Intersection, DIFF-SelectAllFrom-SelectAllFromWhere,
DIFF-SelectAllFrom-SelectSomeFrom, DIFF-SelectAllFrom-SelectSomeFromWhere,
DIFF-SelectAllFrom-Union, DIFF-SelectAllFromWhere-Difference,
DIFF-SelectAllFromWhere-Intersection,
DIFF-SelectAllFromWhere-SelectSomeFromWhere, DIFF-SelectAllFromWhere-Union,
DIFF-SelectSomeFrom-Difference, DIFF-SelectSomeFrom-Intersection,
DIFF-SelectSomeFrom-SelectAllFromWhere, DIFF-SelectSomeFrom-SelectSomeFromWhere,
DIFF-SelectSomeFrom-Union, DIFF-SelectSomeFromWhere-Difference,
DIFF-SelectSomeFromWhere-Intersection, DIFF-SelectSomeFromWhere-Union,
DIFF-Tvalue-Difference, DIFF-Tvalue-Intersection, DIFF-Tvalue-SelectAllFrom,
DIFF-Tvalue-SelectAllFromWhere, DIFF-Tvalue-SelectSomeFrom,
DIFF-Tvalue-SelectSomeFromWhere, DIFF-Tvalue-Union, DIFF-Union-Difference,
DIFF-Union-Intersection, DIFF-VEquals-VGreater, DIFF-VEquals-VSmaller,
DIFF-VGreater-VSmaller, DIFF-aempty-acons, DIFF-emptyContext-bindContext,
DIFF-emptyStore-bindStore, DIFF-error-isFalse, DIFF-error-isTrue,
DIFF-isTrue-isFalse, DIFF-noConf-someConf, DIFF-noFType-someFType,
DIFF-noRawTable-someRawTable, DIFF-noTType-someTType, DIFF-noTable-someTable,
DIFF-rempty-rcons, DIFF-rtempty-rtcons, DIFF-ttempty-ttcons, EQ-Difference,
EQ-Intersection, EQ-Ref, EQ-SelectAllFrom, EQ-SelectAllFromWhere,
EQ-SelectSomeFrom, EQ-SelectSomeFromWhere, EQ-Tvalue, EQ-Union, EQ-VEquals,
EQ-VGreater, EQ-VSmaller, EQ-acons, EQ-bindContext, EQ-bindStore, EQ-conf,
EQ-ctype, EQ-rcons, EQ-rtcons, EQ-someConf, EQ-someFType, EQ-someRawTable,
EQ-someTType, EQ-someTable, EQ-table, EQ-ttcons, StoreContext-Lookup-WT,
StoreContextConsistent-false-INV, StoreContextConsistent-true-INV,
StoreContextConsistent0, StoreContextConsistent1, StoreContextConsistent2,
T-Difference, T-Intersection, T-SelectAllFrom, T-SelectAllFromWhere,
T-SelectSomeFrom, T-SelectSomeFromWhere, T-TTContext-Duplicate,
T-TTContext-Swap, T-Tvalue, T-Union, append-INV, append0, append1,
attachColToFrontRaw-INV, attachColToFrontRaw0, attachColToFrontRaw1,
attachColToFrontRaw2, attachColToFrontRaw3, checkPValidity-false-INV,
checkPValidity-true-INV, checkPValidity0, checkPValidity1, checkPValidity2,
ctypeIn-false-INV, ctypeIn-true-INV, ctypeIn0, ctypeIn1, difference-INV,
difference0, difference1, dropFirstColRaw-INV, dropFirstColRaw0,
dropFirstColRaw1, dropFirstColRaw2, findCol-INV, findCol0, findCol1, findCol2,
findColType0, findColType1, findColType2, getAL0, getQuery0, getRaw0,
getSomeConf0, getSomeFType0, getSomeRawTable0, getSomeTType0, getSomeTable0,
intersect-INV, intersect0, intersect1, isSomeConf-false-INV,
isSomeConf-true-INV, isSomeConf0, isSomeConf1, isSomeFType-false-INV,
isSomeFType-true-INV, isSomeFType0, isSomeFType1, isSomeRawTable-false-INV,
isSomeRawTable-true-INV, isSomeRawTable0, isSomeRawTable1,
isSomeTType-false-INV, isSomeTType-true-INV, isSomeTType0, isSomeTType1,
isSomeTable-false-INV, isSomeTable-true-INV, isSomeTable0, isSomeTable1,
isValue-false-INV, isValue-true-INV, isValue0, isValue1, isValue2, isValue3,
isValue4, isValue5, isValue6, isValue7, lookupContext-INV, lookupContext0,
lookupContext1, lookupContext2, lookupStore-INV, lookupStore0, lookupStore1,
lookupStore2, matchingAList-false-INV, matchingAList-true-INV, matchingAList0,
matchingAList1, matchingAList2, project-INV, project0, project1, project2,
projectEmptyCol0, projectEmptyCol1, projectFirstRaw0, projectFirstRaw1,
projectFirstRaw2, projectType0, projectType1, projectType2, rawDifference0,
rawDifference1, rawDifference3, rawDifference5, rawIntersection-INV,
rawIntersection0, rawIntersection1, rawIntersection2, rawIntersection3,
rawIntersection4, rawIntersection5, rawType-INV, rawType0, rawType1,
rawUnion-INV, rawUnion0, rawUnion1, rawUnion2, rawUnion3, reduce-INV, reduce0,
reduce1, reduce10, reduce11, reduce12, reduce13, reduce14, reduce15, reduce16,
reduce17, reduce18, reduce19, reduce2, reduce20, reduce21, reduce22, reduce23,
reduce24, reduce25, reduce26, reduce27, reduce28, reduce29, reduce3, reduce30,
reduce4, reduce5, reduce6, reduce7, reduce8, reduce9, rowIn-false-INV,
select-INV, select0, select1, select2, select3, singleRowSelect-INV,
singleRowSelect0, singleRowSelect1, singleRowSelect10, singleRowSelect11,
singleRowSelect12, singleRowSelect13, singleRowSelect14, singleRowSelect15,
singleRowSelect16, singleRowSelect17, singleRowSelect2, singleRowSelect3,
singleRowSelect4, singleRowSelect5, singleRowSelect6, singleRowSelect7,
singleRowSelect8, singleRowSelect9, union-INV, union0, union1,
welltypedRawtable-false-INV, welltypedRawtable-true-INV, welltypedRawtable0,
welltypedRawtable1, welltypedRow-false-INV, welltypedRow-true-INV,
welltypedRow0, welltypedRow1, welltypedRow2, welltypedtable-false-INV,
welltypedtable-true-INV, welltypedtable0

Those formulas are unsatisfiable:
---------------------------------

Begin of proof
| 
| ALPHA: (EQ-tcons) implies:
|   (1)   ! [v0: $int] :  ! [v1: $int] :  ! [v2: $int] :  ! [v3: $int] :  ! [v4:
|          $int] : ( ~ (vtcons(v1, v3) = v4) |  ~ (vtcons(v0, v2) = v4) | (v3 =
|            v2 & v1 = v0))
| 
| ALPHA: (rowIn1) implies:
|   (2)   ! [v0: $int] :  ! [v1: $int] :  ! [v2: $int] :  ! [v3: $int] : (v1 =
|          v0 |  ~ (vrowIn(v0, v3) = 0) |  ~ (vtcons(v1, v2) = v3) | vrowIn(v0,
|            v2) = 0)
|   (3)   ! [v0: $int] :  ! [v1: $int] :  ! [v2: $int] :  ! [v3: $int] :  ! [v4:
|          $int] : (v4 = 0 |  ~ (vrowIn(v0, v3) = v4) |  ~ (vtcons(v1, v2) = v3)
|          | ( ~ (v1 = v0) &  ? [v5: $int] : ( ~ (v5 = 0) & vrowIn(v0, v2) =
|              v5)))
| 
| DELTA: instantiating (test-4) with fresh symbols all_425_0, all_425_1,
|        all_425_2, all_425_3 gives:
|   (4)  vtcons(vrow3, all_425_1) = all_425_0 & vtcons(vrow1, all_425_3) =
|        all_425_2 & vtcons(vrow1, vtempty) = all_425_1 & vtcons(vrow2, vtempty)
|        = all_425_3 &  ? [v0: $int] : ( ~ (v0 = all_425_3) &
|          vrawDifference(all_425_2, all_425_0) = v0)
| 
| ALPHA: (4) implies:
|   (5)  vtcons(vrow2, vtempty) = all_425_3
|   (6)  vtcons(vrow1, vtempty) = all_425_1
|   (7)  vtcons(vrow1, all_425_3) = all_425_2
|   (8)  vtcons(vrow3, all_425_1) = all_425_0
|   (9)   ? [v0: $int] : ( ~ (v0 = all_425_3) & vrawDifference(all_425_2,
|            all_425_0) = v0)
| 
| DELTA: instantiating (9) with fresh symbol all_440_0 gives:
|   (10)   ~ (all_440_0 = all_425_3) & vrawDifference(all_425_2, all_425_0) =
|         all_440_0
| 
| ALPHA: (10) implies:
|   (11)   ~ (all_440_0 = all_425_3)
|   (12)  vrawDifference(all_425_2, all_425_0) = all_440_0
| 
| GROUND_INST: instantiating (rawDifference4) with vtempty, all_425_3,
|              all_425_0, vrow1, all_425_2, all_440_0, all_425_1, simplifying
|              with (6), (7), (12) gives:
|   (13)  all_440_0 = all_425_1 | all_425_3 = vtempty |  ? [v0: $int] :  ? [v1:
|           $int] : ((v1 = 0 & vrowIn(vrow1, all_425_0) = 0) | ( ~ (v0 =
|               vtempty) & vrawDifference(all_425_3, all_425_0) = v0))
| 
| GROUND_INST: instantiating (rawDifference-INV) with all_425_2, all_425_0,
|              all_440_0, simplifying with (12) gives:
|   (14)   ? [v0: $int] :  ? [v1: $int] :  ? [v2: $int] :  ? [v3: $int] : ( ~
|           (v3 = 0) &  ~ (v1 = vtempty) & vrawDifference(v1, all_425_0) = v0 &
|           vrowIn(v2, all_425_0) = v3 & vtcons(v2, v1) = all_425_2 & vtcons(v2,
|             v0) = all_440_0) |  ? [v0: $int] :  ? [v1: $int] : (all_440_0 =
|           all_425_2 &  ~ (v1 = 0) & vrowIn(v0, all_425_0) = v1 & vtcons(v0,
|             vtempty) = all_425_2) |  ? [v0: $int] :  ? [v1: $int] : ( ~ (v0 =
|             vtempty) & vrawDifference(v0, all_425_0) = all_440_0 & vrowIn(v1,
|             all_425_0) = 0 & vtcons(v1, v0) = all_425_2) |  ? [v0: $int] :
|         (all_440_0 = vtempty & vrowIn(v0, all_425_0) = 0 & vtcons(v0, vtempty)
|           = all_425_2) | (all_440_0 = all_425_2 & all_425_0 = vtempty) |
|         (all_440_0 = vtempty & all_425_2 = vtempty)
| 
| BETA: splitting (13) gives:
| 
| Case 1:
| | 
| |   (15)  all_425_3 = vtempty
| | 
| | REDUCE: (5), (15) imply:
| |   (16)  vtcons(vrow2, vtempty) = vtempty
| | 
| | GROUND_INST: instantiating (DIFF-tempty-tcons) with vrow2, vtempty,
| |              simplifying with (16) gives:
| |   (17)  $false
| | 
| | CLOSE: (17) is inconsistent.
| | 
| Case 2:
| | 
| |   (18)   ~ (all_425_3 = vtempty)
| | 
| | BETA: splitting (14) gives:
| | 
| | Case 1:
| | | 
| | |   (19)   ? [v0: $int] :  ? [v1: $int] :  ? [v2: $int] :  ? [v3: $int] : (
| | |           ~ (v3 = 0) &  ~ (v1 = vtempty) & vrawDifference(v1, all_425_0) =
| | |           v0 & vrowIn(v2, all_425_0) = v3 & vtcons(v2, v1) = all_425_2 &
| | |           vtcons(v2, v0) = all_440_0) |  ? [v0: $int] :  ? [v1: $int] :
| | |         (all_440_0 = all_425_2 &  ~ (v1 = 0) & vrowIn(v0, all_425_0) = v1
| | |           & vtcons(v0, vtempty) = all_425_2) |  ? [v0: $int] :  ? [v1:
| | |           $int] : ( ~ (v0 = vtempty) & vrawDifference(v0, all_425_0) =
| | |           all_440_0 & vrowIn(v1, all_425_0) = 0 & vtcons(v1, v0) =
| | |           all_425_2)
| | | 
| | | BETA: splitting (19) gives:
| | | 
| | | Case 1:
| | | | 
| | | |   (20)   ? [v0: $int] :  ? [v1: $int] :  ? [v2: $int] :  ? [v3: $int] :
| | | |         ( ~ (v3 = 0) &  ~ (v1 = vtempty) & vrawDifference(v1, all_425_0)
| | | |           = v0 & vrowIn(v2, all_425_0) = v3 & vtcons(v2, v1) = all_425_2
| | | |           & vtcons(v2, v0) = all_440_0)
| | | | 
| | | | DELTA: instantiating (20) with fresh symbols all_595_0, all_595_1,
| | | |        all_595_2, all_595_3 gives:
| | | |   (21)   ~ (all_595_0 = 0) &  ~ (all_595_2 = vtempty) &
| | | |         vrawDifference(all_595_2, all_425_0) = all_595_3 &
| | | |         vrowIn(all_595_1, all_425_0) = all_595_0 & vtcons(all_595_1,
| | | |           all_595_2) = all_425_2 & vtcons(all_595_1, all_595_3) =
| | | |         all_440_0
| | | | 
| | | | ALPHA: (21) implies:
| | | |   (22)   ~ (all_595_0 = 0)
| | | |   (23)  vtcons(all_595_1, all_595_2) = all_425_2
| | | |   (24)  vrowIn(all_595_1, all_425_0) = all_595_0
| | | | 
| | | | GROUND_INST: instantiating (1) with vrow1, all_595_1, all_425_3,
| | | |              all_595_2, all_425_2, simplifying with (7), (23) gives:
| | | |   (25)  all_595_1 = vrow1 & all_595_2 = all_425_3
| | | | 
| | | | ALPHA: (25) implies:
| | | |   (26)  all_595_1 = vrow1
| | | | 
| | | | REDUCE: (24), (26) imply:
| | | |   (27)  vrowIn(vrow1, all_425_0) = all_595_0
| | | | 
| | | | GROUND_INST: instantiating (3) with vrow1, vrow3, all_425_1, all_425_0,
| | | |              all_595_0, simplifying with (8), (27) gives:
| | | |   (28)  all_595_0 = 0 | ( ~ (vrow3 = vrow1) &  ? [v0: $int] : ( ~ (v0 =
| | | |               0) & vrowIn(vrow1, all_425_1) = v0))
| | | | 
| | | | BETA: splitting (28) gives:
| | | | 
| | | | Case 1:
| | | | | 
| | | | |   (29)  all_595_0 = 0
| | | | | 
| | | | | REDUCE: (22), (29) imply:
| | | | |   (30)  $false
| | | | | 
| | | | | CLOSE: (30) is inconsistent.
| | | | | 
| | | | Case 2:
| | | | | 
| | | | |   (31)   ~ (vrow3 = vrow1) &  ? [v0: $int] : ( ~ (v0 = 0) &
| | | | |           vrowIn(vrow1, all_425_1) = v0)
| | | | | 
| | | | | ALPHA: (31) implies:
| | | | |   (32)   ? [v0: $int] : ( ~ (v0 = 0) & vrowIn(vrow1, all_425_1) = v0)
| | | | | 
| | | | | DELTA: instantiating (32) with fresh symbol all_612_0 gives:
| | | | |   (33)   ~ (all_612_0 = 0) & vrowIn(vrow1, all_425_1) = all_612_0
| | | | | 
| | | | | ALPHA: (33) implies:
| | | | |   (34)   ~ (all_612_0 = 0)
| | | | |   (35)  vrowIn(vrow1, all_425_1) = all_612_0
| | | | | 
| | | | | GROUND_INST: instantiating (3) with vrow1, vrow1, vtempty, all_425_1,
| | | | |              all_612_0, simplifying with (6), (35) gives:
| | | | |   (36)  all_612_0 = 0
| | | | | 
| | | | | REDUCE: (34), (36) imply:
| | | | |   (37)  $false
| | | | | 
| | | | | CLOSE: (37) is inconsistent.
| | | | | 
| | | | End of split
| | | | 
| | | Case 2:
| | | | 
| | | |   (38)   ? [v0: $int] :  ? [v1: $int] : (all_440_0 = all_425_2 &  ~ (v1
| | | |             = 0) & vrowIn(v0, all_425_0) = v1 & vtcons(v0, vtempty) =
| | | |           all_425_2) |  ? [v0: $int] :  ? [v1: $int] : ( ~ (v0 =
| | | |             vtempty) & vrawDifference(v0, all_425_0) = all_440_0 &
| | | |           vrowIn(v1, all_425_0) = 0 & vtcons(v1, v0) = all_425_2)
| | | | 
| | | | BETA: splitting (38) gives:
| | | | 
| | | | Case 1:
| | | | | 
| | | | |   (39)   ? [v0: $int] :  ? [v1: $int] : (all_440_0 = all_425_2 &  ~
| | | | |           (v1 = 0) & vrowIn(v0, all_425_0) = v1 & vtcons(v0, vtempty)
| | | | |           = all_425_2)
| | | | | 
| | | | | DELTA: instantiating (39) with fresh symbols all_595_0, all_595_1
| | | | |        gives:
| | | | |   (40)  all_440_0 = all_425_2 &  ~ (all_595_0 = 0) & vrowIn(all_595_1,
| | | | |           all_425_0) = all_595_0 & vtcons(all_595_1, vtempty) =
| | | | |         all_425_2
| | | | | 
| | | | | ALPHA: (40) implies:
| | | | |   (41)  vtcons(all_595_1, vtempty) = all_425_2
| | | | | 
| | | | | GROUND_INST: instantiating (1) with vrow1, all_595_1, all_425_3,
| | | | |              vtempty, all_425_2, simplifying with (7), (41) gives:
| | | | |   (42)  all_595_1 = vrow1 & all_425_3 = vtempty
| | | | | 
| | | | | ALPHA: (42) implies:
| | | | |   (43)  all_425_3 = vtempty
| | | | | 
| | | | | REDUCE: (18), (43) imply:
| | | | |   (44)  $false
| | | | | 
| | | | | CLOSE: (44) is inconsistent.
| | | | | 
| | | | Case 2:
| | | | | 
| | | | |   (45)   ? [v0: $int] :  ? [v1: $int] : ( ~ (v0 = vtempty) &
| | | | |           vrawDifference(v0, all_425_0) = all_440_0 & vrowIn(v1,
| | | | |             all_425_0) = 0 & vtcons(v1, v0) = all_425_2)
| | | | | 
| | | | | DELTA: instantiating (45) with fresh symbols all_595_0, all_595_1
| | | | |        gives:
| | | | |   (46)   ~ (all_595_1 = vtempty) & vrawDifference(all_595_1,
| | | | |           all_425_0) = all_440_0 & vrowIn(all_595_0, all_425_0) = 0 &
| | | | |         vtcons(all_595_0, all_595_1) = all_425_2
| | | | | 
| | | | | ALPHA: (46) implies:
| | | | |   (47)  vtcons(all_595_0, all_595_1) = all_425_2
| | | | |   (48)  vrowIn(all_595_0, all_425_0) = 0
| | | | |   (49)  vrawDifference(all_595_1, all_425_0) = all_440_0
| | | | | 
| | | | | GROUND_INST: instantiating (1) with vrow1, all_595_0, all_425_3,
| | | | |              all_595_1, all_425_2, simplifying with (7), (47) gives:
| | | | |   (50)  all_595_0 = vrow1 & all_595_1 = all_425_3
| | | | | 
| | | | | ALPHA: (50) implies:
| | | | |   (51)  all_595_1 = all_425_3
| | | | |   (52)  all_595_0 = vrow1
| | | | | 
| | | | | REDUCE: (49), (51) imply:
| | | | |   (53)  vrawDifference(all_425_3, all_425_0) = all_440_0
| | | | | 
| | | | | REDUCE: (48), (52) imply:
| | | | |   (54)  vrowIn(vrow1, all_425_0) = 0
| | | | | 
| | | | | GROUND_INST: instantiating (2) with vrow1, vrow3, all_425_1,
| | | | |              all_425_0, simplifying with (8), (54) gives:
| | | | |   (55)  vrow3 = vrow1 | vrowIn(vrow1, all_425_1) = 0
| | | | | 
| | | | | GROUND_INST: instantiating (rawDifference2) with vrow2, all_425_0,
| | | | |              all_425_3, all_440_0, simplifying with (5), (53) gives:
| | | | |   (56)  all_440_0 = all_425_3 | vrowIn(vrow2, all_425_0) = 0
| | | | | 
| | | | | BETA: splitting (56) gives:
| | | | | 
| | | | | Case 1:
| | | | | | 
| | | | | |   (57)  vrowIn(vrow2, all_425_0) = 0
| | | | | | 
| | | | | | BETA: splitting (55) gives:
| | | | | | 
| | | | | | Case 1:
| | | | | | | 
| | | | | | |   (58)  vrowIn(vrow1, all_425_1) = 0
| | | | | | | 
| | | | | | | GROUND_INST: instantiating (2) with vrow2, vrow3, all_425_1,
| | | | | | |              all_425_0, simplifying with (8), (57) gives:
| | | | | | |   (59)  vrow3 = vrow2 | vrowIn(vrow2, all_425_1) = 0
| | | | | | | 
| | | | | | | GROUND_INST: instantiating (rowIn-true-INV) with vrow1, all_425_1,
| | | | | | |              simplifying with (58) gives:
| | | | | | |   (60)   ? [v0: $int] :  ? [v1: $int] :  ? [v2: $int] :
| | | | | | |         (vtcons(v0, v1) = all_425_1 & (v0 = vrow1 | (v2 = 0 &
| | | | | | |               vrowIn(vrow1, v1) = 0)))
| | | | | | | 
| | | | | | | DELTA: instantiating (60) with fresh symbols all_633_0, all_633_1,
| | | | | | |        all_633_2 gives:
| | | | | | |   (61)  vtcons(all_633_2, all_633_1) = all_425_1 & (all_633_2 =
| | | | | | |           vrow1 | (all_633_0 = 0 & vrowIn(vrow1, all_633_1) = 0))
| | | | | | | 
| | | | | | | ALPHA: (61) implies:
| | | | | | |   (62)  vtcons(all_633_2, all_633_1) = all_425_1
| | | | | | | 
| | | | | | | BETA: splitting (59) gives:
| | | | | | | 
| | | | | | | Case 1:
| | | | | | | | 
| | | | | | | |   (63)  vrowIn(vrow2, all_425_1) = 0
| | | | | | | | 
| | | | | | | | GROUND_INST: instantiating (1) with vrow1, all_633_2, vtempty,
| | | | | | | |              all_633_1, all_425_1, simplifying with (6), (62)
| | | | | | | |              gives:
| | | | | | | |   (64)  all_633_1 = vtempty & all_633_2 = vrow1
| | | | | | | | 
| | | | | | | | ALPHA: (64) implies:
| | | | | | | |   (65)  all_633_2 = vrow1
| | | | | | | |   (66)  all_633_1 = vtempty
| | | | | | | | 
| | | | | | | | GROUND_INST: instantiating (2) with vrow2, vrow1, vtempty,
| | | | | | | |              all_425_1, simplifying with (6), (63) gives:
| | | | | | | |   (67)  vrow1 = vrow2 | vrowIn(vrow2, vtempty) = 0
| | | | | | | | 
| | | | | | | | BETA: splitting (67) gives:
| | | | | | | | 
| | | | | | | | Case 1:
| | | | | | | | | 
| | | | | | | | |   (68)  vrowIn(vrow2, vtempty) = 0
| | | | | | | | | 
| | | | | | | | | GROUND_INST: instantiating (rowIn0) with vrow2, simplifying
| | | | | | | | |              with (68) gives:
| | | | | | | | |   (69)  $false
| | | | | | | | | 
| | | | | | | | | CLOSE: (69) is inconsistent.
| | | | | | | | | 
| | | | | | | | Case 2:
| | | | | | | | | 
| | | | | | | | |   (70)  vrow1 = vrow2
| | | | | | | | | 
| | | | | | | | | REDUCE: (70), (DIFF-row1-row2) imply:
| | | | | | | | |   (71)  $false
| | | | | | | | | 
| | | | | | | | | CLOSE: (71) is inconsistent.
| | | | | | | | | 
| | | | | | | | End of split
| | | | | | | | 
| | | | | | | Case 2:
| | | | | | | | 
| | | | | | | |   (72)  vrow3 = vrow2
| | | | | | | | 
| | | | | | | | REDUCE: (72), (DIFF-row2-row3) imply:
| | | | | | | |   (73)  $false
| | | | | | | | 
| | | | | | | | CLOSE: (73) is inconsistent.
| | | | | | | | 
| | | | | | | End of split
| | | | | | | 
| | | | | | Case 2:
| | | | | | | 
| | | | | | |   (74)  vrow3 = vrow1
| | | | | | | 
| | | | | | | REDUCE: (74), (DIFF-row1-row3) imply:
| | | | | | |   (75)  $false
| | | | | | | 
| | | | | | | CLOSE: (75) is inconsistent.
| | | | | | | 
| | | | | | End of split
| | | | | | 
| | | | | Case 2:
| | | | | | 
| | | | | |   (76)  all_440_0 = all_425_3
| | | | | | 
| | | | | | REDUCE: (11), (76) imply:
| | | | | |   (77)  $false
| | | | | | 
| | | | | | CLOSE: (77) is inconsistent.
| | | | | | 
| | | | | End of split
| | | | | 
| | | | End of split
| | | | 
| | | End of split
| | | 
| | Case 2:
| | | 
| | |   (78)   ? [v0: $int] : (all_440_0 = vtempty & vrowIn(v0, all_425_0) = 0 &
| | |           vtcons(v0, vtempty) = all_425_2) | (all_440_0 = all_425_2 &
| | |           all_425_0 = vtempty) | (all_440_0 = vtempty & all_425_2 =
| | |           vtempty)
| | | 
| | | BETA: splitting (78) gives:
| | | 
| | | Case 1:
| | | | 
| | | |   (79)   ? [v0: $int] : (all_440_0 = vtempty & vrowIn(v0, all_425_0) = 0
| | | |           & vtcons(v0, vtempty) = all_425_2)
| | | | 
| | | | DELTA: instantiating (79) with fresh symbol all_595_0 gives:
| | | |   (80)  all_440_0 = vtempty & vrowIn(all_595_0, all_425_0) = 0 &
| | | |         vtcons(all_595_0, vtempty) = all_425_2
| | | | 
| | | | ALPHA: (80) implies:
| | | |   (81)  all_440_0 = vtempty
| | | |   (82)  vtcons(all_595_0, vtempty) = all_425_2
| | | | 
| | | | REDUCE: (11), (81) imply:
| | | |   (83)   ~ (all_425_3 = vtempty)
| | | | 
| | | | GROUND_INST: instantiating (1) with vrow1, all_595_0, all_425_3,
| | | |              vtempty, all_425_2, simplifying with (7), (82) gives:
| | | |   (84)  all_595_0 = vrow1 & all_425_3 = vtempty
| | | | 
| | | | ALPHA: (84) implies:
| | | |   (85)  all_425_3 = vtempty
| | | | 
| | | | REDUCE: (18), (85) imply:
| | | |   (86)  $false
| | | | 
| | | | CLOSE: (86) is inconsistent.
| | | | 
| | | Case 2:
| | | | 
| | | |   (87)  (all_440_0 = all_425_2 & all_425_0 = vtempty) | (all_440_0 =
| | | |           vtempty & all_425_2 = vtempty)
| | | | 
| | | | BETA: splitting (87) gives:
| | | | 
| | | | Case 1:
| | | | | 
| | | | |   (88)  all_440_0 = all_425_2 & all_425_0 = vtempty
| | | | | 
| | | | | ALPHA: (88) implies:
| | | | |   (89)  all_425_0 = vtempty
| | | | | 
| | | | | REDUCE: (8), (89) imply:
| | | | |   (90)  vtcons(vrow3, all_425_1) = vtempty
| | | | | 
| | | | | GROUND_INST: instantiating (DIFF-tempty-tcons) with vrow3, all_425_1,
| | | | |              simplifying with (90) gives:
| | | | |   (91)  $false
| | | | | 
| | | | | CLOSE: (91) is inconsistent.
| | | | | 
| | | | Case 2:
| | | | | 
| | | | |   (92)  all_440_0 = vtempty & all_425_2 = vtempty
| | | | | 
| | | | | ALPHA: (92) implies:
| | | | |   (93)  all_425_2 = vtempty
| | | | | 
| | | | | REDUCE: (7), (93) imply:
| | | | |   (94)  vtcons(vrow1, all_425_3) = vtempty
| | | | | 
| | | | | GROUND_INST: instantiating (DIFF-tempty-tcons) with vrow1, all_425_3,
| | | | |              simplifying with (94) gives:
| | | | |   (95)  $false
| | | | | 
| | | | | CLOSE: (95) is inconsistent.
| | | | | 
| | | | End of split
| | | | 
| | | End of split
| | | 
| | End of split
| | 
| End of split
| 
End of proof
% SZS output end Proof for theBenchmark

Loading ARI495=1.p ...
Warning: Problem contains reals, using incomplete axiomatisation
Preprocessing ...
Proving ...

VALID

