polynomialmani.pl/polimani.pl

%% -*- mode: prolog-*-
%% Follows 'Coding guidelines for Prolog' - Theory and Practice of Logic Programming
%% https://doi.org/10.1017/S1471068411000391

%% Import the Constraint Logic Programming over Finite Domains lybrary
%% Essentially, this library improves the way Prolog deals with integers,
%% allowing more predicates to be reversible.
%% For instance, number(N) is always false, which prevents the
%% reversing of a predicate.
:- use_module(library(clpfd)).

%% polynomial_variable_list(-List:atom) is det
%
%  List of possible polynomial variables
%
polynomial_variable_list([x, y, z]).

%% polynomial_variable(?X:atom) is det
%
%  Returns true if X is a polynomial variable, false otherwise.
%
polynomial_variable(X) :-
    polynomial_variable_list(V),
    member(X, V).
%% polynomial_variable(P) :-
%%     polynomial_variable_list(V),
%%     member(X, V),
%%     P = X^N,
%%     N == 1.
%% Tests:
%% ?- polynomial_variable(x).
%@ true .
%% ?- polynomial_variable(x^(1)).
%@ false.

%% power(+X:atom) is semidet
%
%  Returns true if X is a power term, false otherwise.
%  Fully reversible.
%
power(P) :-
    %% Makes this more reversible
    P = X ^ N,
    %% CPL(FD) library predicate to perform integer comparassions in a reversible way
    %% If 0 > N succeds, fail, otherwise check if X is a valid variable
    (zcompare((>), 0, N); polynomial_variable(X)), fail.
    %% if(zcompare((>), 0, N),
    %%    fail,
    %%    polynomial_variable(X)
    %% ).
power(X) :-
    polynomial_variable(X).
%% Tests:
%% ?- power(x).
%@ true .
%% ?- power(x^1).
%@ true .
%% ?- power(x^3).
%@ false.
%@ false.
%@ false.
%@ true .
%@ true .
%% ?- power(x^(-3)).
%@ false.
%@ false.
%@ true .
%@ false.
%@ true .
%@ false.
%% ?- power(X).
%@ X = x ;
%@ X = y ;
%@ X = z.

%% if(+P, -T, -F) is det
%
%  A simple implementation of an if predicate.
%  Returns T if P is true
%  or F if P otherwise
%
%% if(If_1, Then_0, Else_0) :-
%%     call(If_1, T),
%%     (  T == true -> call(Then_0)
%%     ;  T == false -> call(Else_0)
%%     ;  nonvar(T) -> throw(error(type_error(boolean,T),_))
%%     ;  /* var(T) */ throw(error(instantiation_error,_))
%%     ).
if(P, T, F) :- (P == true, T); F.
%% ?- if(true, N = 1, N = 2).
%@ N = 1 .
%% ?- if(false, N = 1, N = 2).
%@ N = 2.

%% term(+N:atom) is det
%
%  Returns true if N is a term, false otherwise.
%
term(N) :-
    number(N).
term(X) :-
    power(X).
term(L * R) :-
    term(L),
    term(R).
%% Tests:
%% ?- term(2*x^3).
%@ true .
%% ?- term(x^(-3)).
%@ false.
%% ?- term((-3)*x^2).
%@ true .

%% is_term_valid_in_predicate(+T, +F) is det
%
%  Returns true if valid Term, fails with UI message otherwise.
%  The fail message reports which Term is invalid and in which
%  predicate the problem ocurred.
%
is_term_valid_in_predicate(T, F) :-
(
        term(T)
;
        write("Invalid term in "),
        write(F),
        write(": "),
        write(T),
        fail
).
%% Tests:
%% ?- is_term_valid_in_predicate(1, "Foo").
%@ true .

%% polynomial(+M:atom) is det
%
%  Returns true if polynomial, false otherwise.
%
polynomial(M) :-
    term(M).
polynomial(L + R) :-
    polynomial(L),
    term(R).
%% Tests:
%% ?- polynomial(x).
%@ true .
%% ?- polynomial(x^3).
%@ true .
%% ?- polynomial(3*x^7).
%@ true .
%% ?- polynomial(2 + 3*x + 4*x*y^3).
%@ true .

%% power_to_canon(+T:atom, -T^N:atom) is det
%
%  Returns a canon power term.
%
power_to_canon(T^N, T^N) :-
    polynomial_variable(T),
    %% N \= 1.
    (
	zcompare(=, 1, N)
    ;
	true
    ).
power_to_canon(T, T^1) :-
    polynomial_variable(T).
%% Tests:
%% ?- power_to_canon(x, X).
%@ X = x^1 .
%% ?- power_to_canon(X, x^1).
%@ X = x .
%@ X = x .
%% ?- power_to_canon(X, x^4).
%@ X = x^4 .

%% term_to_list(?T, ?List) is det
%
%  Converts a term to a list and vice versa.
%  Can verify if term and list are compatible.
%
term_to_list(L * N, [N | TS]) :-
    number(N),
    term_to_list(L, TS).
term_to_list(L * P, [P2 | TS]) :-
    power(P),
    power_to_canon(P, P2),
    term_to_list(L, TS).
term_to_list(N, [N]) :-
    number(N).
term_to_list(P, [P2]) :-
    power(P),
    power_to_canon(P, P2).
%% Tests:
%% ?- term_to_list(1*2*y*z*23*x*y*x^3*x, X).
%@ X = [x^1, x^3, y^1, x^1, 23, z^1, y^1, 2, 1] .
%% ?- term_to_list(X, [y^1, x^1]).
%@ X = x*y .
%% ?- term_to_list(X, [x^4]).
%@ false.
%@ false.
%@ X = x^4 .
%% ?- term_to_list(X, [y^6, z^2, x^4]).
%@ X = x^4*z^2*y^6 .

%% simplify_term(+Term_In:term, ?Term_Out:term) is det
%
%  Simplifies a term.
%
simplify_term(Term_In, Term_Out) :-
    term_to_list(Term_In, L),
    sort(0, @=<, L, L2),
(
    member(0, L2),
    Term_Out = 0
;
    exclude(==(1), L2, L3),
    join_like_terms(L3, L4),
    sort(0, @>=, L4, L5),
    term_to_list(Term_Out, L5)
),
    % First result is always the most simplified form.
    !.
%% Tests:
%% ?- simplify_term(2*y*z*x^3*x, X).
%@ X = 2*x^4*y*z.
%% ?- simplify_term(1*y*z*x^3*x, X).
%@ X = x^4*y*z.
%% ?- simplify_term(0*y*z*x^3*x, X).
%@ X = 0.
%% ?- simplify_term(6*y*z*7*x*y*x^3*x, X).
%@ X = 42*x^2*x^3*y^2*z.

%% join_like_terms(+List, -List)
%
%  Combine powers of the same variable in the given list
%
join_like_terms([P1, P2 | L], [B^N | L2]) :-
    power(P1),
    power(P2),
    B^N1 = P1,
    B^N2 = P2,
    %% B1 == B2,   % Wasn't working before..?
    N is N1 + N2,
    join_like_terms(L, L2).
join_like_terms([N1, N2 | L], [N | L2]) :-
    number(N1),
    number(N2),
    N is N1 * N2,
    join_like_terms(L, L2).
join_like_terms([X | L], [X | L2]) :-
    join_like_terms(L, L2).
join_like_terms([], []).
%% Tests:
%% ?- join_like_terms([2, 3, x^1, x^2], T).
%@ T = [6, x^3].
%@ T = [6, x^3].
%% ?- join_like_terms([2, 3, x^1, x^2, y^1, y^6], T).
%@ T = [6, x^3, y^7].
%@ T = [6, x^3, y^7].

%% simplify_polynomial(+P:atom, -P2:atom) is det
%
%  Simplifies a polynomial.
%
simplify_polynomial(M, M2) :-
    %% Are we dealing with a valid term?
    is_term_valid_in_predicate(M, "simplify_polynomial(M, M2)"),
    %% If so, simplify it.
    simplify_term(M, M2),
    !.
simplify_polynomial(P + 0, P) :-
    %% Ensure valid term
    is_term_valid_in_predicate(P, "simplify_polynomial(P + 0, P)"),
    !.
simplify_polynomial(0 + P, P) :-
    %% Ensure valid term
    is_term_valid_in_predicate(P, "simplify_polynomial(0 + P, P)"),
    !.
simplify_polynomial(P + M, P2 + M2) :-
    simplify_polynomial(P, P2),
    simplify_term(M, M2).
simplify_polynomial(P + M, P2 + M3) :-
    monomial_parts(M, _, XExp),
    delete_monomial(P, XExp, M2, P2),
    !,
    add_monomial(M, M2, M3).
simplify_polynomial(P + M, P2 + M2) :-
    simplify_polynomial(P, P2),
    simplify_term(M, M2).
%% Tests:
%% ?- simplify_polynomial(1, 1).
%@ Invalid term in simplify_polynomial(M, M2): 1
%@ false.


%% simplify_polynomial_list(+L1,-L3) is det
%
%  Simplifies a list of polynomials
%

simplify_polynomial_list([L1], L3) :-
    simplify_polynomial(L1, L2),
    L3 = [L2].
simplify_polynomial_list([L1|L2],L3) :-
    simplify_polynomial(L1, P1),
    simplify_polynomial_list(L2, P2),
    L3 = [P1|P2],
    % There is nothing further to compute at this point
    !.

%% monomial_parts(X, Y, Z)
%
%  TODO Maybe remove
%  Separate monomial into it's parts. Given K*X^N, gives K and N
%
monomial_parts(X, 1, X)     :-
    power(X),
    !.
monomial_parts(X^N, 1, X^N) :-
    power(X^N),
    !.
monomial_parts(K * M, K, M) :-
    number(K),
    !.
monomial_parts(K, K, indep) :-
    number(K),
    !.


delete_monomial(M, X, M, 0) :-
    term(M),
    monomial_parts(M, _, X),
    !.
delete_monomial(M + M2, X, M, M2) :-
    term(M2),
    term(M),
    monomial_parts(M, _, X),
    !.
delete_monomial(P + M, X, M, P) :-
    term(M),
    monomial_parts(M, _, X),
    !.
delete_monomial(P + M2, X, M, P2 + M2) :-
    delete_monomial(P, X, M, P2).

add_monomial(K1, K2, K3) :-
    number(K1),
    number(K2), !,
    K3 is K1 + K2.
add_monomial(M1, M2, M3) :-
    monomial_parts(M1, K1, XExp),
    monomial_parts(M2, K2, XExp),
    K3 is K1 + K2,
    p_aux_add_monomial(K3, XExp, M3).

p_aux_add_monomial(K, indep, K) :-
    !.
p_aux_add_monomial(0, _, 0) :-
    !.
p_aux_add_monomial(1, XExp, XExp) :-
    !.
p_aux_add_monomial(K, XExp, K * XExp).

closure_simplify_polynomial(P, P) :-
    simplify_polynomial(P, P2),
    P==P2,
    !.
closure_simplify_polynomial(P, P3) :-
    simplify_polynomial(P, P2),
    closure_simplify_polynomial(P2, P3),
    !.

list_to_term([N | NS], N * L) :-
    number(N),
    term_to_list(L, NS).