Program-Aided Reasoning

PAL

Implement the Program-Aided Reasoning pattern in this codebase, using the LLM client and language we already use.

## Goal

Answer a question that needs calculation by having the model write a short program for it, running that program in a sandbox, and returning what the program prints.

## How it works

1. Fill in the Program-aided prompt with worked examples and the user's question, and call the model once.
2. Extract the code block from the reply. If there is none, return no answer with a status saying the model wrote no program.
3. Run the code in a sandboxed interpreter with no network or file access, a time limit and a memory limit, and capture what it prints.
4. Return the printed output, trimmed, as the answer, and keep the program alongside it as the working.
5. If repair is enabled and the run raises an error, call the model once with the Repair prompt, passing the program and the error, and run the corrected program the same way.

## Prompts

### Program-aided prompt

````markdown
Solve the problem by writing a Python program. Use comments for your
reasoning and variables for every quantity, and print the final answer.
Return only the program, in one code block.

Question: Olivia has $23. She bought five bagels for $3 each.
How much money does she have left?
```python
# Olivia starts with $23
money_initial = 23
# she buys 5 bagels at $3 each
bagels = 5
bagel_cost = 3
money_spent = bagels * bagel_cost
print(money_initial - money_spent)
```

Question: {{question}}
````

### Repair prompt

```markdown
Your program for the question below failed when it ran.

<question>{{question}}</question>
<program>{{program}}</program>
<error>{{error}}</error>

Fix the program so it runs and prints the final answer.
Return only the corrected program, in one code block.
```

## Stop rule

Stop when a program runs and prints an answer. If the run fails and repair is off, return no answer with the program and the error. With repair on, stop after one attempt; if that also fails, return no answer with a status saying execution failed.

## Requirements

- Never run generated code outside a sandbox; block the network and the file system, and set a time limit (default 5 s) and a memory limit.
- Treat empty output as a failure, the same as an exception.
- Make the repair step optional and off by default, since it is an extension to the original method.
- Log the question, the program, the output or error, and whether a repair was used.
- Add a test with a stub LLM that returns a program printing 5 + 2 * 3 and a real sandbox; assert one model call and that the answer is exactly '11'.

Program of Thoughts

Implement the Program-Aided Reasoning pattern (Program of Thoughts variant) in this codebase, using the LLM client and language we already use.

## Goal

Answer a numerical question by having the model write a program that binds every quantity to a named variable and stores the result in ans, then returning ans, or reasoning one step further from it where the task needs that.

## How it works

1. Call the model with the Program of Thoughts prompt and the question. The program must bind every quantity to a meaningfully named variable and store the result in a variable called ans.
2. Run the program in a sandboxed interpreter with time and memory limits, and read the value of ans.
3. If the task needs no further step, return ans as the answer. This is the main path: one model call.
4. If the task needs a step the program does not take, such as choosing among multiple-choice options or converting units, call the model with the Finish from ans prompt, passing the question and ans.
5. Parse the finishing reply's 'Answer:' line and return it, keeping the program and ans alongside it as the working.

## Prompts

### Program of Thoughts prompt

```markdown
Write a Python program that computes the answer to the question.
Bind every quantity to a variable with a meaningful name, compute
step by step, and store the final result in a variable called ans.
Return only the program, in one code block.

Question: {{question}}
```

### Finish from ans prompt

```markdown
A program computed an intermediate result for the question below.

<question>{{question}}</question>
<ans>{{ans}}</ans>

Starting from ans, reason step by step to the final answer, for
example by converting units or matching it to one of the options.
End with one line that starts with "Answer:".
```

## Stop rule

Stop when ans has been read, or after the one finishing call when that step is enabled. If the program fails or never sets ans, return no answer with the program and the error.

## Requirements

- Never run generated code outside a sandbox; block the network and the file system, and set time and memory limits.
- Read the answer from the variable ans, not from printed output, and fail clearly if it is missing.
- Make the finishing step a per-task setting, off by default; the paper used it only for multiple-choice questions.
- Log the question, the program, ans and, when used, the finishing reply.
- Add a test with a stub LLM whose program sets ans = 5 + 2 * 3, with finishing off; assert exactly one model call and that the answer is exactly 11.
- Add a test with finishing on: the program sets ans = 123 / 60 and the stub finish replies 'Answer: (B)'; assert two calls, that the finish prompt contains '2.05', and the answer '(B)'.