hoololi/llm-calculations-v02

Local Arithmetic LLM Experiments

This dataset contains factual observations from local experiments comparing how different large language models answer arithmetic questions in three configurations:

1. raw: question only, with no calculator-specific system prompt.
2. prompted: calculator-oriented system prompt, but no external tool.
3. tool: formal calculator tool schema, local tool execution, and final model answer after tool results are returned.

The goal is not to rank models or provide a subjective benchmark. The data is intended as raw experimental material for independent analysis.

Data collection setup

The experiment was run locally using OpenRouter as the LLM provider. The calculator tool was implemented locally and safely, without using Python eval.

For each arithmetic question and each model, the script records raw answers, extracted numeric results, latency, token usage when available, cost when available, errors, and metadata such as model family and operation category.

Operation files are stored in operations/. Each operation contains:

• operation: the arithmetic question sent to the model;
• result: the locally recorded correct result;
• category: optional analysis category such as arithmetic_small, arithmetic_large, mixed_operations, simplification, or edge_case.

Only operation is sent to the models. result is exported as correct_result and is not included in prompts.

Tool mode

In tool mode, the model receives a formal calculator tool schema. If the model emits a tool call, the local calculator evaluates the requested expression, the result is sent back as a tool message, and the model returns a final answer.

Tool metadata is recorded explicitly:

• tool_called
• tool_call_count
• tool_expression
• tool_expression_scope
• tool_result
• tool_result_correct
• tool_error
• tool_error_type
• tool_calls

Each entry in tool_calls includes tool name, raw arguments, expression, result, and any tool error. Flat tool columns are included for easier analysis in pandas/Kaggle while preserving the full nested tool_calls details.

Numeric extraction

For convenience, extracted numeric results are included. The extractor prioritizes explicit final-answer patterns before falling back to generic number extraction. Examples of prioritized patterns include:

• final answer: ...
• the answer is ...
• answer is ...
• result is ...
• bold numeric answers such as **1,111,111,110**
• numbers after = signs, including inside bold equations

Thousands separators are handled for both standard comma notation such as 1,000,000,000,000 and LaTeX-style notation such as 1{,}000{,}000{,}000{,}000. Values are converted to integer if possible, otherwise float. If no number can be extracted, the extracted answer is null.

Raw answers are preserved so users can apply their own extraction logic. Extraction status is summarized in extraction_error_type.

File format

The dataset is stored as JSONL in long/tidy format. Each line corresponds to one arithmetic question × one model × one mode.

Fields include:

• timestamp
• operations_file
• operation_id: stable ID combining the operation file stem and operation index, e.g. operations_batch02__op_000003
• operation_category
• operation
• correct_result
• correct_result_str
• model_family
• model
• mode: raw, prompted, or tool
• answer_text
• answer_empty
• extracted_answer
• extracted_answer_str
• extracted_answer_correct
• extraction_error_type
• final_result_source
• final_result_correct
• latency_seconds
• cost
• input_tokens
• output_tokens
• total_tokens
• run_success
• run_error
• tool_called
• tool_call_count
• tool_expression
• tool_expression_scope
• tool_result
• tool_result_str
• tool_result_correct
• tool_error
• tool_error_type
• tool_calls

Previously generated datasets may contain older wide-format fields such as answer, result, question, llm_only_*, llm_with_calculator_*, raw_*, prompted_*, tool_*, difference, latency_difference_seconds, or cost_difference. Newer runs use explicit answer/tool fields, use operation rather than question, and omit recalculable difference fields.

final_result_correct reflects the answer actually returned to the user. For all modes, including tool, the current policy is:

• final_result_source = extracted_answer
• final_result_correct = extracted_answer == correct_result

Tool correctness is kept separate in tool_result_correct; a correct tool result is not silently substituted for the final user-facing answer.

Limitations

• Results depend on exact model versions and OpenRouter/provider routing at collection time.
• Latency can be affected by network conditions, provider load, routing, and rate limits.
• Tool support can vary by model and provider.
• Tool mode may involve more than one LLM call.
• Numeric extraction is heuristic. It prioritizes common final-answer formats, but may not match every possible response format.

Intended uses

Possible analyses include:

• comparing numeric outputs across raw, prompted, and tool modes;
• measuring whether tool use changes final answers;
• evaluating outputs against correct_result;
• breaking down results by model family or operation category;
• estimating latency and cost trade-offs;
• studying tool-use behavior through recorded tool calls.