mat

Let us unfreeze the room pre-emptively!

One thing seems clear: Even if you run it as is, you get error messages in Try it online: "Type error: character_code' expected, found -1' (an integer)". So, it seems to have problems with this input in the first place. I recommend you also try it on the terminal for comparison.

you cane use once/1 to restrict yourself to the first answer!

Is everything alright?

You can use string_code/3. But overall, I recommend to simply set double_quotes to chars, and forget about strings. It is much nicer to work on lists of characters.

Maybe use ignore/1?

@Michelle: you need a separate utility to write files. For example, try Emacs! You can then consult these files in Prolog.

@dzalma: You are doing "generate and test", which tries many, many possibilities that can never be completed to a solution. It should be quite easy to turn this to "constrain and enumerate", by first stating the relevant constraints, and then trying values. Constraints can significantly prune the search space much earlier.

In my opinion, the textual tracer is unusable. In SWI-Prolog, try the graphical debugger: ?- gtrace, your_goal.

In SWI-Prolog, you can use ?- help(foldl/4).

@Laikoni: Yes, that's one way to solve it! And interestingly, you can express both clauses with a single auxiliary predicate over which you can use foldl/4, and retain the determinism.

Regarding the performance, I suggest for example the following query: ?- time((between(1, 1 000 000,_), X is 1+3, false))., and then to replace "is" by "#=". In recent SWI versions, I measure about 11% overhead.

@DLosc: Using CLP(FD), you can shave off 4 bytes from this: P#=N-1 and also F#=G*N.

ascending_([], _). and further: ascending_([L|Ls], L0) :- ... I leave the rest as a challenge. An advantage of this way to formulate the task is that the predicate is deterministic if the list is already fully instantiated. This means that it will succeed without leaving choice-points if the argument is a list of ascending (instantiated) integers.

Second, what about the following: The empty list is ascending, i.e., ascending([]). holds. Next, what about lists with one element: ascending([L|Ls) :- ascending_(Ls, L). For this, we now consider an auxiliary relation:

Regarding sorted/1, I have a few comments: First, the name "sorted" is rather imperative (at least it is a form of a verb). It suggests that "someone has done something", not that "something is of some kind", which would be a more declarative view. So, I would first suggest a more declarative name. For example, what about ascending/1 ?

As another example, consider "all lists with 3 elements": Xs = [,,_]. Again, an answer, describing infinitely many solutions, such as [a,a,a], [a,a,b], [f(1),3,-] etc. When you say length(Xs, 3), you post one constraint: Xs has 3 elements. But nothing further!

To produce concrete solutions (if there are any), you have to actually use the enumeration predicates like labeling/2. Only this will guarantee to produce concrete solutions, using exhaustive search. As long as there are pending constraints (like in your X in -8\/8 example) there may have one, more or even no solutions.

Conversely, We can say for example X #> Y, X #< Y, and the constraint solver will report this as an answer. But there are no concrete integers that satisfy these constraints! This is because the constraint solver is incomplete: It cannot derive everything that does or cannot hold. This is necessarily so, because constraints over integers are actually undecidable!

CLP(FD) lets us carry over this notion with the additional restriction that the domain is the set of integers. For example, when we get as answer X in inf..sup, then X must be an integer, but there are still infinitely many. So X = 0, X = 1, X = -1 are all concrete solutions that are described by this answer.

@LeakyNun: It it actually quite the same in plain Prolog. The key issue is the difference between answers and solutions. We call it a solution if it is a concrete, ground value. But one answer may describe many, even infinitely many solutions, or even none at all. For example, in plain Prolog, consider the answer you get for X = f(Y). This is an answer. But concrete solutions are: Y = a, Y = b, Y = c, ... so this one term f(Y) describes infinitely many concrete solutions.

You will, in due time.

Yes, when you reach a certain age you get automatically blurred on stackexchange.

It would have been tough financially given that I had not even finished my military service when you all were born...

thank you! the new fork construct is great!

Malheureusement, le père de Prolog est décédé.

binaire.blog.lemonde.fr/2017/05/18/prolog-est-orphelin

that's OK ;-) one day you may be able to learn a living from these new abilities. So, have fun, and thank you for sharing many interesting snippets!

that's OK. everything that's worth learning takes ages.

Java code sucks balls in any case, so one remaining recommendation I have: if possible, use Prolog to either translate or interpret the Brachylog code. A DCG might be useful for parsing the program and obtain a syntax tree, and once you have that available, further analysis is a lot easier to do in Prolog. So, I hope this helps, and I'm very interested in seeing what you will come up with. Enjoy!

in any case, there are several possible solutions for this. One is make an explicit labeling also avaiable. another is to have special primitives for writing.

even better of course would be a way to integrate side-effects in a purer way, maybe you can come up with something very interesting for this.

you will certainly have to analyze the given program in some way, but I think it would be doable at least for a very useful subset of programs.

that would be doable I think. use an implicit labeling/2 before side effects.

And then,simply label all remaining CLP(FD) variables automaticall. This is always a valid operation to do.

Then, filter the CLP(FD) variables from that list, using include(fd_var, Ls0, Ls).

I would do it like this: wrap the whole Brachylog execution into a call of call_residue_vars/2. This yields the list of variables that are still involved in constraints after the goal has finished.

For labeling, you can simply label everything implicitly at the end!

first, float would require different operators (which it also currently does: compare CLP(FD) and CLP(Q) syntax).

Hi Fatalize!