Conceptual dependency & conceptual graphs

Conceptual dependency: canonical meaning

Schank's conceptual dependency (CD) theory aims for a canonical semantic representation: sentences that mean the same thing should produce the same internal structure, so understanding becomes matching rather than logical inference. CD claims every verb reduces to one (or a few) of just 11 primitive ACTs. Three you must know:

• ATRANS — transfer of an abstract relationship such as ownership (give, donate, sell).
• PTRANS — physical transfer of location (go, move, fly to).
• MTRANS — transfer of mental information (tell, read, remember).

So "give" and "donate" both reduce to ATRANS, and a CD system sees them as identical. The strength is reduced ambiguity and cheap matching; the criticisms are that reduction to primitives is computationally expensive, the 11 primitives are too coarse for subtle distinctions (push vs shove), and there is no evidence humans actually store meaning this way.

Conceptual graphs: relations as nodes

Sowa's conceptual graphs (CG) fix a weakness of plain semantic nets — that relations hide inside arc labels, which makes n-ary relations awkward. A conceptual graph is bipartite: there are concept nodes (objects, drawn as boxes, written type:referent, e.g. dog:emma) and conceptual relation nodes (relations, drawn as ellipses). There are no arc labels — an arc just connects a concept to a relation. An n-ary relation is one relation node with n arcs, so any arity is handled uniformly.

Four canonical formation rules transform graphs: copy, restrict (replace a generic marker with an individual, or a type with a subtype), join (merge two graphs sharing an identical concept node), and simplify (drop a duplicate relation). Restrict and join are specialisation operations, and together they implement inheritance. Crucially these rules preserve meaningfulness, not truth — they are plausible-reasoning operations, not logical inference.

Worked example & equivalence to logic

Conceptual graphs have exactly the expressive power of predicate calculus. To convert a CG to logic: give each generic concept a unique variable and each individual a unique constant, write each concept node as a unary predicate (dog:emma → dog(emma)), write each relation node as an n-ary predicate over its concept arguments, and existentially quantify the variables. So the CG [Dog: emma] → (agent) → [Run] converts to dog(emma) ∧ run(X) ∧ agent(X, emma) — same content, graphical form.