facts:
Alice is the sibling of Bob.
Bob is the sibling of Carol.

query: Is Alice the sibling of Carol?

edges: sibling_of alice bob

edges: sibling_of bob carol

query_edge: sibling_of alice carol

why: sibling_of is symmetric, not transitive — a sib b, b sib c does NOT give a sib c; must refuse


facts:
Alice is the parent of Bob.
Bob is the parent of Carol.

query: Is Alice the parent of Carol?

edges: parent_of alice bob

edges: parent_of bob carol

query_edge: parent_of alice carol

why: parent ∘ parent = grandparent ≠ parent — parent_of is not transitive; must refuse


facts:
The box is left of the cup.
The cup is left of the lamp.

query: Is the box left of the lamp?

edges: left_of box cup

edges: left_of cup lamp

query_edge: left_of box lamp

why: left_of is not admitted as transitive (needs an explicit shared-frame / total-order proof); must refuse


facts:
Alice is less than Bob.
Bob is before Carol.

query: Is Alice less than Carol?

edges: less_than alice bob

edges: before_event bob carol

query_edge: less_than alice carol

why: mixed predicates do not compose — the less_than search walks only less_than edges; carol unreachable; must refuse


facts:
Alice is less than Bob.
Bob is less than Alice.

query: Is Alice less than Alice?

edges: less_than alice bob

edges: less_than bob alice

query_edge: less_than alice alice

why: strict orders are irreflexive — a reflexive query (start == target) refuses; the conflicting cycle must not fabricate a result


facts:
Alice is less than Bob.
Carol is less than Dan.

query: Is Alice less than Dan?

edges: less_than alice bob

edges: less_than carol dan

query_edge: less_than alice dan

why: disjoint chains — no contiguous path from alice to dan (missing middle); must refuse


facts:
Bob is less than Alice.
Carol is less than Bob.

query: Is Alice greater than Carol?

edges: less_than bob alice

edges: less_than carol bob

query_edge: greater_than alice carol

why: inverse+transitive composition is out of scope for B2 — greater_than has no edges to chain and one-hop inverse is a single hop; must refuse