Lecture 05 · The two worlds

The interface problems

Grounding, compositionality, data, trust. Four ways a system can be right about the words and wrong about the world.

4 problems 1 interactive test 1 lab Self-paced
00 · Learning objectivesLecture 05 · The interface problems

By the end of this lecture

Four things you can do.

01

Ground a symbol in a referent

Declare the frame, distinguish grounding from anchoring, and return a set when the expression is ambiguous.

02

Test composition by recombination

Hold out a combination of seen primitives and compare a program with a lookup.

03

Audit the data and its splits

Describe coverage, leakage, and supervision by what they make identifiable.

04

Make trust conditional

State the specification, the domain, and the evidence behind any guarantee.

S/V · Lecture 05
00 · The hookLecture 05 · The interface problems

A sentence, two worlds

“The red cube left of the sphere.”

VIEWER OBJECT A · referent B sphere left = smaller x A B · referent faces → left = sphere’s left
Schematic. Same objects, same sentence, two admissible semantics.
Viewer frame. left is a screen coordinate. Cube A is the referent.
Object frame. left is the sphere’s intrinsic left. Cube B is the referent.

Nothing in the sentence decides. The frame is an argument English leaves implicit.

S/V · Lecture 05
01 · GroundingLecture 05 · The interface problems
01 / 08

Which object does the symbol pick out?

Grounding, anchoring, frames, and the pipeline of commitments from pixels to symbols.

S/V · Lecture 05
01 · GroundingLecture 05 · The interface problems

Harnad, 1990

A dictionary is a closed loop.

Look up horse and you find equine mammal; look up equine and you find horse. Definitions only point at other definitions. Something outside the symbol system has to connect the word to the world.

Symbol → symbol

A definition. Internally consistent, potentially about nothing.

Symbol → world

Perception and action. The connection Harnad demands.

Token → entity

Anchoring: this occurrence, this object, this time.

Grounding is a relation; anchoring is an act. A system can have grounded predicates and still bind them to the wrong object.
S/V · Lecture 05
01 · GroundingLecture 05 · The interface problems

The missing argument

“Left” is a three-place relation.

leftF(a, b)   where   F ∈ {viewer, object, world}

Viewer

xa < xb in image coordinates. Cheap, and wrong the moment the camera turns.

Object

(pa − pb) · lb > 0, where lb is the reference object’s intrinsic left.

In the hook, the sphere faces east, so l = (0, −1). Cube A has dot product 0; cube B has dot product 1. The frame flips the referent.

S/V · Lecture 05
01 · GroundingLecture 05 · The interface problems

From pixels to symbols

A pipeline of commitments.

01Pixelsimage or video
02Detectionsmissed or merged objects
03Attributesconfused colour or shape
04Scene graphwrong relation or depth
05Symbolswrong anchor or frame

A downstream program cannot recover an object the detector never proposed. The scene graph is where perceptual errors become symbolic facts.

S/V · Lecture 05
01 · GroundingLecture 05 · The interface problems

An interface decision

Ambiguity is a result, not an error.

Return the set. If two objects satisfy the expression, the answer is two objects, not the more likely one.
Declare the frame. Viewer, object, or world. An undeclared frame is a missing input, not a modelling choice.
Log the candidates. Scores, anchor ids, and the frame. The log is what makes the choice contestable.

System status

expression: the red cube left of the sphere

frame: undeclared

referents: {A, B}

status: ambiguous · 2 referents

An argmax over referents makes a choice the language did not authorize. The choice may be harmless in a game and unacceptable in a medical record.

S/V · Lecture 05
02 · CompositionalityLecture 05 · The interface problems
02 / 08

Unseen combinations are the test.

Systematicity, held-out recombination, and why an i.i.d. score says almost nothing about composition.

S/V · Lecture 05
02 · CompositionalityLecture 05 · The interface problems

Frege, via Fodor and Pylyshyn

Meaning is a function of parts — and of combination.

⟦S⟧ = fsyn(⟦w1⟧, …, ⟦wn⟧)

Systematicity

If you can represent red cube and blue sphere, you can represent red sphere.

Productivity

A finite system generates unboundedly many meaningful combinations.

Recombination

The test is a combination the system has not seen, not a new sample near old ones.

S/V · Lecture 05
02 · CompositionalityLecture 05 · The interface problems

Two different questions

Interpolation is not recombination.

red cubeseen
red sphereheld out
blue cubeheld out
blue sphereseen

Two diagonal cells in training. Two off-diagonal cells in the test.

I.i.d. split. A new point near old points. Tests interpolation.
Combination held out. Each primitive is seen, but not together. Tests the rule.
The gap is not a data gap. More diagonal examples do not put the off-diagonal in the representation.
S/V · Lecture 05
02 · CompositionalityLecture 05 · The interface problems

Interactive · switch the model

Try the recombination.

red cube · seen 1 · memorised
red sphere · held out — no entry
blue cube · held out — no entry
blue sphere · seen 1 · memorised

Training set: the two diagonal cells only.

The lookup has entries for the two diagonal cells. Red sphere and blue cube have no representation, so it cannot answer them.

The program is given grounded primitives. This isolates the combination rule, not perception.

S/V · Lecture 05
02 · CompositionalityLecture 05 · The interface problems

The benchmark is the split

Two ways to hold out a combination.

SCAN · 2018

Primitive + modifier

Train on commands and actions; test a known primitive in a new combination with a known modifier. Sequence-to-sequence models can fail on the unseen combination.

arXiv:1711.00350

COGS · 2020

Structure, not only lexicon

A semantic-interpretation challenge whose splits test novel syntactic structures with familiar words. The held-out unit moves from the word to the grammar.

arXiv:2010.05465

Methodological point that outlives both grammars: a high i.i.d. score is not evidence of composition. The split is the claim.
S/V · Lecture 05
02 · CompositionalityLecture 05 · The interface problems

Two findings, one lesson

Depth is a diagnostic; a program is a response.

Faith and Fate. On multi-step compositional tasks, transformer performance tends to degrade as the chain grows, consistent with pattern completion rather than a general procedure.
NS-CL. Learn a scene representation and a parser from question–answer pairs; execute the parsed program over the scene. Recombination beyond the exact training questions.
Caveat. NS-CL is synthetic, closed-world, and small. It demonstrates that a program interface can support composition; it does not demonstrate an open world.
S/V · Lecture 05
03 · Data and trustLecture 05 · The interface problems
03 / 08

What supervision buys, and what trust means.

Coverage, leakage, calibration, and the specification hidden inside every guarantee.

S/V · Lecture 05
03 · DataLecture 05 · The interface problems

What is labelled, and what that identifies

Supervision is a choice of distinctions.

RegimeIdentifies wellHides
Program annotationParse structure, compositionAnnotator grammar; cost
Question–answerEnd-to-end behaviourWhich program produced the answer
Image–captionBroad alignmentReference to a region
Weak supervisionCoverageCorrelated label noise

Question–answer supervision is many-to-one over programs. The answer does not identify the computation; a curriculum or a trace has to do that work.

S/V · Lecture 05
03 · DataLecture 05 · The interface problems

The hypothesis-space argument

Knowledge shrinks the hypothesis space.

HK = { h ∈ H : h is consistent with K }   ⇒   |HK| ≤ |H|

If K is true

Fewer examples are needed to identify the right hypothesis. This is the data-efficiency argument for symbolic priors.

If K is false

The right answer is removed from the class. No amount of data recovers it. A prior is a bet.

Program annotations, constraints, and ontologies are all versions of K. They are worth their cost when the domain is stable and the knowledge is auditable.

S/V · Lecture 05
03 · DataLecture 05 · The interface problems

Describe the matrix, not the size

Coverage is the dataset’s shape.

red cubeseen
red sphereempty
red cyl.seen
blue cubeempty
blue sphereseen
blue cyl.empty
green cubeseen
green sphereempty
green cyl.empty

A coverage matrix. The empty cells are the test set, or the blind spot.

Leakage. Near-duplicates across splits, template overlap, scene-level leakage, pretraining contamination.
Audit. Hash inputs, search near-duplicates, split by scene or grammar, report what cannot be checked.
An aggregate score hides all of it.
S/V · Lecture 05
04 · TrustLecture 05 · The interface problems

Two strategies, different guarantees

Readable, or explained afterwards?

Rudin · 2019

Interpretable by construction

Use a model whose computation can be read. The argument is partly about fidelity: an explanation of a black box is a second model, and it can be wrong about the first.

LIME · 2016

Post-hoc local surrogate

Perturb around a prediction, fit a simple surrogate, report its features. Useful as a diagnostic; weak as a guarantee.

A program trace is a representation, not a guarantee. It can be read, and it can be wrong at the first predicate. Fluent explanations make wrong traces persuasive.
S/V · Lecture 05
04 · TrustLecture 05 · The interface problems

The hidden premise

A guarantee is only as good as its specification.

S ⊨ φ on D

Empirical

Tested on a sample. A statistical claim about that sample and its distribution.

Formal

Holds for all inputs in a domain, relative to a model. The model-to-world gap remains.

Operational

A monitor checks the running system and can intervene. Coverage is the limit.

If φ says “no visible obstacle,” a transparent obstacle is outside the specification and inside the accident. The specification is part of the theorem.

S/V · Lecture 05
04 · TrustLecture 05 · The interface problems

Scores are not probabilities of correctness

Confidence is not correctness.

ECE = Σb (nb / N) · |acc(b) − conf(b)|
Calibrated. Among cases where the system says 0.8, about 80% are correct.
Miscalibrated. Confident and wrong. The score is a ranking signal, not a probability.
Ambiguity is not uncertainty. Two valid referents is an underspecified question, not a blurry input.
Underspecification. Many models fit one test score and diverge under a shift the evaluation never exercised.
S/V · Lecture 05
04 · TrustLecture 05 · The interface problems

What the model is actually using

The cheap cue wins.

Shortcut

A cue correlated with the label but not the rule: position, texture, a spurious word.

Shift

A camera move, a transparent bin, a new material. The shortcut stops working.

Counterfactual

Change one property and check that the output changes for the right reason.

SayCan makes the check explicit: language scores a skill, a value function estimates feasibility, the product chooses the action. The plan is grounded in what the robot can actually do.
S/V · Lecture 05
05 · DiagnosisLecture 05 · The interface problems

When the answer is wrong

Four failures, four probes.

FailureFirst probeWhat to log
GroundingSwap in oracle perceptionCandidates, frame, anchor ids
CompositionCompare the program with the intentParse tree, trace, counts
SpecificationSecond independent formalisationSpec version, assumptions
Distribution shiftRe-run on the shifted domainDomain id, per-slice calibration

The probe is the smallest experiment that separates this failure from its neighbours. The categories are diagnostic aids, not an ontology.

S/V · Lecture 05
05 · DiagnosisLecture 05 · The interface problems

One wrong drop, four readings

“Put the red cube left of the bowl into the blue bin.”

Grounding

Two red cubes. The system chose the viewer-left one; the speaker meant the bowl-left one. Fix: frame parameter and ambiguity check.

Composition

“Left of the bowl” attached to “put,” not to “the red cube.” Fix: parser or clarification.

Specification

“Into” was formalised as “within a fixed radius.” The robot obeyed. Fix: spec review.

Shift

The bin is transparent; the detector saw no bin. Fix: data or detector, not policy.

Retraining is the wrong response to the first three. The diagnosis chooses the fix.

S/V · Lecture 05
06 · DesignLecture 05 · The interface problems

Before you build

Six questions for any interface.

1 · What is the symbol?

A predicate, program, graph, constraint, or proof. What language, and what does it mean?

2 · What grounds it?

A detector, scene graph, lexicon, or convention. Where does it touch the world?

3 · What composes it?

A parser, executor, or solver. Is it typed? What does it reject?

4 · What data teaches it?

Which regime, which coverage, which split? What is held out?

5 · What checks it?

A loss, monitor, verifier, or calibration test. Of what, exactly?

6 · What happens when it fails?

Abstain, ask, fall back, log, alarm. No behaviour is still a behaviour: it guesses.

S/V · Lecture 05
07 · The bridgeLecture 05 · The interface problems

The bridge to Lecture 06

Five responses, no one-to-one map.

InterfacePrimary problemWhat it does not fix
Logic as lossData, compositionSoft constraints; no proof
Logic as architectureGrounding, compositionWrong scene graph → wrong proof
Logic as dataData, groundingEmbedding distortion; schema drift
Logic as searchComposition, trustSearch cost; proposal quality
Logic as verifierTrustSpecification gaps; monitor coverage

The tuple, not the label, is the object to compare. Lecture 06 compares systems along expressivity, complexity, coupling, guarantee, supervision, cost, and transparency.

S/V · Lecture 05
08 · RecapLecture 05 · The interface problems

What you should be able to do

Four moves.

Ground

Declare the frame; return a set; log the anchor.

Compose

Hold out a combination; inspect the program, not only the score.

Audit

Describe coverage, leakage, and what the supervision identifies.

Condition

State specification, domain, and evidence before you say “trust.”

S/V · Lecture 05
08 · RecapLecture 05 · The interface problems

Next · hands-on

Now make it ambiguous.

Open the lab. Resolve the expression with an undeclared frame, then with viewer and object. Then switch the lookup to a program and watch the held-out cells change.

S/V · Lecture 05
Speaker notes