Answers terminology

[bakaq]

(Response to @triska's comment #2490 (comment))

Thank you a lot for expaining! I have some points I want to make though. First, which of those definitions are well established (like "goal", which is defined in the standard so there is no ambiguity there) and which are not consistently used? I think we should pick some terminology to be consistent even if it is not well established, but I feel knowing what those are so that we can point it out in documentation (maybe it means something else in other contexts) is very important.

then, in addition to the entire answer, each of the disjuncts is also called an answer! We currently lack the terminology to properly distinguish these cases!

This is very unfortunate, because this is precisely the distinction that we will need to make in the library interface. I feel that "answer" to mean one disjunct and "answer set"/"complete answer" to mean the whole disjunction would make the most sense to me, but as "answer" is already used to mean both, I think it's best if we used something like "answer line" for the disjunct and "complete answer" for the whole disjunction (please suggest better names if you can think of any!).

A solution is an answer that grounds all variables that appear in the query.

There is an ambiguity here. Is the "answer" here an answer line or a complete answer? I think a solution being a grounded answer line makes more sense. Is X = 1; X = 2 a solution or a set of solutions?

An answer can also be an exception, reported (as all cases above) as a goal; a goal that yields that exception.

Well, that currently isn't actually the case in Scryer. If you throw an error, then the correspondent answer line is not a goal that throws an error. Is this intentional or should I file an issue?

?- X = 1 ; throw(not_error).
   X = 1
;     throw(not_error). % Actually throws error
?- X = 1 ; throw(error(_,_)).
   X = 1
;     error(_41,_42).
?- X = 1; error(_41, _42).
   X = 1
;     error(instantiation_error,error/2). % Not equivalent!!!

An answer may also include residual goals. Since all answers (including answer substitutions) are goals, one could all classify them as "residual goals", but we normally use "residual goals" only to mean pending constraints that are not trivial in the sense that: they are not answer substitutions. An example of a residual goal is dif(X, f(b)). Residual goals may occur by themselves, or together with answer substitutions.

Ok, but this assumes that residual goals are always constraints. I think they should be, but I can also see use cases for residual goals which aren't constraints. Funny one:

?- X = 1, comment("Comment in answers!"); X = 2.
   X = 1, "Comment in answers! ..."
;  X = 2.
% Now that I implemented this and used it a bit, I think it could
% actually be _very_ useful for both teaching and debugging.
% And I think a string isn't even a goal, so this isn't even technically
% a "residual goal", but just wrapping it in comment/1 would fix that.
% Should we add a check to attribute_goals//2 that ensures it generates
% valid goals?

An answer that contains residual goals is also called a conditional solution, because it only implies solutions if the residual constraints can be satisfied.

Wouldn't "conditional (complete answer|answer line)" be more appropriate? I don't think the resolution of the constraints needs to be grounded in this case, so it would be more consistent with the previous definition of "solution".

[UWN]

In 13211-1:1995 the word answer is used three times. Once unrelated that a user has to answer (7.10.210 Note 1) and then twice to mean what we mean here. So

• negative answer (7.7.1 a) and
• positive answer in an implementation defined form (7.7.1 b)

However, in logic programming the notion of answer substitution is very common. But answer substitutions represent one or more even infinitely many solutions (and in the case of an STO unification and also constraints they may also represent no solution),

I'd say, that

?- X=1;X=1.
   X = 1
;  X = 1.

describes one solution (even if the current standard would call this two solutions, but only indirectly because of the general introduction in 8.10 and similarly indirectly qua 7.7.3 note). In the codex there are 23 occurrences of solution. But its meaning is still flaky. I sometimes call in above query the second "solution" a redundant solution. I am a bit biased here from German where there is no satisfying translation of unique which smoothly works in French and English. But then I realized that unique solution really means solution. The uniqueness is only an artefact of the way Prolog executes a query. But it has nothing to do with the meaning as such.

Looking a bit in the neighborhood of Prolog there is the notion of an answer set. From that viewpoint, Prolog produces one answer only. Even if we often do not want to look at the entire answer.

So what do we call these above two answer substitutions? Not sure, but it seems this is the missing notion.

[jjtolton]

I suppose "set of bindings" is out of the question?

[UWN]

"set of bindings"

That is answer substitution. But we want more than that. That also constraints are included.

[UWN]

... and the notion of answer constraint like answer substitution exists also, example usage. So both together without any disjunction...

[jjtolton]

"set of bindings"

That is answer substitution. But we want more than that. That also constraints are included.

Ahh, yes, good point. That's very tricky!

... and the notion of answer constraint like answer substitution exists also, example usage. So both together without any disjunction...

I'm a little confused about the example usage? 😰

[UWN]

Just /answer constraint/ in it

[UWN]

I think a string isn't even a goal

?- [a]. % string
   error(existence_error(source_sink,"a.pl"),open/4).

[bakaq]

I guess this means that a string is indeed a goal? By the way, what is the difference between a goal and a callable? From reading the standard I haven't been able to tell. For example:

?- "abc".
   % This seems to imply that "abc" is a goal 
   error(existence_error(procedure,a/0),a/0).
?- call("abc").
   % This, however, implies that "abc" isn't callable.
   error(type_error(callable,"abc"),call/1).

[UWN]

A string is a list of characters. Thus for the non-empty case the principal functor is '.'/2. And many Prologs offer this an an implementation specific extension which means to prepare for execution all files that are mentioned in the list. In Scryer, only the first is taken, though.

[UWN]

?- X = 1 ; throw(error(_,_)).
   X = 1
;     error(_41,_42), non_normative.

7.12.1 states that the first argument is a term that supplies information
about the error and 7.12.2 enumerates such information. Above is thus non-conforming. Now you might argue that 7.12 is only about errors you want to throw error/2 for educational purposes only. Not for indicating errors. Well ... . I'd say the way how it is presented is good enough.

[bakaq]

Oh, it seems that when the error is conforming to 7.12.1, this actually works:

?- throw(error(instantiation_error,_)).
   error(instantiation_error,_42).
?- error(instantiation_error,_42).
   error(instantiation_error,_42). % Equivalent!

Isn't this basically defining a predicate error/2? I don't know if that would be considered conforming.

[UWN]

After another discussion with Markus: leaf answer

[UWN]

So a leaf answer may be, an answer substitution with or without answer constraints, but also just false, (or an error)

[bakaq]

This is very good!!! Thank you a lot!

[UWN]

So effectively 'leaf' is not an adjective but serves the very same purpose:

?- X = 1 ; X = 2.
   X = 1
; ... .

So the first answer, or more precisely the first leaf answer, is 1 which happens to be also a solution The ... reminds us that this is an incomplete answer. We need to continue to get the complete answer.

?- X = 1 ; X = 2.
   X = 1
;  X = 2.

So the complete answer consists of two leaf answers.

[UWN]

See this correction #2615 that false is not a leaf answer.