Semantic Parsing and Meaning Representations › Worked Examples: Logical Form, AMR, and SQL

Let us make the differences concrete with a small schema and a few sentences.

The three utterances below highlight different strengths of the representation families: quantifier scope in logic, shared participants in AMR, and aggregation in SQL. They are separate examples rather than equivalent encodings of one sentence.

Take the sentence:

Every student reads a book.

A surface-scope logical form is:

An inverse-scope logical form is:

Both are consistent with the English string. The first says each student may read a different book. The second says there is one book that every student reads. A semantic parser that outputs one fully resolved, reading-specific logical form has made a choice. A system that needs to reason about ambiguity should represent both readings or defer the choice.

The executable example below constructs the surface-scope reading explicitly. A parser must resolve or retain the ambiguity according to its application; word order alone does not determine the intended scope.

Now take:

The boy wants to go.

An AMR graph is:

(w / want-01
   :ARG0 (b / boy)
   :ARG1 (g / go-02
            :ARG0 b))

The graph contains a wanting node w, whose wanter is a boy b, and whose desired event is represented by a go-02 node g with the same boy as the understood goer. It does not assert that the boy actually goes. The reentrancy is explicit. The graph does not encode the difference between "the boy" and "a boy" in the same way first-order logic does. It abstracts over that distinction.

This is a feature for paraphrase stability: "The boy wants to go" and "A boy wants to go" receive very similar graphs, which is desirable if the task is about events and participants rather than definiteness.

Suppose we have this schema:

departments(department_id, name)
students(student_id, name, department_id)
enrollments(student_id, course_id)

And this question:

Which departments have more than two enrolled students?

A correct SQL query is:

SELECT d.name
FROM departments AS d
JOIN students AS s
  ON s.department_id = d.department_id
JOIN enrollments AS e
  ON e.student_id = s.student_id
GROUP BY d.department_id, d.name
HAVING COUNT(DISTINCT e.student_id) > 2
ORDER BY d.name;

The query joins the three tables, groups by department, counts distinct enrolled students, and filters groups with more than two students. The DISTINCT matters if a student can appear in multiple enrollment rows. Without it, the count could overcount.

The query is not a flat lookup. Under the shown schema, it uses the department and enrollment relationships to identify which students to count. The graph displays these information dependencies; equivalent SQL need not use this exact join plan.