Thomas agreed with the changes and the experiments showed no signs of errors 
(http://ai.cs.unibas.ch/_tmp_files/seipp/issue650-v2-issue650-base-issue650-v2-
compare.html for 
reference) so I merged and pushed the branch.

For reference, the error happened in depot:pfile1. After our offline discussion, I have 
changed the code to use -INF for the minimum cost. Do you agree with the implementation and 
the comments?

https://bitbucket.org/jendrikseipp/downward/commits/f65080f83d500e1b4a1d95e374b40b5492d02c4e

Could you provide some of the instance names where the error occured? If there
are errors with INF, something is wrong with MAX_COST_VALUE too and we should
make sure that doesn't happen. I suspect that the A* implementation doesn't
check for operators with cost INF / MAX_COST_VALUE, which it should since
otherwise we compute (finite) sums that involve infinity.

Thanks!

Using -INF instead of -MAX_COST_VALUE produced some over-/underflow errors and 
the code is easier to read with -MAX_COST_VALUE, so I reverted the change. I'm 
currently running experiments to check that we didn't miss anything.

I had another look at it and it looks good.

Thanks for your comments, Thomas! Can you have another look at the pull request, 
please?

I am fairly certain that we can set the saturated costs of those operators to
-\infty, but I don't think it matters since it should only occur between dead
end states in all abstractions anyway.

I don't know enough about the context, but from the little I can see, all
transitions affecting unreachable states could be treated as if they don't exist
at all. Whether that's the same as setting their cost to -\infty depends on the
context of all this; I can't really say much about it without diving into this
much more deeply. (Which I can't do in the near future.)

I thought about this and believe that we could indeed set the saturated costs of 
an operator that only occurs between two abstract dead end states to -
MAX_COST_VALUE, because we can distribute the costs arbitrarily in a cost 
partitioning. Do you both agree?

Thanks Thomas, I had a look at your implementation. You can find mine at 
https://bitbucket.org/jendrikseipp/downward/pull-requests/48

Could you please check whether it's correct?

Let me copy a comment I made in the code:

"Note: Currently, we set the saturated costs of operators
between two dead end states to at least 0 (INF - INF). It is
unclear whether we can lower the saturated costs to
-MAX_COST_VALUE and still be admissible."

What's your take on this? If you want we can also discuss this tomorrow in 
person.

My implementation for the same issue in the saturated state-dependent saturated
cost partitioning branch initializes the saturated cost of each operator as
-MAX_COST_VALUE, and then loops over all outgoing arcs and all self loops of all
states and updates the saturated cost by replacing it with the maximum of the
current value and the difference of the h-values of the states that connect the
corresponding arcs (see lines 477 to 498 in abstraction.cc of the cegar-sdac
branch, revision 9146).

Best,
Thomas

We'd like to move the  saturated cost computation out of the A* search code and 
maintain goal distances only for reachable states.