Kinship

This is a relatively larger example of using the natural logic described before for describing families.

Here is mine:

  
// Sam is a person
Sam(u) person(u).

// Dani is a person
Dani(v) person(v).

// Leo is a boy
Leo(p) person(p) male(p).

// Anna is a girl
Anna(q) person(q) female(q).

// Arthur is a boy
Arthur(r) person(r) male(r).

// Sam is Leo's, Anna's and Arthur's father
father(u, p) father(u, q) father(u, r).

// Dani is Leo's, Anna's and Arthur's mother
mother(v, p) mother(v, q) mother(v, r).
  

These describe basic facts about my family.

Here are some general statements about families in general:

  
for (let x: person(x)) {
  for (let y: person(y)) {
    // Every father is a male parent
    if (father(x, y)) {
      male(x) parent(x, y).
    }
    // Every mother is a female parent
    if (mother(x, y)) {
      female(x) parent(x, y).
    }
    // Every male parent is a father
    if (parent(x, y) male(x)) {
      father(x, y).
    }
    // Every female parent is a mother
    if (parent(x, y) female(x)) {
      mother(x, y).
    }
    // If A is a parent of B then B is a child of A
    if (parent(x, y)) {
      child(y, x).
    }
    // Every son is a male child
    if (son(x, y)) {
      male(x) child(x, y).
    }
    if (male(x) child(x, y)) {
      son(x, y).
    }
    // Every daughter is a female child
    if (daughter(x, y)) {
      female(x) child(x, y).
    }
    if (female(x) child(x, y)) {
      daughter(x, y).
    }
    // If A is an ancestor of B then B is a descendent of A
    if (ancestor(x, y)) {
      descedent(y, x).
    }
    if (parent(x, y)) {
      // Every parent is an ancestor
      ancestor(x, y).
      // Every parent is an ancestor of its descendents
      for (let z: person(z)) {
        if (ancestor(y, z)) {
          ancestor(x, z).
        }
      }
    }
    // If there is a person z who is a parent of x and y
    // then x and y are siblings
    for (let z: person(z)) {
      if (parent(z, x) parent(z, y)) {
        sibling(x, y).
      }
    }
 
    if (sibling(x, y)) {
      sibling(y, x).
      if (male(x)) {
        brother(x, y).
      }
      if (female(x)) {
        sister(x, y).
      }
    }
    if (brother(x, y)) {
      male(x) sibling(x, y).
    }
    if (sister(x, y)) {
      female(x) sibling(x, y).
    }
  }
}
  

With the basic facts about my family and the general statements about families in general, we can ask things that were only indirectly stated.

For example:

  
// Who is a child of Sam?
let x, y: Sam(x) child(y, x)?
  

You can run that query by clicking on the run button below:

The query returns three bindings, one for each of my kids.

This is kinda of exciting because child(u, p), child(u, q), child(u, r) was never something that we explicitly stated, but rather something that was inferred from the basic facts and the general statements about families.

Here is another example:

  
 // Who are Anna's brothers?
 let x, y: Anna(x) brother(y, x)?
  

And again, you get back two responses that were never explicitly stated before, but were rather inferred from the logical form of the program.

Neat, huh?