Faultline

Inspiration

A student can choose the correct answer while still using the wrong reasoning. Most learning tools only check the final response, so hidden misconceptions can go unnoticed.

We built Faultline to make the thinking behind a physics answer visible. Instead of only asking whether an answer is correct, Faultline checks what the learner believes, what evidence supports that belief, and whether the learner can improve their reasoning.

What it does

Faultline is a physics learning tool with three scenarios: Vacuum Drop, Collision Forces, and Projectile Motion.

The learner first chooses an answer and explains their reasoning in their own words. Faultline turns that explanation into a small reasoning map and connects each relationship to the exact words the learner used.

The learner then makes a prediction before running a focused physics simulation. After seeing the result, the learner explains the idea again. Faultline compares the first explanation with the revised one and checks whether the incorrect relationship was repaired.

A final transfer question changes the context and checks whether the learner can apply the same idea again. At the end, Faultline creates a report showing the original reasoning, the identified problem, the revised explanation, and the transfer result.

Faultline does not simply provide another answer. It helps learners inspect and repair their own thinking.

How we built it

Faultline was built with Next.js, React, TypeScript, Zod, Vitest, and Playwright.

The system separates language interpretation from physics validation. A language extraction layer reads the learner’s explanation and identifies possible concepts, relationships, and supporting evidence.

That layer does not decide whether the physics is correct. Deterministic TypeScript code checks the physics relationships, contradictions, evidence, simulation results, repair, and transfer response.

This allows Faultline to understand natural language while keeping the scientific rules consistent, testable, and transparent.

Challenges we faced

The hardest challenge was handling explanations that sounded correct but contained weak or incorrect reasoning.

Learners may use negation, uncertainty, quotations, contradictions, or ideas from another topic. A learner may also reach the correct conclusion through the wrong method.

We created validation rules and test cases for these situations. Every mapped relationship must connect to exact evidence from the learner’s explanation. A repair only passes when the required relationship is clearly present.

We also needed the demo to remain reliable when live inference was unavailable. Faultline clearly shows when fallback extraction is being used, while the physics validation and simulations remain deterministic.

Accomplishments

Faultline now supports a complete learning process from the first answer to the final transfer check.

The current version includes three physics scenarios, evidence-linked reasoning maps, required predictions, deterministic simulations, repair verification, transfer questions, and a final learning report.

What we learned

Language models are useful for understanding the many ways learners express the same idea, but they should not be the final authority on scientific truth.

We learned that language extraction works best when paired with a deterministic system that owns the physics rules.

We also learned that showing learners the relationship they expressed, along with the exact words that created it, can be more useful than immediately giving them another explanation.

What is next

The current prototype focuses on three authored physics scenarios.

The next step is to test Faultline with learners and educators. We also want to add more physics scenarios and create tools that allow educators to build their own reasoning models.