p(X) :- p(X). does usually not terminate in a top-down (Prolog) system but does in a bottom-up (Datalog) system. Datalog doesn't even allow terms as predicate arguments so of course you can't construct them of infinite size. But also this isn't allowed (where it is in Prolog)
p(X) :- p(Y), X is Y + 1.
Given a fact p(0) you get p(X) true for any integer X or generate all positive integers. This doesn't terminate for some binding patterns.
is/2 is not Datalog though- it takes an arithmetic function as an argument;
+/2 in your example. So the above would not terminate because it's Prolog, not
because it's a Datalog program evaluated by Prolog.
>> Datalog doesn't even allow terms as predicate arguments so of course you
can't construct them of infinite size.
Usual confusion: I think you mean "terms" as in Prolog terms, i.e. atoms of
predicates (as opposed to terms in logic programming, i.e. variables,
constants and functions). Datalog accepts constants and variables so with a
finite vocabulary you can't create infinite atoms. I don't think that has to
do with bottom-up or top-down evaluation.
To be honest, I haven't read any Datalog papers, but I'd be surprised if the
termination guaranteed rested upon a specific implementation rather than the
language semantics. Maybe not surprised- but it would be less interersting if
you can only guarantee termination if you implement the language just so, vs.
if it's a property of the language.
The minimal herbrandt model does not have new atoms. Besides what is given in the rules and the starting facts (empty for least fix point).
So the "biggest" model is only as large as any atom in any position for any predicate and that is always finite for a finite number of sorts or predicates.
Is gave is/2 as an example of how Prologo allows you to generate new atoms/terms that have not been facts before.
p(X) :- p(X). does usually not terminate in a top-down (Prolog) system but does in a bottom-up (Datalog) system. Datalog doesn't even allow terms as predicate arguments so of course you can't construct them of infinite size. But also this isn't allowed (where it is in Prolog)
p(X) :- p(Y), X is Y + 1.
Given a fact p(0) you get p(X) true for any integer X or generate all positive integers. This doesn't terminate for some binding patterns.