## Screenshot: Instance Reflection Query Template
### Overview
The image displays a digital template titled "Instance reflection query template." It is a structured form designed to guide a user in comparing two solutions to a math question, identifying errors, and providing a verification. The template uses a clean, two-tone design with a dark header and a light content area.
### Components/Axes
The image is segmented into two primary regions:
1. **Header (Top Bar):**
* A dark gray horizontal bar spans the top of the frame.
* Contains the title text in white: `Instance reflection query template`.
2. **Main Content Area (Below Header):**
* A light gray or off-white background.
* Contains all instructional text and placeholders, formatted with specific indentation and line breaks.
### Detailed Analysis
The content is a precise set of instructions and a template structure. All text is in English.
**Text Transcription:**
```
User:
Compare a correct solution and a potential solution to the same math question,
identify the error in the potential solution, if any, and briefly explain the
error in two sentences or less in the <reflection> ... </reflection> tags,
and then conclude with:
Verification: Is the previous solution correct? (Yes/No)
The explanation should be "I think the solution is correct." if the potential
solution is correct.
DO NOT solve the question. DO NOT include phrases implying the comparison
between the two solutions.
Question: {{ Question }}
Correct solution: {{ correct_solution }}
Potential solution: {{ potential_solution }}
```
**Structural Details:**
* The word `User:` is left-aligned and acts as a label for the entire block of instructions that follows.
* The main instructional paragraph is a single block of text.
* The line `Verification: Is the previous solution correct? (Yes/No)` is presented as a standalone, required output format.
* Two critical negative constraints are given in all-caps: `DO NOT solve the question. DO NOT include phrases implying the comparison between the two solutions.`
* Three placeholders are defined at the bottom, each on its own line:
* `Question: {{ Question }}`
* `Correct solution: {{ correct_solution }}`
* `Potential solution: {{ potential_solution }}`
* The placeholders `{{ ... }}` use a double-curly-brace syntax, indicating they are variables to be filled with specific content.
### Key Observations
* **Purpose-Driven Design:** The template is not a generic form but a highly specific prompt engineering tool for evaluating mathematical reasoning. It enforces a strict output format (`<reflection>` tags, a binary verification) and prohibits certain actions (solving, explicit comparison).
* **Clarity of Constraints:** The instructions are unambiguous, using direct language and capitalization for emphasis on prohibitions.
* **Variable Isolation:** The three placeholders (`Question`, `correct_solution`, `potential_solution`) are clearly separated, ensuring the inputs for the task are distinct.
### Interpretation
This image is a **meta-template**—a template for generating prompts that will, in turn, be used to evaluate AI or human performance on math problems. Its design reveals several underlying principles:
1. **Controlled Evaluation:** By forbidding the solver from re-solving the question and from making direct comparative statements ("The potential solution is wrong because..."), the template aims to isolate the error-identification skill. The evaluator must diagnose the flaw based solely on the provided solutions, not on their own re-derivation.
2. **Structured Output:** The requirement for `<reflection>` tags and a final `Verification:` line standardizes the response format. This makes automated parsing or consistent human review possible. The reflection is constrained to two sentences or less, forcing conciseness.
3. **Pedagogical or Benchmarking Use:** Such a template is likely used in one of two contexts: (a) to train models to critique mathematical reasoning, or (b) as a benchmark task to test a model's ability to perform this critique. The "Instance reflection" title suggests it's part of a larger system for generating many such evaluation instances.
4. **Implicit Trust in "Correct Solution":** The template operates on the axiom that the `correct_solution` is indeed correct. The task is not to verify the correct solution but to audit the `potential_solution` against it. This frames the exercise as a debugging task rather than a truth-seeking one.
In essence, this template is a blueprint for creating a focused, constrained test of analytical reasoning in mathematics, prioritizing the identification of logical errors over computational skill.
