Derivative: A Computational Invention Engine

Derivative is a sophisticated computational invention engine designed to transform natural-language requirements into executable, testable systems. By leveraging Forge, its integrated software-building pipeline, it provides end-to-end capabilities that include isolation of generated builds, independent validation, and package management for only those builds that have been meticulously validated.

Key Features

• Transform Requirements into Code: Derivative processes a natural-language requirement, articulating a journey from requirement to typed contract, grounded plan, and ultimately generated code:

  requirement -> typed contract -> grounded plan -> generated code
              -> isolated execution -> independent validation
              -> verified package or explicit failure evidence
  

• Independent Verification: Each generated artifact undergoes a rigorous validation process that confirms it satisfies compiled requirements, quality checks, execution standards, and adversarial contracts at its specific revision. While verified indicates that all necessary conditions are met, it does not imply formal proof or universal correctness.

• Fail-Closed Design: Derivative is built to fail with clarity. It preserves user intent and requirement traceability, ensuring quality contracts through executable obligations. Execution and validation occur within a secure Docker environment, eliminating external network dependencies.

Usage Example

To create a Python CLI that processes CSV contracts and flags impending expirations, users can execute:

python forge.py "Build a Python CLI that reads a CSV of contracts, extracts expiration dates, flags contracts expiring in less than 90 days, writes a summary CSV, and includes tests."

For more advanced operations involving OpenAI-backed capabilities, run:

python forge.py "Build a Python REST service with tests." --mode hybrid

System Architecture

Derivative consists of two interconnected layers:

• Derivative (the computational reasoning substrate) encompasses specialized libraries, determinism, obligation compilation, contradiction detection, and audit functionalities.
• Forge manages software-building contracts, candidate compilation, independent validation, and the fail-closed packaging process.

Each layer plays a vital role in the generation and verification cycle, ensuring that builds are credible and traceable. The stages of this workflow include:

• Requirement Compilation: Maintaining user intent by compiling acceptance obligations.
• Planner Stage: Utilizing the Derivative substrate to produce either a feasible plan or a contradiction certificate.
• Coder Stage: Translating a plan into executable code through approved adapters.
• Validator Stage: Conducting independent checks to prevent self-certification of generated code.
• Packaging Stage: Occurs only after passing all validation checks, ensuring that verified builds are safely packaged.

Current Scope

Supported Features:

• Development of Python CLI, REST services, data pipelines, and libraries.
• Capability profiles that allow for deterministic operation.
• Typed contracts for module and symbol verification.
• Evidence-based testing with Docker isolation.

Limitation: Derivative does not yet support editing of existing repositories, additional programming languages, or formal verification of arbitrary software.

Documentation and Further Reading

• Technical Reference: Detailed examination of contracts, capabilities, validation processes, and schema for building artifacts.
• Benchmark Evidence: Tracks frozen evidences, including test metrics and commands for reproducibility.
• Architecture Boundary: Understanding the relationships between Derivative and Forge and their respective roles.

Conclusion

Derivative stands at the forefront of computational invention, bridging the gap between natural language processing and practical software generation, with an emphasis on accountability, traceability, and validated outputs. This project aims to continuously evolve while maintaining its foundational integrity through stringent evidence preservation and stability evaluations.