playbooks

home / skills / a5c-ai / babysitter / theorem-prover-interface

theorem-prover-interface skill

/plugins/babysitter/skills/babysit/process/specializations/domains/science/computer-science/skills/theorem-prover-interface

This skill helps you harness interactive theorem provers for mechanized verification, generating proofs, automating tactics, and extracting certified code.

npx playbooks add skill a5c-ai/babysitter --skill theorem-prover-interface

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
965 B
---
name: theorem-prover-interface
description: Interface with interactive theorem provers for mechanized verification
allowed-tools:
  - Bash
  - Read
  - Write
  - Edit
  - Glob
  - Grep
metadata:
  specialization: computer-science
  domain: science
  category: formal-verification
  phase: 6
---

# Theorem Prover Interface

## Purpose

Provides expert guidance on using interactive theorem provers for mechanized formal verification.

## Capabilities

- Coq proof script generation
- Isabelle/HOL interface
- Lean 4 integration
- Proof automation (hammers, tactics)
- Proof library search
- Extraction to executable code

## Usage Guidelines

1. **Prover Selection**: Choose appropriate theorem prover
2. **Formalization**: Formalize definitions and theorems
3. **Proof Development**: Develop proofs interactively
4. **Automation**: Apply automated tactics
5. **Extraction**: Extract certified code if needed

## Tools/Libraries

- Coq
- Isabelle
- Lean
- ACL2

Overview

This skill provides an interface to interactive theorem provers for mechanized verification workflows. It guides selection and use of provers like Coq, Isabelle/HOL, and Lean 4, and helps generate proof scripts, apply automation, and extract certified code. The goal is to make formalization and proof development deterministic and resumable in complex development pipelines.

How this skill works

The skill inspects your specification and recommends a target prover based on expressiveness and toolchain needs. It can generate starter proof scripts, suggest or apply tactics and hammers for automation, and search proof libraries for reusable lemmas. When proofs reach completion, it supports extraction of verified code or transitions to downstream build and verification steps.

When to use it

  • Formalizing algorithms or protocols that require machine-checked proofs
  • Integrating mechanized verification into CI/CD or automated agent workflows
  • Migrating informal proofs into a formal prover like Coq, Isabelle, or Lean
  • Searching for existing lemmas and tactics to speed proof development
  • Extracting certified implementations from proven specifications

Best practices

  • Select the prover that matches your logic and ecosystem needs (Coq for constructive, Isabelle for classical, Lean for research/automation)
  • Start with small, well-typed definitions and prove lemmas incrementally
  • Prefer library reuse: search standard libraries before proving from scratch
  • Mix automation and manual tactics; use automation to discharge routine goals and manual steps for invariants
  • Keep proof scripts modular and document key proof invariants for resumability

Example use cases

  • Generate a Coq proof skeleton and iterate with interactive refinement to verify a sorting algorithm
  • Interface with Isabelle/HOL to formalize and prove properties of a distributed protocol
  • Use Lean 4 integration to prototype mathematical theories and export reusable lemmas
  • Apply proof automation (hammers/tactics) to reduce manual effort on routine proof obligations
  • Extract certified functional code from a proven spec to include in a trusted build

FAQ

Which provers does this skill support?

It supports Coq, Isabelle/HOL, Lean 4, and can coordinate with other tools like ACL2 where applicable.

Can it produce executable code from proofs?

Yes. The skill can guide extraction of certified code from provers that support extraction and help integrate that code into downstream builds.