Styjun

I intend to describe "a rule is commutative" in my database, an immediate idea is that like the code.

certain_rule(X,Y) :- X = struct(_X,Others) , Y = some_process_base_on(_X).
certain_rule(Y,X) :- X = struct(_X,Others) , Y = some_process_base_on(_X).

But if X is unbound, it will make X bind with struct(_X,Others) directly, then some_process_base_on(_X) will be unknown. Now my solution is insert compound(X) before breakdown X.

Usually, compound/1 is not strict enough, something unexpected will be taken in, functor/3 may be a better solution but too many rules will exist since too many functors I need to compare, even if I use member/2 to find functor in list I still construct too many combination.

Is there any better way to describe 'commutative', BTW, is there any better way to screen some specified structures out?

First, note that your clauses are equivalent to writing:

certain_rule(struct(X,_), some_process_base_on(X)).
certain_rule(some_process_base_on(X), struct(X,_)).

A possible solution to screen for valid structures is to use a table of valid structures. For example:

valid_structure(-) :-
 !,
 fail.
valid_structure(struct(_,_)).
valid_structure(some_process_base_on(_)).
...

The first clause will screen out variables while preserving first-argument indexing for the predicate. You could then define a gatekeeper predicate:

certain_rule_gatekeeper(X, Y) :-
 once((valid_structure(X); valid_structure(Y))),
 certain_rule(X, Y).

To address commutativity, would a definition such as the following would work in your specific case?

certain_rule_gatekeeper(X, Y) :-
 once((valid_structure(X); valid_structure(Y))),
 once((certain_rule(X, Y); certain_rule(Y, X))).

Sample calls using just one of the clauses above for the certain_rule/2 predicate (thus avoiding duplicated information):

| ?- certain_rule_gatekeeper(X, Y). 
no

| ?- certain_rule_gatekeeper(struct(X,_), Y). 
Y = some_process_base_on(X)
yes

| ?- certain_rule_gatekeeper(Y, struct(X,_)).
Y = some_process_base_on(X)
yes

| ?- certain_rule_gatekeeper(some_process_base_on(X), Y).
Y = struct(X,_)
yes

| ?- certain_rule_gatekeeper(Y, some_process_base_on(X)).
Y = struct(X,_)
yes