refinement-step-generator

Generate systematic refinement steps with proof obligations for Isabelle/HOL and Coq.

142|14|Updated Feb 14, 2026
One-click install
npx skills add https://github.com/ArabelaTso/Skills-4-SE --skill refinement-step-generator
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: refinement-step-generator
Source: https://github.com/ArabelaTso/Skills-4-SE/tree/main/skills/refinement-step-generator
Command: npx skills add https://github.com/ArabelaTso/Skills-4-SE --skill refinement-step-generator

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill bridges the gap between abstract specifications and concrete, verifiable code, ensuring correctness through formal methods.

Core Features & Use Cases

  • Systematic Refinement: Guides the transformation of high-level requirements into detailed, executable code.
  • Formal Verification Support: Generates proof obligations at each step to maintain correctness guarantees.
  • Use Case: When developing critical software that requires formal verification, use this Skill to meticulously refine abstract mathematical specifications into proven implementations in languages like Isabelle/HOL or Coq.

Quick Start

Use the refinement-step-generator skill to generate refinement steps for transforming a set specification into a list-based implementation in Isabelle/HOL.

Frequently Asked Questions about refinement-step-generator

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I formalize code from spec to implementation in Isabelle/HOL?

To formalize code from spec to implementation, you generate systematic refinement steps that transform high-level specifications into concrete, verifiable implementations. This process creates proof obligations at each step to maintain correctness guarantees.

What is data refinement in formal verification systems like Coq?

Data refinement in formal verification is the process of transforming abstract mathematical specifications into detailed, executable code. It involves generating proof obligations at each step to ensure the concrete implementation maintains the original correctness guarantees.

Can I use this approach to transform a set specification into a list-based implementation?

Yes, you can use refinement step generation to transform a set specification into a list-based implementation. It systematically guides the transformation while generating proof obligations to verify correctness in systems like Isabelle/HOL.

How do I generate proof obligations during algorithmic refinement?

You generate proof obligations during algorithmic refinement by systematically transforming high-level requirements into detailed code. Each refinement step produces specific proof obligations that must be satisfied to maintain formal correctness guarantees.

What's the best way to bridge the gap between abstract specifications and verifiable code?

The best way to bridge the gap between abstract specifications and verifiable code is through systematic refinement. This method transforms high-level requirements into concrete implementations while generating proof obligations to ensure correctness through formal methods.