As/atoms

CHANGES.md

@@ -2,6 +2,11 @@
 
 ## Ongoing
 
+- raise warning `atom(syntaxError)` when an execution, optimize, or preference
+  atom is malformed
+- rename `forbid_warning` and `ignore_warning` to `warning_forbid` and
+  `warning_ignore`; allow an optional label argument for `warning_ignore`
+- raise warning `statement(syntaxError)` when a statement is malformed
 - Use `bad` instead of `none` for set operator python evaluation
 - Update CI to run fewer smoke tests and to test only one configuration on
   routine commits. Enable caching for routine commit tests.
@@ -19,7 +24,7 @@
   `variable_declareOptional`, if unspecified, it defaults to the label of the
   corresponding `variable_declare` atom.
 - introduce optional label argument to `evaluate`
-- raise warning `expression(syntax)` when an expression is malformed
+- raise warning `expression(syntaxError)` when an expression is malformed
 - `evaluate` declarations now also generate expression-related warnings
 - Introduce warning `variable(badValue)` that is emitted when the value of some
   variable is bad

docs/developer/fact-format.md

@@ -151,9 +151,10 @@ This page describes the EBNF grammar for the fact format used by the constraint
     | "preference_variableValue" "(" <term> "," <term> "," <expression> "," <int> ")"
 
 <warning-control-atom> ::=
-    | "ignore_warning" "(" <term> ")"
-    | "forbid_warning" "(" <term> ")"
-    | "forbid_warning" "(" <term> "," <term> ")"
+    | "warning_forbid" "(" <term> ")"
+    | "warning_forbid" "(" <term> "," <term> ")"
+    | "warning_ignore" "(" <term> ")"
+    | "warning_ignore" "(" <term> "," <term> ")"
 
 <atom> ::=
     | "assign" "(" <term> "," <expression> ")"

docs/fact-format/fact-format.tex

@@ -155,9 +155,10 @@ \subsection{Building facts and declarations}
 \alt `preference_variableValue' `(' <term> `,' <term> `,' <expression> `,' <int> `)'
 
 <warning-control-atom> ::=
-~\alt `ignore_warning' `(' <term> `)'
-\alt `forbid_warning' `(' <term> `)'
-\alt `forbid_warning' `(' <term> `,' <term> `)'
+~\alt `warning_forbid' `(' <term> `)'
+\alt `warning_forbid' `(' <term> `,' <term> `)'
+\alt `warning_ignore' `(' <term> `)'
+\alt `warning_ignore' `(' <term> `,' <term> `)'
 
 <atom> ::=
 ~\alt `assign' `(' <term> `,' <expression> `)'

docs/reference/error_handling.md

@@ -75,10 +75,10 @@ warning(Type, Labels, Details)
 ## Ignore Warning
 **[Declaration]**{.badge .declaration }
 
-Users have the option to ignore specific warnings by using the `ignore_warning/1` predicate. This allows users to suppress warnings that they are aware of and do not wish to be notified about.
+Users have the option to ignore specific warnings by using the `warning_ignore/1` predicate. This allows users to suppress warnings that they are aware of and do not wish to be notified about.
 
 ```prolog
-ignore_warning(WarningType)
+warning_ignore(WarningType)
 ```
 
 | Name | Description |
@@ -89,7 +89,7 @@ ignore_warning(WarningType)
     To ignore warnings about variables with confusing names, you can use:
 
     ```prolog
-    ignore_warning(variable(confusingName)).
+    warning_ignore(variable(confusingName)).
     ```
 
     This will suppress any warnings of the type `variable(confusingName)` from being reported in the future.
@@ -99,13 +99,13 @@ ignore_warning(WarningType)
 ## Forbid Warning
 **[Declaration]**{.badge .declaration } **[Label Support]**{.badge .label-support }
 
-Users can also choose to forbid specific warnings using the `forbid_warning/1` predicate. This means that if a forbidden warning is encountered, it will be treated as a failed constraint.
+Users can also choose to forbid specific warnings using the `warning_forbid/1` predicate. This means that if a forbidden warning is encountered, it will be treated as a failed constraint.
 
 !!! Info
     Ignored warnings cannot be forbidden, and vice versa. If a warning type is both ignored and forbidden, it will be treated as ignored.
 
 ```prolog
-forbid_warning(WarningType)
+warning_forbid(WarningType)
 ```
 
 | Name | Description |
@@ -116,7 +116,7 @@ forbid_warning(WarningType)
     To forbid warnings about variables with empty domains, you can use:
 
     ```prolog
-    forbid_warning(variable(emptyDomain)).
+    warning_forbid(variable(emptyDomain)).
     ```
 
     This will cause any warning of the type `variable(emptyDomain)` to be treated as an error, and it will prevent the model from being generated if such a warning is encountered.

src/constraint_handler/data/atom.lp

@@ -55,57 +55,108 @@ optimize_maximizeSum(_label_anonymous,E,X,P) :- optimize_maximizeSum(E,X,P).
 optimize_maximizeSum(_label_anonymous,E,X,0) :- optimize_maximizeSum(E,X).
 
 %%%%%% preference atoms
+#defined preference_holds/3.
 #defined preference_holds/2.
 #defined preference_holds/1.
+#defined preference_variableValue/4.
 #defined preference_variableValue/3.
 #defined preference_variableValue/2.
-preference_holds(_label_anonymous,E,K) :- preference_holds(E,K).
-preference_variableValue(_label_anonymous,X,E,K) :- preference_variableValue(X,E,K).
-%%% convenience
-preference_holds(_label_anonymous,E,1) :- preference_holds(E).
-preference_variableValue(_label_anonymous,X,E,1) :- preference_variableValue(X,E).
+_passed(defaultArgs,preference_holds(LBL,E,K)) :- preference_holds(LBL,E,K).
+_passed(defaultArgs,preference_holds(_label_anonymous,E,K)) :- preference_holds(E,K).
+_passed(defaultArgs,preference_holds(_label_anonymous,E,1)) :- preference_holds(E).
+_passed(defaultArgs,preference_variableValue(_label_anonymous,X,E,K)) :- preference_variableValue(X,E,K).
+_passed(defaultArgs,preference_variableValue(LBL,X,E,K)) :- preference_variableValue(LBL,X,E,K).
+_passed(defaultArgs,preference_variableValue(_label_anonymous,X,E,1)) :- preference_variableValue(X,E).
 
 %%%%%% warning atoms
-#defined forbid_warning/1.
-#defined ignore_warning/1.
-
-forbid_warning(_label_anonymous,KIND) :- forbid_warning(KIND).
+#defined warning_forbid/1.
+#defined warning_ignore/1.
 
+warning_forbid(_label_anonymous,KIND) :- warning_forbid(KIND).
+warning_ignore(_label_anonymous,KIND) :- warning_ignore(KIND).
 
 %%%%%%%%%%%%%%%%% collect labels
-_label(LABEL) :- ensure(LABEL,_).
-_label(LABEL) :- assign(LABEL,_,_).
+_label(LABEL) :- ensure(LABEL,E).
+_label(LABEL) :- assign(LABEL,X,E).
 _label(LABEL) :- define(LABEL,_,_,_).
-_label(LABEL) :- evaluate(LABEL,_,_).
+_label(LABEL) :- evaluate(LABEL,O,ARGS).
 
 %%%%%% variable atoms
-_label(LABEL) :- variable_define(LABEL,_,_).
-_label(LABEL) :- variable_declare(LABEL,_,_).
-_label(LABEL) :- variable_domain(LABEL,_,_).
+_label(LABEL) :- variable_define(LABEL,X,E).
+_label(LABEL) :- variable_declare(LABEL,X,D).
+_label(LABEL) :- variable_domain(LABEL,X,E).
 
 %%%%%% multimap atoms
-_label(LABEL) :- multimap_declare(LABEL,_).
-_label(LABEL) :- multimap_assign(LABEL,_,_,_).
+_label(LABEL) :- multimap_declare(LABEL,X).
+_label(LABEL) :- multimap_assign(LABEL,X,K,B).
 
 %%%%% set atoms
-_label(LABEL) :- set_declare(LABEL,_).
-_label(LABEL) :- set_assign(LABEL,_,_).
-_label(LABEL) :- set_baseDomain(LABEL,_,_).
+_label(LABEL) :- set_declare(LABEL,X).
+_label(LABEL) :- set_assign(LABEL,X,E).
+_label(LABEL) :- set_baseDomain(LABEL,X,E).
 
 %%%%%% statement atoms
-_label(LABEL) :- execution_declare(LABEL,_,_,_,_).
-_label(LABEL) :- execution_run(LABEL,_).
+_label(LABEL) :- execution_declare(LABEL,NAME,STMT,INS,OUTS).
+_label(LABEL) :- execution_run(LABEL,NAME).
 
 %%%%%% optimization atoms
 _label(LABEL) :- optimize_maximizeSum(LABEL,_,_,_).
 
 %%%%%% preference atoms
-_label(LABEL) :- preference_holds(LABEL,_,_).
-_label(LABEL) :- preference_variableValue(LABEL,_,_,_).
+_label(LABEL) :- _passed(defaultArgs,preference_holds(LABEL,E,K)).
+_label(LABEL) :- _passed(defaultArgs,preference_variableValue(LABEL,X,E,K)).
 
 %%%%%% warning atoms
-_label(LABEL) :- forbid_warning(LABEL,_).
+_label(LABEL) :- warning_forbid(LABEL,KIND).
+_label(LABEL) :- warning_ignore(LABEL,KIND).
 
 
 
 %%%%%%%%%%%%%%%%% check if well-formed
+_passed(sugar,ensure(LBL,E)) :- ensure(LBL,E), _expression_wellformed(E).
+_passed(sugar,evaluate(LBL,OP,ARGS)) :- evaluate(LBL,OP,ARGS), _expression_wellformed(operation(OP,ARGS)).
+
+
+_label(LABEL) :- define(LABEL,_,_,_).
+%_passed(sugar,assign(LABEL,X,E)) :- assign(LABEL,X,E), _expression_wellformed(E).
+
+
+%%%%%% multimap atoms
+_passed(sugar,multimap_declare(LBL,X)) :- multimap_declare(LBL,X).
+_passed(sugar,multimap_assign(LBL,X,K,B)) :- multimap_assign(LBL,X,K,B), _expression_wellformed(K), _expression_wellformed(B).
+
+%%%%% set atoms
+_passed(sugar,set_declare(LBL,X)) :- set_declare(LBL,X).
+_passed(sugar,set_assign(LBL,X,E)) :- set_assign(LBL,X,E), _expression_wellformed(E).
+_passed(sugar,set_baseDomain(LBL,X,E)) :- set_baseDomain(LBL,X,E), _expression_wellformed(E).
+
+%%%%%% statement atoms
+_passed(sugar,execution_declare(LBL,PRG,STMT,INS,OUTS)) :- execution_declare(LBL,PRG,STMT,INS,OUTS),
+    _statement_wellformed(STMT),
+	true=@pythonIsList(INS),
+	true=@pythonIsList(OUTS).
+_passed(sugar,execution_run(LBL,PRG)) :- execution_run(LBL,PRG).
+_warning(atom(syntaxError),(PRG,()),execution_declare(PRG)) :- execution_declare(LBL,PRG,STMT,INS,OUTS),
+    #false: _statement_wellformed(STMT), true=@pythonIsList(INS), true=@pythonIsList(OUTS).
+
+%%%%%% optimization atoms
+_passed(sugar,optimize_maximizeSum(LBL,E,X,P)) :- optimize_maximizeSum(LBL,E,X,P),
+    _expression_wellformed(E),
+    (number,_,_,_)=@pythonReify(P).
+_passed(sugar,optimize_precision(PREC,PRIO)) :- _passed(defaultArgs,optimize_precision(PREC,PRIO)),
+    _expression_wellformed(PREC),
+    (number,_,_,_)=@pythonReify(PRIO).
+_warning(atom(syntaxError),(),optimize_maximizeSum(LBL,E,X,P)) :- optimize_maximizeSum(LBL,E,X,P),
+    not _passed(sugar,optimize_maximizeSum(LBL,E,X,P)).
+_warning(atom(syntaxError),(),optimize_precision(PREC,PRIO)) :- optimize_precision(PREC,PRIO),
+    not _passed(sugar,optimize_precision(PREC,PRIO)).
+
+%%%%%% preference atoms
+_passed(sugar,preference_holds(LABEL,E,K)) :- _passed(defaultArgs,preference_holds(LABEL,E,K)), _expression_wellformed(E), (number,_,_,_)=@pythonReify(K).
+_passed(sugar,preference_variableValue(LABEL,X,E,K)) :- _passed(defaultArgs,preference_variableValue(LABEL,X,E,K)), _expression_wellformed(E), (number,_,_,_)=@pythonReify(K).
+_passed(sugar,preference_expressionScore(LBL,operation(eq,(variable(X),(E,()))),K)) :- _passed(sugar,preference_variableValue(LBL,X,E,K)), K > 0.
+_passed(sugar,preference_expressionScore(LBL,operation(neq,(variable(X),(E,()))),-K)) :- _passed(sugar,preference_variableValue(LBL,X,E,K)), K < 0.
+_passed(sugar,preference_expressionScore(LBL,E,K)) :- _passed(sugar,preference_holds(LBL,E,K)), K > 0.
+_passed(sugar,preference_expressionScore(LBL,operation(wnot,(E,())),-K)) :- _passed(sugar,preference_holds(LBL,E,K)), K < 0.
+
+%%%%%% warning atoms

src/constraint_handler/data/bool.lp

@@ -25,14 +25,14 @@ _operator_recoverable((conj;disj)).
 %_computedIdx(E,bool,true)  :- _computeIdx(E,conj), E=operation(conj,L), _se_value(E1,val(bool,true)) : E1=@pythonListElements(L).
 _computedIdx(E,val(bool,false)) :- _computeIdx(E,conj), _computeIdx(E,IDX,val(bool,false)).
 _computedIdx(E,val(bool,true))  :- _computeIdx(E,conj), _computeIdx(E,IDX,val(bool,true)) : _computeIdx(E,IDX,V).
-_computedIdx(E,bad) :- _computeIdx(E, conj), _computeIdx(E, _, bad), not _computedIdx(E, val(bool, false)).
+_computedIdx(E,bad) :- _computeIdx(E,conj), _computeIdx(E,IDX,bad), not _computedIdx(E,val(bool,false)).
 
 %_se_value(E,val(bool,true))  :- direct_query(E), E=operation(conj,L), _se_value(E1,val(bool,true)) : E1=@pythonListElements(L).
 %_se_value(E,val(bool,false)) :- direct_query(E), E=operation(conj,L), _se_value(E1,val(bool,false)), E1=@pythonListElements(L).
 
-_computedIdx(E,val(bool,true)) :- _computeIdx(E,disj), _computeIdx(E,_,val(bool,true)).
+_computedIdx(E,val(bool,true)) :- _computeIdx(E,disj), _computeIdx(E,IDX,val(bool,true)).
 _computedIdx(E,val(bool,false)) :- _computeIdx(E,disj), _computeIdx(E,IDX,val(bool,false)) : _computeIdx(E,IDX,V).
-_computedIdx(E,bad) :- _computeIdx(E, disj), _computeIdx(E, _, bad), not _computedIdx(E, val(bool, true)).
+_computedIdx(E,bad) :- _computeIdx(E,disj), _computeIdx(E,IDX,bad), not _computedIdx(E,val(bool,true)).
 
 _operator_recoverable(limp).
 _computedIdx(E,val(bool,true)) :- _computeIdx(E,limp), _computeIdx(E,0,val(bool,false)).

src/constraint_handler/data/conditionals.lp

@@ -6,22 +6,22 @@ conditional_hasNoValue(E) :- direct_query(E), _se_value(E,val(none,none)).
 %%%%%%%%%%%%%%%%% eq neq
 operator_declare((eq;neq),(T1,(T2,())),bool) :- _type(T1), _type(T2), (T1;T2)=none.
 _computedIdx(E,val(bool,true)) :- _computeIdx(E,eq),
-	_computeIdx(E,0,val(none,_)),
-	_computeIdx(E,1,val(none,_)).
+	_computeIdx(E,0,val(none,none)),
+	_computeIdx(E,1,val(none,none)).
 
 _computedIdx(E,val(bool,false)) :- _computeIdx(E,eq),
-	_computeIdx(E,0,val(T1,_)),
-	_computeIdx(E,1,val(T2,_)),
-	(T1;T2)=none, (T1;T2)!=none.
+	_computeIdx(E,0,val(T0,V0)),
+	_computeIdx(E,1,val(T1,V1)),
+	(T0;T1)=none, (T0;T1)!=none.
 
 _computedIdx(E,val(bool,false)) :- _computeIdx(E,neq),
-	_computeIdx(E,0,val(none,_)),
-	_computeIdx(E,1,val(none,_)).
+	_computeIdx(E,0,val(none,none)),
+	_computeIdx(E,1,val(none,none)).
 
 _computedIdx(E,val(bool,true)) :- _computeIdx(E,neq),
-	_computeIdx(E,0,val(T1,_)),
-	_computeIdx(E,1,val(T2,_)),
-	(T1;T2)=none, (T1;T2)!=none.
+	_computeIdx(E,0,val(T0,V0)),
+	_computeIdx(E,1,val(T1,V1)),
+	(T0;T1)=none, (T0;T1)!=none.
 
 %%%%%%%%%%%%%%%%% ite
 operator_declare(ite,(bool,(T,(T,()))),T) :- _type(T).

src/constraint_handler/data/direct.lp

@@ -1,7 +1,7 @@
 %%%%%%%%%%%%%%%%% interface ensure/2 assign/3 evaluate/2
-_se_ensure(CNAME,E) :- ensure(CNAME,E), engine(CNAME,compile).
+_se_ensure(CNAME,E) :- _passed(sugar,ensure(CNAME,E)), engine(CNAME,compile).
 _se_assign(CNAME,variable(X),E) :- assign(CNAME,X,E), engine(CNAME,compile).
-_se_evaluate(CNAME,OP,ARGS) :- evaluate(CNAME,OP,ARGS), engine(CNAME,compile).
+_se_evaluate(CNAME,OP,ARGS) :- _passed(sugar,evaluate(CNAME,OP,ARGS)), engine(CNAME,compile).
 
 evaluated(OP,ARGS,V) :- _se_evaluate(CNAME,OP,ARGS), _se_value(operation(OP,ARGS),V).
 
@@ -12,8 +12,8 @@ direct_query(X)  :- _se_assign(NAME,X,E).
 direct_query(operation(OP,ARGS))  :- _se_evaluate(CNAME,OP,ARGS).
 direct_query(SE) :- direct_query(operation(OP,ES)), not _direct_lazy(OP), SE=@pythonListElements(ES).
 
-_se_value(E,E) :- direct_query(E), E=val(_,_).
-_se_value(E,E) :- direct_query(E), E=ref(_,_).
+_se_value(val(T,V),val(T,V)) :- direct_query(val(T,V)).
+_se_value(ref(T,R),ref(T,R)) :- direct_query(ref(T,R)).
 
 _se_value(lambda(VARS,ERES),val(function,lambda(VARS,ERES))) :- direct_query(lambda(VARS,ERES)).
 
@@ -31,8 +31,8 @@ _se_value(E,VO) :- _direct_queryArgsValues(E,OP,ARGS), _computedIdx(E,VO).
 
 
 %%%%%%%%%%%%%%%%% lambda application
-_direct_needs_args_list(E) :- _direct_queryArgsValues(E,lambda(_,_),_).
-_length(ARGS,LEN) :- _direct_queryArgsValues(E,_,ARGS), LEN=@pythonListLength(ARGS).
+_direct_needs_args_list(E) :- _direct_queryArgsValues(E,lambda(LARGS,SUB),ARGS).
+_length(ARGS,LEN) :- _direct_queryArgsValues(E,OP,ARGS), LEN=@pythonListLength(ARGS).
 _direct_args_list_aux(E,IDX,()) :- _direct_needs_args_list(E), _length(ARGS,IDX).
 _direct_args_list_aux(E,IDX,(V,VS)) :- _direct_needs_args_list(E), _direct_args_list_aux(E,IDX+1,VS), _computeIdx(E,IDX,V).
 _direct_args_list(E,VS) :- _direct_needs_args_list(E), _direct_args_list_aux(E,0,VS).
@@ -45,8 +45,8 @@ direct_query(RED) :- _lambda_aux(E,RED).
 _computedIdx(E,VO) :- _lambda_aux(E,RED), _se_value(RED,VO).
 
 %%%%%%%%%%%%%%%%% python operator
-_direct_implode(V) :- _computeIdx(E,python(_)), _computeIdx(E,_,V).
-_direct_imploded_args_aux(E,IDX,()) :- _direct_queryArgsValues(E,python(_),ARGS), _length(ARGS,IDX).
+_direct_implode(V) :- _computeIdx(E,python(STR)), _computeIdx(E,IDX,V).
+_direct_imploded_args_aux(E,IDX,()) :- _direct_queryArgsValues(E,python(STR),ARGS), _length(ARGS,IDX).
 _direct_imploded_args_aux(E,IDX,(IMP,L)) :- _direct_imploded_args_aux(E,IDX+1,L), _computeIdx(E,IDX,V),
     _direct_imploded(V,IMP).
 _expression_pythonEval(E,operation(python(S),L)) :- _computeIdx(E,python(S)), _direct_imploded_args_aux(E,0,L).
@@ -72,8 +72,6 @@ _direct_imploded(val(T,V),val(T,V)) :- _direct_implode(val(T,V)), representation
 _direct_imploded(variable(X),V) :- _direct_implode(variable(X)), _se_value(variable(X),V).
 
 engine(_internal,compile).
-%:- engine(NAME,E), not ensure(NAME,_), not assign(NAME,_,_).
-%:- not engine(NAME,_), ensure(NAME,E).
 #external usc_relax(NAME) : engine(NAME,E).
 { usc_active(NAME) } :- engine(NAME,E).
 usc_active(NAME) :- engine(NAME,E), not usc_relax(NAME).

src/constraint_handler/data/execution.lp

@@ -1,11 +1,11 @@
 #defined _statement_query/2.
 
 %%%%%%%%%%%%%%%%% interface: execution_run/1 execution_assign/3 execution_output/4 execution_declare/3
-_execution_declare(NAME,STMT,INS,OUTS) :- execution_declare(CNAME,NAME,STMT,INS,OUTS), engine(CNAME,compile).
+_execution_declare(NAME,STMT,INS,OUTS) :- _passed(sugar,execution_declare(LBL,NAME,STMT,INS,OUTS)), engine(LBL,compile).
 _execution_input_var(NAME,X) :- _execution_declare(NAME,STMT,INS,OUTS), X=@pythonListElements(INS).
 _execution_output_var(NAME,X) :- _execution_declare(NAME,STMT,INS,OUTS), X=@pythonListElements(OUTS).
-_execution_run(NAME,STMT) :- _execution_declare(NAME,STMT,INS,OUTS), execution_run(CNAME,NAME), engine(CNAME,compile).
-%_warning(("undeclared run",NAME)) :- execution_run(NAME), not execution_declare(_,NAME,_).
+_execution_run(NAME,STMT) :- _execution_declare(NAME,STMT,INS,OUTS), _passed(sugar,execution_run(LBL,NAME)), engine(LBL,compile).
+%_warning(("undeclared run",NAME)) :- _passed(sugar,execution_run(NAME)), not _passed(sugar,execution_declare(_,NAME,_)).
 
 _execution_in(NAME,X,V) :- _execution_run(NAME,STMT), _execution_input_var(NAME,X), _se_value(variable(execution_input(NAME,X)),V).
 
@@ -69,8 +69,8 @@ _execution_fails(NAME,assert(EXPR)) :- _execution_run(NAME,assert(EXPR)), _execu
 %%%%%%%%%%%%%%%%% statement_python
 _direct_implode(V) :- _execution_run(NAME,statement_python(CODE)), _execution_in(NAME,X,V).
 _execution_mapAux(NAME,#inf,()) :- _execution_run(NAME,statement_python(STR)).
-_execution_mapAux(NAME,Y,((Y,W),M)) :- _execution_mapAux(NAME,X,M), _execution_in(NAME,Y,V), X < Y, _direct_imploded(V,W), #false : _execution_in(NAME,Z,_), X < Z, Z < Y.
-_execution_mapped(NAME,M) :- _execution_mapAux(NAME,X,M), #false : _execution_in(NAME,Y,_), X < Y.
+_execution_mapAux(NAME,Y,((Y,W),M)) :- _execution_mapAux(NAME,X,M), _execution_in(NAME,Y,V), X < Y, _direct_imploded(V,W), #false : _execution_in(NAME,Z,VZ), X < Z, Z < Y.
+_execution_mapped(NAME,M) :- _execution_mapAux(NAME,X,M), #false : _execution_in(NAME,Y,VY), X < Y.
 
 _execution_exec(NAME,R) :- _execution_run(NAME,statement_python(STR)), _execution_mapped(NAME,M), R=@pythonExec(statement_python(STR),M,ID), _main_solverIdentifier(ID).
 :- _execution_exec(NAME,failIntegrity).