What does #False executing krun mean?

When executing krun on a sample program for a lambda calculus, I get #False as an output. What does this mean?

[dwightguth]

.K is the unit of the list type that the K sort represents whose cons operator is ~>. We allow users to write terms of sort K as if they were an associative list, but it’s actually implemented as a cons list under the hood and matching elements off the tail is not supported (for that, you need the List sort).

I don’t believe we have a way to output the entire configuration instead of a substitution, but if you write a pattern that completes to the top cell with no anonymous variables, you can of course infer the entire configuration from the substitution.

#And means that there are multiple variables in the substitution and the conjunction of all of them is a single search result. #True means that the pattern matched but generated the empty substitution. A term like isKResult(V0) ==K true in the substitution means that you have some symbolic term that ended up in the output substitution but was unable to be fully resolved.

[dwightguth]

I figured out why you’re seeing this behavior. This is actually the correct behavior of krun for this scenario, although in this case it is occurring due to what I believe to be a bug in your semantics, which you should now be able to fix.

The problem here is the rule rule fail ~> _ => fail. This rule desugars into the following:

rule <T> <k> fail ~> Var1 ~> Var2 </k> </T> => <T> <k> fail ~> Var2 </k> </T>

In this case, if Var1 and Var2 are both .K, then this is equivalent to the following rule:

rule <T> <k> fail </k> </T> => <T> <k> fail </k> </T>

As you can see, this is rewriting the current term to itself. In this case, because the configuration is not changing at all, krun was able to detect that rewriting didn’t terminate, and so it returned #False, indicating that there exist no output states for this input configuration. Perhaps there should be a nicer message here, but krun is technically behaving soundly.

I believe what you meant to write was the following:

rule <k> fail ~> K:K => fail </k> requires K =/=K .K