Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    Automated Theorem Proving

    2

    Verify logical claims, prove theorems, and find counterexamples using automated theorem provers like E and Vampire.

    Free

    Security scanned
    Automated Theorem Proving

    Automated Theorem Proving

    Example session with this skill installed

    Check if these axioms are consistent: all humans are mortal, and Socrates is a human. Use the E prover.

    • Read your context and instructions
    • Compiled the automated theorem proving

    I have formalized the axioms in First-Order Formula (FOF) syntax and checked them for consistency using the E prover via the sotptp backend.

    Consistency Check Results

    MetricValue
    DialectFOF (Untyped First-Order Logic)
    ProverE 3.1
    SZS StatusSatisfiable
    ResultThe axioms are consistent and have at least one model.

    Formalized TPTP Input

    % Axiom: All humans are mortal
    fof(all_humans_mortal, axiom, ! [X] : (human(X) => mortal(X))).
    
    % Axiom: Socrates is a human
    fof(socrates_human, axiom, human(socrates)).
    

    The prover returned Satisfiable, which means there is no internal contradiction in these definitions. Since no conjecture was provided, this confirms the logical foundations are sound for further theorem proving.

    Next steps

    1. Add a conjecture, such as fof(socrates_mortal, conjecture, mortal(socrates)), to prove a specific consequence.
    2. Use run_prover with raw: true if you need to inspect the generated model.
    3. Add more entities to the domain to test the scalability of the proof.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Building high-stakes systems requires more than just a plausible LLM response. Natural language arguments are not proofs. This skill integrates the atp_mcp server to connect your agent to the SystemOnTPTP catalogue, enabling machine-checked verification of logical claims using world-class automated theorem provers like E, Vampire, and Leo-III.

    What it does

    • Formal Verification converts natural-language specs, rules, or puzzles into TPTP dialects for rigorous checking.
    • Automated Proving determines if a conjecture follows from axioms with mathematical certainty, returning SZS status verdicts.
    • Model Finding identifies counterexamples when a conjecture is refutable, helping debug flawed specifications.
    • Consistency Auditing checks sets of axioms to ensure they are not self-contradictory or vacuous.
    • Multi-Prover Comparison runs problems across different engines in parallel to find the most efficient proof path.

    How it works

    1. Formalize the problem into the appropriate TPTP dialect (CNF, FOF, TFF, or THF) using standard logic roles.
    2. Lint the problem using lint_problem to catch syntax errors or type mismatches before execution.
    3. Execute via query_backend or run_prover to send the problem to local engines or SystemOnTPTP.
    4. Analyze the SZS verdict, such as Theorem, CounterSatisfiable, or GaveUp, to validate the logic.

    Frameworks & tools

    This skill utilizes the atp_mcp server, SystemOnTPTP (tptp.org), Isabelle/HOL, and provers including E, Vampire, Leo-III, and Paradox. It supports standard TPTP dialects and modal logic (NXF).

    Why this beats prompting it yourself

    LLMs frequently hallucinate logical steps or miss subtle contradictions in complex rule sets. By offloading the actual reasoning to dedicated symbolic engines, you get a machine-verified binary truth rather than a statistical guess.

    Use cases

    • Policy Validation checking if a cloud access policy allows unauthorized states.
    • Puzzle Solving finding solutions to complex constraint problems like scheduling.
    • Proof Auditing verifying each step of a mathematical argument for gaps.
    • Legal Logic formalizing regulations to check for loopholes or inconsistencies.

    Known limitations

    Requires an active atp_mcp server connection. Remote backends like sotptp require network access and are subject to third-party availability and time limits.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for LLM Ops.

    Requires atp_mcp server setup. Isabelle/HOL requires specific docker tags. THF support in E depends on build configuration. Remote backends require internet access.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before buying a skill.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free to use

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 21 days ago

    • Free with an Agensi account

    Permissions

    Network Access
    Listed21 days ago

    What's inside

    Frequently Asked Questions

    This skill integrates with any AI agent or platform supporting the Model Context Protocol (MCP), including Claude Desktop and other MCP-compatible environments, allowing them to communicate with theorem proving servers.

    No, you do not need to host them; this skill allows your agent to connect to the SystemOnTPTP remote catalogue to access world-class engines like Vampire and E without local installation.

    The skill supports standard TPTP dialects including CNF, FOF, TFF, and THF, as well as NXF for modal logic, covering everything from basic propositional logic to higher-order theorems.

    While LLMs excel at translating natural language into logic, they often fail at complex deduction; this skill offloads the actual reasoning to symbolic engines to ensure a mathematically verified 'Theorem' or 'CounterSatisfiable' verdict.

    You receive the full configuration for the atp_mcp server, including the tool definitions for formalizing, linting, and executing logic problems, along with documentation for connecting to TPTP backends.

    The skill includes a 'lint_problem' tool that allows your agent to catch syntax errors or type mismatches in the TPTP code before it is sent to the prover, saving time and compute resources.

    New in LLM Ops

    Free