Abstract Strategy vs Solution

This note isolates the distinction between a latent abstract strategy and a realized solution.

Related notes:

• Disentangling reasoning strategies in large language models
• Analogy as strategy transfer
• CVAE post-training methodology

We have been using the term "solution strategy" in previous notes and discussions on analogical exploration. The core distinction is:

• a solution strategy $z$ is latent, abstract, and high-level;
• a solution $y$ is low-level, instance-grounded, and observed.

One way to formalize this is through the graphical-model view

$$z \sim \pi_{z \mid x}(\cdot \mid x), \qquad y \sim \pi_{y \mid z, x}(\cdot \mid z, x),$$

where $z$ is an abstract method or motif and $y$ is a concrete realization of that method on the input $x$.

Comparison

Examples

• For "Sort a list of numbers efficiently," a strategy might be "divide-and-conquer, merge sort," while the solution is a concrete implementation.
• For "Find the final velocity of a block sliding down a frictionless incline of height $h$," a strategy might be "energy conservation" or "kinematics equations," while the solution is a worked derivation.
• For "Implement a function to check if a string is a palindrome," a strategy might be the "two-pointer technique," while the solution is concrete code.

Relation to the latent-variable view

In LLMs, these solution strategies are implicit rather than explicitly sampled. Even so, it is still useful to think of high-level reasoning modes as latent abstract strategies:

• the strategy is reusable across instances;
• the concrete solution is a local realization of that strategy;
• different surface-form solutions can still correspond to the same high-level method.

This is the conceptual pressure behind trying to factor a model into a router over strategies and a strategy-conditioned generator.