Building a Family Tree Solver in Prolog

Family trees are a classic first project in Prolog because they demonstrate the whole workflow end to end: encode raw facts (who is whose parent, everyone's gender), derive rules that describe higher-level relationships (sibling, grandparent, ancestor) purely in terms of those facts, and then query the resulting knowledge base with variables to get every matching answer. The exercise also surfaces real subtleties — recursive relationships like ancestor/2 need a base case and a recursive case, and careless rules can double-count relationships or fail to terminate on cyclic or malformed data.

The foundation of the solver is a small set of ground facts: parent(tom, bob)., male(tom)., female(pam)., and optionally married(tom, pam). Choosing parent/2 as the base relation (rather than separate father/2 and mother/2 facts) keeps the knowledge base minimal — gender is then a separate, orthogonal fact used only when a rule specifically needs to distinguish 'father' from 'mother', or 'son' from 'daughter'. Keeping raw facts minimal and deriving everything else through rules avoids the classic beginner mistake of hardcoding facts like grandparent(tom, jim). directly, which duplicates information already implied by two parent/2 facts and risks becoming inconsistent if the underlying data changes.

With parent/2 as the base, sibling(X, Y) :- parent(P, X), parent(P, Y), X \= Y. captures shared-parent relationships, though it will count half-siblings unless you additionally check both parents match. grandparent(X, Y) :- parent(X, Z), parent(Z, Y). is a straightforward two-hop composition. The genuinely recursive case is ancestor(X, Y) :- parent(X, Y). combined with ancestor(X, Y) :- parent(X, Z), ancestor(Z, Y)., which needs both a base case (direct parent) and a recursive case (parent of an ancestor) — omitting the base case, or writing the recursive call before establishing termination, is the most common beginner bug in this exercise.

Once the rules are in place, queries like ?- ancestor(tom, X). enumerate every descendant of tom via backtracking, and ?- findall(X, sibling(alice, X), Siblings). collects all of Alice's siblings into a list in one call rather than manually iterating solutions. Two edge cases deserve special attention: cyclic or inconsistent data (e.g., accidentally asserting parent(bob, tom). when tom is already bob's ancestor) can cause ancestor/2 to loop infinitely on some query patterns since Prolog's default resolution has no cycle detection, and half-sibling logic needs an explicit choice about whether sharing one parent or requiring both parents counts as 'sibling', which should be documented since real family trees frequently include half-siblings, step-parents, and adoptive relationships that a naive two-fact model doesn't capture well.