---------------------------------------------------------------------------------------------------
The following entries do not lead to adapted feedback
---------------------------------------------------------------------------------------------------

off FORMULA: correct
off MESSAGE: That's correct

off FORMULA: NOT correct AND NOT missingsubop
off MESSAGE: CORRECTSUBOPERATION is the correct operation!

off FORMULA: missingsubop
off MESSAGE: There are missing suboperations!

---------------------------------------------------------------------------------------------------
CORRECT-KB:
---------------------------------------------------------------------------------------------------

=== link ===

FORMULA: correct AND subop[current].id = link AND subop[current].count = 1
MESSAGE: Is necessary for OPERATIONID's consolidate

FORMULA: correct AND subop[current].id = link AND subop[current].count > 1
MESSAGE: This SUBOPERATIONID ist correct, because the bigger node is linked to the smaller node, and both nodes has same outdegree.


=== setkey ===

FORMULA: correct AND subop[current].id = setkey
MESSAGE: Is necessary for OPERATIONID to set the new value.

=== remove ===

FORMULA: correct AND subop[current].id = remove
MESSAGE: Is necessary for OPERATION

=== mark ===

FORMULA: correct AND subop[current].id = mark
MESSAGE: If a node loose a child, the node must be marked

=== unmark ===

FORMULA: correct AND subop[current].id = unmark
MESSAGE: If a node becomes child of another node, the node will be unmarked

=== updatemin ===

FORMULA: correct AND subop[current].id = updatemin AND op[current].id != delete_min
MESSAGE: The pointer to the minimum node has to be updated after a operation who changes him. And this is necessary for OPERATION

FORMULA: correct AND subop[current].id = updatemin AND op[current].id = delete_min
MESSAGE: A OPERATION always changes the minimum, and so the minimum has to be updated at end.

=== cut ===

FORMULA: correct AND subop[current].id = cut AND op[current].id = delete AND subop[current].id = cut AND subop[current].count = 1
MESSAGE: A to removed node has to be cut before he can removed

FORMULA: correct AND subop[current].id = cut AND op[current].id = delete AND subop[current].id = cut AND subop[current].count > 1
MESSAGE: A marked node who lost a child must be cutted

FORMULA: correct AND subop[current].id = cut AND op[current].id = decrease_key AND subop[current].id = cut AND subop[current].count = 1
MESSAGE: If a node is decreased below the value of its parent node, he has to be cutted

FORMULA: correct AND subop[current].id = cut AND op[current].id = decrease_key AND subop[current].id = cut AND subop[current].count > 1
MESSAGE: A marked node who lost a child must be cutted

=== newfheapmeld ===

FORMULA: correct AND subop[current].id = newfheapmeld
MESSAGE: A OPERATION causes to create a new Fibonacci-Heap with a node of the value OPPARAM1 and meld it with the current Fibonacci-Heap.
MESSAGE: A SUBOPERATION is the correct operation.

---------------------------------------------------------------------------------------------------
FIRSTINCORRECT-KB:
---------------------------------------------------------------------------------------------------

=== link ===

FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete_min AND subop[current].param1 > subop[current].param2
FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete AND correctsubop[0].id = remove AND subop[current].param1 > subop[current].param2
MESSAGE: A link links always the bigger node to the smaller node, so that the bigger node is a child of the smaller node. Otherwise are the Heap-Constraints violated.

FORMULA: firstincorrect AND subop[current].id = link AND correctsubop[current].id = link AND op[current].id = delete_min AND subop[current].count = 1
FORMULA: firstincorrect AND subop[current].id = link AND correctsubop[current].id = link AND op[current].id = delete AND correctsubop[0].id = remove AND subop[current].count = 1
MESSAGE: You have to start with the link operation at the current min-pointer (blue arrow, must not be the minimum!), and go right through the sibling list. That means e.g. that the node (blue arrow) and his right sibling were the first candidates for a link operation.

FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete_min AND subop[current].param1.pre.rank != subop[current].param2.rank
FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete AND correctsubop[0].id = remove AND subop[current].param1.pre.rank != subop[current].param2.rank
MESSAGE: Two nodes from the rootlist were linked, only when they have the same outdegree. And this is here not the case.

FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete_min AND NOT Subop[current].param1.isroot AND NOT subop[current].param2.isroot
FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete AND correctsubop[0].id = remove AND NOT Subop[current].param1.isroot AND NOT subop[current].param2.isroot
MESSAGE: With such a operation you were able to generate any tree-structure you want, but this would violate the Fibonacci-Heap rules.
MESSAGE: A link-operation is only possible for nodes out of the rootlist. Both nodes you want to link are not in the rootlist.

FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete_min AND NOT subop[current].param1.isroot
FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete AND correctsubop[0].id = remove AND NOT subop[current].param1.isroot
MESSAGE: A link-operation is only possible for nodes out of the rootlist. Your first node is not from the rootlist.

FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete_min AND NOT subop[current].param2.pre.isroot
FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete AND correctsubop[0].id = remove AND NOT subop[current].param2.pre.isroot
MESSAGE: A link-operation is only possible for nodes out of the rootlist. Your second node is not from the rootlist.

FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete_min AND Subop[current].count = 1 AND subop[current-1].id != remove
FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete AND correctsubop[0].id = remove AND Subop[current].count = 1 AND subop[current-1].id != remove
MESSAGE: You started with a consolidate, but have forgotten something.
MESSAGE: To perform a consolidate is for OPERATIONID necessary, but you have forgotten to remove the minimum first.

FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete_min AND Subop[current-1].id = unmark AND subop[current-1].param1 = subop[current].param2
FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete AND correctsubop[0].id = remove AND Subop[current-1].id = unmark AND subop[current-1].param1 = subop[current].param2
MESSAGE: Normally the link-operation has to performed before you unmark the linked node. But it doesn't make any difference.

FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete_min AND correctsubop[current].id = link
FORMULA: firstincorrect AND subop[current].id = link AND op[current].id = delete AND correctsubop[0].id = remove AND correctsubop[current].id = link
MESSAGE: You have overlooked a link

FORMULA: firstincorrect AND subop[current].id = link AND op[current].id != delete_min AND op[current].id != delete
MESSAGE: A link is only required in DELETE_MIN or DELETE (MIN)

=== setkey ===

FORMULA: firstincorrect AND subop[current].id = setkey AND subop[current].param1 != op[current].param1
MESSAGE: You performed the setkey on the false node. The right node is OPPARAM1.

FORMULA: firstincorrect AND subop[current].id = setkey AND subop[current].param2 != op[current].param2
MESSAGE: You decreased the key to the false value. The correct value is OPPARAM2.

FORMULA: firstincorrect AND subop[current].id = setkey AND subop[current].param2 = subop[current].param1
MESSAGE: You decreased the key to its current value. So nothing has changed.

=== updatemin ===

FORMULA: firstincorrect AND subop[current].id = updatemin AND correctsubop[current].id != updatemin AND subop[1].id = updatemin AND subop[0].id = remove AND op[current].id = delete
MESSAGE: OPERATION needs a consolidate, because the minimum was removed!
MESSAGE: Updates of the minimum-pointer are always at the end of an operation.

FORMULA: firstincorrect AND subop[current].id = updatemin AND correctsubop[current].id != updatemin AND subop[1].id = updatemin AND subop[0].id = remove AND op[current].id = delete_min
MESSAGE: OPERATION needs a consolidate!
MESSAGE: Updates of the minimum-pointer are always at the end of an operation.

off FORMULA: firstincorrect AND subop[current].id = updatemin AND correctsubop[current].id != updatemin
off MESSAGE: Updates of the minimum-pointer are always at the end of an operation.

FORMULA: firstincorrect AND subop[current].id = updatemin AND correctsubop[current].id = updatemin AND subop[current].param1 != min
MESSAGE: Thats not the minimum of the Fibonacci-Heap.

off FORMULA: firstincorrect AND subop[current].id = updatemin AND correctsubop[current].id = updatemin AND subop[current].param1 = min
off MESSAGE: Thats already the minimum. So nothing has changed.

=== mark ===

off FORMULA: firstincorrect AND subop[current].id = mark AND correctsubop[current+1].id = cut AND correctsubop[current+1].param1.parent = subop[current].param1
off MESSAGE: Normally the node is marked after the cut-Operation, but this doesn't make any difference.
--> funktioniert nicht, da correctsupop[current+1].param1.parent nicht geht (kein Zugriff auf zukünftiges parent möglich)

FORMULA: firstincorrect AND subop[current].id = mark AND subop[current].param1.isroot AND subop[current-1].param1.pre.parent = subop[current].param1
MESSAGE: The mark-state makes no difference in the rootlist, therefore a mark-Operation is not necessary.

FORMULA: firstincorrect AND subop[current].id = mark AND subop[current].param1.ismarked AND subop[current].param1.pre.ismarked
MESSAGE: That node is already marked. So nothing changed.

=== unmark ===

FORMULA: firstincorrect AND subop[current].id = unmark AND subop[current].param1.isRoot
MESSAGE: The mark-state makes no difference in the rootlist, therefore a unmark-Operation is not necessary.

FORMULA: firstincorrect AND subop[current].id = unmark AND correctsubop[current+1].id = link AND correctsubop[current+1].param2 = subop[current].param1
MESSAGE: Normally a unmark-operation have to performed after the link-Operation. But thats make no difference.

FORMULA: firstincorrect AND subop[current].id = unmark AND NOT subop[current].param1.ismarked AND NOT subop[current].param1.pre.ismarked
MESSAGE: That node is already unmarked. So nothing changed.

=== remove ===

FORMULA: firstincorrect AND subop[current].id = remove AND NOT subop[current].param1.pre.isRoot
MESSAGE: Remove is only possible for nodes in the rootlist. If you want to remove a inner node, you must cut it before.

FORMULA: firstincorrect AND subop[current].id = remove AND correctsubop[current].id = mark
MESSAGE: A node must be immediatly marked, when he looses a child

FORMULA: firstincorrect AND subop[current].id = remove AND correctsubop[current].id = remove AND op[current].id = delete_min AND subop[current].param1 != min
MESSAGE: You have to remove the minimum node!

FORMULA: firstincorrect AND subop[current].id = remove AND subop[current-1].id != cut AND correctsubop[current].id = cut AND op[current].id = delete
MESSAGE: A to removed inner node has to be cut before he can removed

FORMULA: firstincorrect AND subop[current].id = remove AND subop[current-1].id = cut AND correctsubop[current].id = cut AND op[current].id = delete
MESSAGE: If a marked node looses a child, he must be cut!

FORMULA: firstincorrect AND subop[current].id = remove AND correctsubop[current].id = remove AND op[current].id = delete
MESSAGE: You have to remove OPPARAM1

=== newfheapmeld ===

FORMULA: firstincorrect AND subop[current].id = newfheapmeld AND correctsubop[current].id = newfheapmeld AND subop[current].param1 != correctsubop[current].param1
MESSAGE: Thats not the correct value. You have to perform OPERATION.

=== cut ===

FORMULA: firstincorrect AND subop[current].id = cut AND op[current].id = delete_min AND subop[current].param1.parent = min
MESSAGE: To delete the minimum node, you dont have to cut the minimum's node children.

FORMULA: firstincorrect AND subop[current].id = cut AND subop[current-1].id = cut AND subop[current-1].param1.parent = subop[current].param1 AND subop[current].count > 1 AND NOT subop[current].param1.pre.ismarked
MESSAGE: This node is not qualified for a cut operation, because he was not marked when he lost a child.

FORMULA: firstincorrect AND subop[current].id = cut AND op[current].id = decrease_key AND subop[current].count = 1 AND subop[current].param2 > subop[current].param1.pre.parent
MESSAGE: If a node's value is not decreased under the value of its parent node, he doesn't have to cutted.

FORMULA: firstincorrect AND subop[current].id = cut AND subop[current].param1.pre.isroot
MESSAGE: A cut on a node from the rootlist has no effect. If you want to remove the node, choose the remove-Operation.

FORMULA: firstincorrect AND subop[current].id = cut AND subop[current-1].id = mark AND subop[current-1].param1 = subop[current].param1.parent
MESSAGE: Normally a cut should be performed before his parent ist marked. But this doesn't make any difference.

FORMULA: firstincorrect AND subop[current].id = cut AND subop[current-1].id = setkey AND subop[current-1].param2 > subop[current-1].param2.parent
MESSAGE: If a node is decreased to value that is greater than his parent, the node do not have to be cutted.

=== general/incorrect ===

FORMULA: firstincorrect AND op[current].id = decrease_key AND subop[current-1].id = setkey AND subop[current].id != cut
MESSAGE: Missing cut. A node whose value is decreased under the value of its parent node must be cutted.

FORMULA: firstincorrect AND subop[current-1].id = cut AND NOT subop[current-1].param1.parent.isroot AND subop[current-1].param1.pre.parent = subop[current].param1 AND subop[current].id != mark
MESSAGE: Missing mark. If a node looses a child and is not in rootlist, must be marked.

FORMULA: firstincorrect AND subop[current-1].id = link AND subop[current-1].param2.ismarked AND subop[current].id != unmark
MESSAGE: Missing unmark. if a node becomes child of another node, and he is marked, he must be unmarked!

FORMULA: firstincorrect AND op[current].id = decrease_key AND subop[0].id != setkey
MESSAGE: Missing setkey. A decrease-key Operation needs a setkey SubOperation.

FORMULA: firstincorrect AND op[current].id = delete_min AND subop[current-1].id != updatemin AND correctsubop[current-1].id = updatemin
MESSAGE: Missing updatemin. If the minimum node is deleted, you must update the minimum.

FORMULA: firstincorrect AND subop[current-1].id = cut AND NOT subop[current-1].param1.parent.isroot AND subop[current-1].param1.parent.ismarked
MESSAGE: Missing cut. If a marked node looses a child, he must be cutted.

---------------------------------------------------------------------------------------------------
MISSING-SUBOPERATIONS-KB: (e.g. after pressing Finish-Operation in WorkEditor)
---------------------------------------------------------------------------------------------------

FORMULA: missingsubop AND correctsubop[current+1].id = updatemin AND op[current].id = delete
FORMULA: missingsubop AND correctsubop[current+1].id = updatemin AND op[current].id = delete_min
MESSAGE: Missing updatemin. If the minimum node is deleted, you must update the minimum at end.

FORMULA: missingsubop AND correctsubop[current+1].id = updatemin AND op[current].id = insert
MESSAGE: Missing updatemin. If a new minimum is inserted, you must update the minimum at end.

FORMULA: missingsubop AND op[current].id = delete AND subop[current].id = remove
MESSAGE: A DELETE of the minimum is equivalent to a DELETE_MIN, therefore you have to do a consolidate.

FORMULA: missingsubop AND op[current].id = delete_min AND subop[current].id = remove
MESSAGE: A OPERATIONID causes to perform a consolidate!

FORMULA: missingsubop AND op[current].id = delete AND subop[current].id = link AND correctsubop[current+1].id = link
FORMULA: missingsubop AND op[current].id = delete_min AND subop[current].id = link AND correctsubop[current+1].id = link
MESSAGE: Missing link. You have not performed all necessary link-operations.

FORMULA: missingsubop AND op[current].id = delete AND correctsubop[current+1].id = remove
MESSAGE: You have forgotten to remove the node OPPARAM1!

FORMULA: missingsubop AND op[current].id = decrease_key AND subop[current].id = setkey AND correctsubop[current+1].id = cut
MESSAGE: Missing cut. If a node is decreased below his parent node's value, he must be cutted.
