Results for “counterexample”

Automatically repair code violations of temporal properties using model-checking counterexamples as guidance. Use when working with formal verification results, temporal logic property violations (LTL, CTL), model checking counterexamples, or when asked to repair property violations, fix counterexamples, repair temporal properties, fix model checking violations, or repair code based on counterexamples. Applicable to concurrent systems, state machines, synchronization issues, safety/liveness properties, and resource management violations.

The English summary is being prepared. Showing the original description.

Solve competition mathematics problems and examine proofs through independent agents that actively look for gaps, counterexamples, and misused theorems. Produces a checked argument or clearly states what remains unresolved, with optional PDF output.

• Solve an IMO or Putnam problem
• Check a competition proof for gaps
• Find counterexamples to claims within a proof

Automatically generates executable test cases from model checking counterexample traces. Translates abstract counterexample states and transitions into concrete test inputs, execution steps, and assertions that reproduce property violations. Use when working with model checker outputs (SPIN, CBMC, NuSMV, TLA+, Java PathFinder, etc.) and needing to create regression tests, validate bug fixes, or reproduce verification failures in executable test suites.

The English summary is being prepared. Showing the original description.

Explain why counterexamples violate specifications by analyzing formal specifications (temporal logic, invariants, pre/postconditions, code contracts), informal requirements (user stories, acceptance criteria), test specifications (assertions, property-based tests), and providing step-by-step traces showing state changes, comparing expected vs actual behavior, identifying root causes, and assessing violation impact. Use when debugging test failures, understanding model checker output, explaining runtime assertion violations, analyzing static analysis warnings, or teaching specification concepts. Produces structured markdown explanations with traces, comparisons, state diagrams, and cause chains. Triggers when users ask why something failed, explain a violation, understand a counterexample, debug a specification, or analyze why a test fails.

The English summary is being prepared. Showing the original description.

Debug proof failures using counterexamples from Nitpick (Isabelle) or QuickChick (Coq) to identify specification errors, missing preconditions, and proof strategy issues. Use when: (1) A proof attempt fails and you need to understand why, (2) Counterexamples are generated by Nitpick or QuickChick, (3) Specifications may be incorrect or incomplete, (4) Theorems need validation before proving, (5) Missing preconditions or lemmas need identification, or (6) Proof failures need explanation and correction suggestions. Supports both Isabelle/HOL and Coq equally.

The English summary is being prepared. Showing the original description.

Turn selected research conversations or notes into themes supported by evidence and counterexamples. Distinguish observed behavior from preferences and hypotheses, assess confidence, and suggest a small next experiment with an observable measure of success.

• Finding recurring themes across research interviews
• Comparing evidence, counterexamples, and confidence
• Planning a small experiment to test findings

Review mathematical proofs in LaTeX for logical gaps, missing assumptions, and unjustified steps. Attempt counterexamples, develop explicit repairs, and repeat the review, producing an audit report that distinguishes completed fixes from assumptions and unresolved proof obligations.

• Checking theorem assumptions and logical dependencies
• Finding counterexamples to key lemmas
• Repairing missing derivations in LaTeX proofs

Helps write and review mathematical proofs in natural language. It clarifies assumptions, maps dependencies between claims and lemmas, checks counterexamples and edge cases, and produces a traceable draft that identifies unresolved gaps or necessary changes to the statement.

• Filling gaps in a mathematical proof draft
• Mapping dependencies between claims and lemmas
• Searching for counterexamples and edge cases

Check mathematical expressions, solve equations, and search bounded ranges for counterexamples using symbolic and numerical libraries. Record assumptions, commands, and results so calculations can be repeated, while keeping computational evidence distinct from general mathematical proof.

• Checking identities and integrals with exact arithmetic
• Searching a defined range for counterexamples
• Cross-checking numerical results at higher precision

Automatically repair C/C++ code violations detected by TLA+ model checking. Takes a program, TLA+ specification, and TLC counterexample trace as input, then generates minimal code modifications to eliminate the violation. Use when: (1) TLC model checker reports an invariant violation, deadlock, or temporal property failure, (2) You have a counterexample trace and need to fix the corresponding code, (3) You need to understand how a TLA+ violation maps to program-level bugs, (4) You want to validate repairs by re-running TLC. Supports safety properties (invariants), liveness properties (temporal logic), and deadlock detection.

The English summary is being prepared. Showing the original description.

Generate concrete counterexamples when formal verification, assertions, or specifications fail. Use this skill when debugging failed proofs, understanding why verification fails, creating minimal reproducing examples, analyzing assertion violations, investigating invariant breaks, or diagnosing specification mismatches. Produces concrete input values, execution traces, and state information that demonstrate the failure.

The English summary is being prepared. Showing the original description.

Refute-before-prove research discipline: automated counterexample sweeps before any formalization, meter-integrity audits for information-bound experiments, mutation-tested model checkers, pre-registered commit-or-cut gates for speculative directions, wrong-turn reporting, and numeric-claim provenance. Use when validating any new theorem, bound, equilibrium, or security claim; when building or trusting a checker, simulator, or experiment; or when deciding whether a speculative research direction lives or dies. NOT for exploratory brainstorming, product prioritization, writing style, or literature review.

The English summary is being prepared. Showing the original description.

Design and build an OpenMAIC lesson series using a spiral curriculum: core ideas return with deeper explanations, new representations, and unfamiliar applications. It maps conceptual growth across lessons and checks that revisits add understanding.

• Designing a Bruner-style spiral curriculum
• Moving from concrete examples to general models across lessons
• Revisiting concepts through unfamiliar applications and counterexamples

Use a constructive thinking partner to review assumptions, separate evidence from interpretation, and test alternative explanations. Refine conclusions and wording so claims match the available evidence and support decisions under uncertainty.

• Checking assumptions before an important decision
• Reviewing whether evidence supports a conclusion
• Testing alternative explanations and counterexamples

Strengthen existing tests with fast-check by checking properties across generated inputs. Find bugs that example tests miss and reduce failing inputs to small, reproducible cases. Property testing is available; the other listed workflows remain planned.

• Checking parser behavior across generated inputs
• Testing serialization and deserialization round trips
• Finding pure functions covered only by example tests

Develop mathematical proofs for machine learning and AI theory by checking assumptions, intermediate results, and edge cases. Produce a complete proof, a corrected claim with its proof, or a report explaining the unresolved gap.

• Draft a proof of a theorem or lemma
• Expand a proof sketch into justified steps
• Check for hidden assumptions and counterexamples

Check mathematical proofs in LaTeX with review by a separate AI model. Identify missing assumptions and unsupported steps, explore counterexamples, repair derivations, and keep an audit record of issues, changes, and follow-up reviews.

• Checking proofs in a theory paper
• Finding missing assumptions in lemmas
• Repairing gaps in mathematical derivations

Writes, reviews, and debugs property-based tests, which generate inputs to check general rules. Helps test conversions, parsers, normalization, and state invariants, assess whether existing assertions are meaningful, and distinguish faulty rules from implementation bugs.

• Testing encode/decode round trips across generated inputs
• Checking normalization and sorting properties
• Reviewing whether existing property tests assert meaningful rules

Role profile — a reviewer who is fact-seeking, bedrock-seeking, honest, and rejecting. Demands that arguments rest on small facts that cannot be wrong (not on stacked assumptions dressed up as foundation), and that deliberately-unclear concepts be quarantined — never leaked into solid layers, never mixed with each other. Catches the failure mode where designs ship after partial grounding: most of the spec researched, the design feels finished, and the unresearched remainder holds the deal-breaker. Invoke with `/pedantic <target>` (e.g. `/pedantic review this design doc`, `/pedantic review the SDK design`, `/pedantic review this PR`). Probes cover logical structure (definitions, assumptions, boundaries, contradictions, unfalsifiability, vague quantifiers, counterexamples), epistemic honesty (researchable vs. discoverable-only-by-doing), bedrock integrity (assumed-bedrock, leaked uncertainty, mixed unclarity), and design pathology (YAGNI, wrong-layer abstraction, unclear responsibility, fragmentation, over-engineering). Use when you want a hard critique of a plan, design doc, technical doc, code change, or PR description — not a copy edit, not a vibe check.

The English summary is being prepared. Showing the original description.

Teaches how to reason from a transaction protocol’s rules to a working model. Use when analyzing a concurrency-control paper, spec, or algorithm to identify state, metadata, invariants, operation rules, examples, counterexamples, guarantees, false aborts, unsafe commits, or tradeoffs before inspecting concrete traces.

The English summary is being prepared. Showing the original description.

Hardware verification tool for checking functional equivalence between two RTL designs (Verilog). Use when users need to: (1) Verify if two RTL versions are functionally equivalent, (2) Compare original vs. refactored RTL code, (3) Validate design changes or optimizations, (4) Identify semantic vs. cosmetic differences, (5) Generate counterexamples for non-equivalent designs. Analyzes interface alignment, state variables, logic differences, and produces detailed equivalence verdicts with plain language explanations. Particularly effective for design verification, code reviews, and regression testing of RTL modifications.

The English summary is being prepared. Showing the original description.

Think and work like an expert Algorithms Researcher. Use when a task calls for Algorithms Researcher judgment. Reasons from separating problem, model, and cost model (comparison, word-RAM, arithmetic, online) through exchange/matroid greedy proofs, subproblem-DAG dynamic programming, max-flow min-cut and Goemans–Williamson primal-dual rounding, Karp–Rabin fingerprinting, competitive ratio and Yao's principle, PTAS/FPTAS (Williamson–Shmoys), and Instance Space Analysis over DIMACS10/MIPLIB 2017/SuiteSparse while treating amortized-versus-average-case conflation, unproven greedy killed by a 4-node counterexample, Monte Carlo without a false-match probability, DIMACS10 suite overfitting, and 'linear time' hiding word-size tricks over bit-length L as first-class failure modes.

The English summary is being prepared. Showing the original description.

Proof writing and verification techniques for mathematical reasoning. Covers 13 proof strategies with canonical worked examples — direct, contrapositive, contradiction, cases, WLOG, vacuous/trivial, biconditional, counterexample, existence (constructive and non-constructive), uniqueness, induction (weak, strong, structural), pigeonhole/double-counting, and diagonal argument/invariants. Use when writing, verifying, or selecting proof strategies for any mathematical claim.

The English summary is being prepared. Showing the original description.

Solve competition math problems (IMO, Putnam, USAMO, AIME) with adversarial verification that catches the errors self-verification misses. Activates when asked to 'solve this IMO problem', 'prove this olympiad inequality', 'verify this competition proof', 'find a counterexample', 'is this proof correct', or for any problem with 'IMO', 'Putnam', 'USAMO', 'olympiad', or 'competition math' in it. Uses pure reasoning (no tools) — then a fresh-context adversarial verifier attacks the proof using specific failure patterns, not generic 'check logic'. Outputs calibrated confidence — will say 'no confident solution' rather than bluff. If LaTeX is available, produces a clean PDF after verification passes.

The English summary is being prepared. Showing the original description.