Constraint-Projected State Computing (CPSC)

Declarative computing through constraint projection

Constraint-Projected State Computing (CPSC) is a declarative computing model in which computation is performed by projecting system state onto explicit constraints, rather than executing ordered instructions. CPSC provides a foundation for deterministic, constraint-driven systems including reasoning engines, compliance enforcement, control systems, and hardware (FPGA/ASIC).

---

What This Repository Contains

• The CPSC technical specification (core computing model)
• CAS-YAML v1.0.0 specification (declarative constraint models)
• Binary interchange format and RTL mapping specifications
• Engine modes and adaptive engine specifications
• Licensing and governance materials

The specification is the primary source of truth.

---

CPSC-RE: Reasoning Engine

The primary product embodiment of CPSC is CPSC-RE — a deterministic, projection-based, general-purpose reasoning engine. CPSC-RE enforces correctness via explicit constraints, operates in bounded deterministic epochs, and provides auditable, replayable transcripts.

CPSC-RE is also a compliance engine: by encoding regulatory controls, governance policies, and security frameworks as constraints, CPSC-RE can enforce them automatically at edge or cloud scale — enabling a Compliance as a Service (CaaS) model.

CPSC-RE specifications and implementation live in the cpsc-engine-rtl repository.

---

Core Concepts

• State — the full configuration of a system
• Constraints — rules defining valid states (hard and soft)
• Projection — resolving state into validity
• Degrees of Freedom — minimal independent information
• Variable Roles — Fixed, External, Free, Derived
• Constraint Fabric — parallel enforcement of rules
• Epoch Cycle — Sense → Compute → Evaluate → Commit

---

Applications

CPSC is applicable to:

• Deterministic reasoning and constraint satisfaction
• Compliance and governance enforcement (CaaS)
• Protocol enforcement and validation
• Power electronics and control systems
• Deterministic AI inference pipelines
• Edge and embedded systems
• FPGA and ASIC acceleration
• Secure state reconstruction
• Telemetry, logging, and replay
• Constraint-governed agentic development (CGAD)

---

Status

CPSC-RE Layers 0–5 are complete in the cpsc-engine-rtl repository (CAS-YAML parser, Constraint IR, Proto-Cell Kernels, Epoch Scheduler, Compiler, Public API).

The specifications in this repository are released for research and evaluation.

---

Patent and prior-art research

This organization maintains a separate docs/patents/ directory for non-normative patent and IP materials related to Constraint-Projected State Computing (CPSC) and Constraint-Projected Adaptive Compression (CPAC).

• Documents under docs/patents/ are legal disclosure and planning artifacts, not specifications.
• A non-normative prior-art search protocol for CPSC/CPAC Themes A and B (paradigm-level computing model and DoF-based compression) is maintained there, together with a simple ledger structure for recording what has been searched and when.
• Contributors using Warp and the local patent_mcp_server MCP backend MAY follow this protocol to run reproducible prior-art and landscape searches using USPTO-backed APIs (PPUBS, PatentSearch/PatentsView), but results remain informational only.
• Standard chat commands beginning with prior-art protocol: (documented in WARP.md and AGENTS.md) provide a repeatable way to ask agents to execute or summarize these searches; they do not change the meaning of any specification.

Patent draft rendering helpers

For local draft PDFs of the CPSC/CPAC provisional (including Mermaid figures), this repository provides:

• A Python wrapper script: scripts/render_markdown_to_pdf.py
• PowerShell helper: scripts/render-docs-pdf.ps1
• Bash helper: scripts/render-docs-pdf.sh (Linux/macOS)

To install PDF rendering tools, run ./setup.ps1 -RenderTools (Windows) or ./setup.sh --render-tools (Linux/macOS).

These are convenience tools around the md2pdf CLI from the md2pdf-mermaid package and use a headless Chromium engine to render Markdown (with Mermaid blocks) to PDF. They do not change the legal status or semantics of any document; they only control local formatting for review.

USPTO / PatentSearch API keys and environment variables

To use the MCP-backed patent tools with live USPTO data, contributors MUST obtain and configure API keys outside this repository:

1. USPTO Open Data Portal API key (USPTO_API_KEY)

   • Create or sign in to a MyUSPTO account at https://my.uspto.gov/.
   • Visit the USPTO Open Data Portal at https://data.uspto.gov/home.
   • Use the key management page at https://data.uspto.gov/myodp/key-reveal to generate or reveal your Open Data Portal API key.
   • Store the key as a user-level environment variable so it is available as $env:USPTO_API_KEY (for example, using the PowerShell instructions in WARP.md §14.2), or in a local .env file consumed by patent_mcp_server.

2. PatentsView / PatentSearch API key (PATENTSVIEW_API_KEY)

   • Request a PatentsView PatentSearch API key via the official support portal at https://patentsview-support.atlassian.net/servicedesk/customer/portal/1/group/1/create/18.
   • General PatentsView information is available at https://patentsview.org/home.
   • Once issued, store the key so it is available to tools as $env:PATENTSVIEW_API_KEY (for example, as a user-level environment variable or in a local .env file that patent_mcp_server reads).

3. Security and repository hygiene

   • API keys MUST NOT be committed to this repository in any form (no checked-in .env files, scripts, or JSON containing secrets).
   • MCP configuration examples in WARP.md and related scripts are designed to read keys from the environment (USPTO_API_KEY, PATENTSVIEW_API_KEY) rather than from tracked files.

All patent-related work must respect the repository’s licensing and IP reservations. Patent rights are governed solely by filed applications and issued patents, not by this repository or any MCP-backed tooling.

---

Licensing

The CPSC specification and related documents are released under the CPSC Research & Evaluation License.

• Non-commercial research, evaluation, and educational use is permitted
• Commercial use requires a separate license

For a plain-language explanation, see LEGAL-FAQ.md.

---

Getting Started

1. Read docs/specification/CPSC-Specification.md (core computation model)
2. Read docs/specification/CAS-YAML-Specification.md (v1.0.0 constraint model format)
3. Read docs/specification/CPSC-Engine-Modes-Specification.md (projection engines)
4. Consult docs/LEGAL-FAQ.md for licensing guidance

---

Agent Session Management

This repository supports AI agent workflows with session commands.

Resuming a Session (New Agent)

When starting a new agent session, use this prompt:

You are in the cpsc-core repository (CPSC specification); first read and internalize AGENTS.md and WARP.md, then execute the load session command as defined in AGENTS.md.

Session Commands

Command	Description
load session	Pull latest changes and summarize any relevant updates.
save session	Update relevant docs and commit changes locally without pushing.
save session and push	Same as save session, then push to the default remote.
push to git	Stage, commit, and push current work to origin.

See AGENTS.md and WARP.md for full agent instructions.

---

Contact

For research questions, discussion, or licensing inquiries, contact BitConcepts, LLC.

---

CPSC Specifications