Building clpBNR constraints at runtime

Help!
1

I’m using:

SWI-Prolog version 9.3.21-34-gbfbbc23db

I want the code to:

build a clpBNR constraint at runtime

But what I’m getting is:

starting from a list, I don’t know how to handle variable identifiers in building the constraint term.

My code looks like this:

The user would give the application two inputs:

  1. a list of pairs of the form [atom-atomOrVariable ..., where the 1st member is an identifier name, and the potentially not grounded 2nd member is its value. This list is obtained from R at runtime.
  2. a boolean expression using identifiers from (1), that I’d like to turn into a clpBNR constraint. The expression is typed by the user into an R GUI and sent to SWI.
%I am able to read a term from input and make a constraint...
read_constraint(Y):-
    open('../read_constraint.txt', read, Str),
    read_term(Str,Constraint,[variable_names(['X'=Y])]),
    close(Str),
    {Constraint}.

%... but I am  having trouble building a suitable term from my input list
substitute_formula_([],[],F,F).
substitute_formula_([Name|Names],[Value|Values],F,S):-
    select(Name,F,Value,F1),!,
    substitute_formula_(Names,Values,F1,S).
substitute_formula(Row,Formula,Substituted):-
    pairs_keys_values(Row,Names,Values),
    substitute_formula_(Names,Values,Formula,Substituted).

Example

?- substitute_formula([potassium-P,glucose-130],[glucose,'>',120,and,potassium,'<',5.0],S).
S = [130, >, 120, and, P, <, 5.0].

Now here’s my problem: how do I build the constraint term from list S to constrain P ? I am able to build a constraint starting from an atom such as 'X>1', but list S contains variables. Do I need to get the variable names as atoms and use atomic_list_concat/2 ? Or is there another strategy entirely ?

Thanks!

2

Example: clpBNR: difference constraint on reals - #17 by ridgeworks

3

I’m curious to know why does R return a boolean expression as a list ?
Naively, it seems like your list is some sort of deep walk (or a flattenning) of your arithmetic tree ?

So, maybe if we write a depth first walk of an arithmetic expression, you’ll be able to recover your original expression ?

:- use_module(library(clpBNR)).
:- table deep_walk//1.

deep_walk(X) -->
   [X], {number(X)}.
deep_walk(X) -->
   [X], {atom(X)}.
deep_walk(A<B) -->
   deep_walk(A), [<], deep_walk(B).
deep_walk(A>B) -->
   deep_walk(A), [>], deep_walk(B).
deep_walk(A and B) -->
   deep_walk(A), [and], deep_walk(B).

This code is just a starting point, notably, it does not implement operator priorities.
Moreover, since the grammar is left recursive, it needs tabling to work properly.

But you can already do something that works:

replace(Pairs, Key, Value) :-
   memberchk(Key-Value, Pairs).

?- phrase(deep_walk(Expr), [glucose,'>',120,and,potassium,'<',5.0]),
   mapsubterms(replace([glucose-130, potassium-P]), Expr, Constraint),
   {Constraint}.
Expr = (glucose>120)and(potassium<5.0),
Constraint = (130>120)and(P<5.0),
P::real(-1.0Inf, 4.999999999999999) .

mapsubterms/3 is a very useful predicate that I have recently discovered and is just perfect for your use case :slight_smile:
Note that mapsubterms/3 also works with lists, so you can actually do the substitution before the deep walk.

4

By the way, if you have some freedom in how your expression list is built, you could use reverse polish notation to simplify the grammar drastically:

deep_walk(X) -->
   [X], {number(X)}.
deep_walk(X) -->
   [X], {atom(X)}.
deep_walk(A<B) -->
   [<], deep_walk(A), deep_walk(B).
deep_walk(A>B) -->
   [>], deep_walk(A), deep_walk(B).
deep_walk(A and B) -->
   [and], deep_walk(A), deep_walk(B).

With this, you don’t need tabling and operator priorities is built in the list:

?- phrase(deep_walk(Expr), [and, >, glucose, 120, <, potassium, 5.0]),
   mapsubterms(replace([glucose-130, potassium-P]), Expr, Constraint),
   {Constraint}.
Expr = (glucose>120)and(potassium<5.0),
Constraint = (130>120)and(P<5.0),
P::real(-1.0Inf, 4.999999999999999) ;
false.
5

The quick and dirty solution, which does not work with your example because of operator priority ambiguity:

?- atomic_list_concat([glucose,'>',120,and,potassium,'<',5.0], ' ', A).
A = 'glucose > 120 and potassium < 5.0'.

?- read_term_from_atom($A, T, []).
ERROR: Syntax error: Operator priority clash
ERROR: glucose 
ERROR: ** here **
ERROR: > 120 and potassium < 5.0 . 

?- atomic_list_concat(['(', glucose,'>',120, ')',and,'(', potassium,'<',5.0, ')'], ' ', A),
read_term_from_atom(A, T, []).
A = '( glucose > 120 ) and ( potassium < 5.0 )',
T = (glucose>120)and(potassium<5.0).
6

I was hoping to avoid parsing the expression on the R side, since I’m a pretty weak programmer. But it seems R actually has features to do that rather easily, so your solution seems to fit my needs. Thank you !