ACOS Capabilities

Complete reference of the ACOS-ISA v1.0 (Adaptive Conformance Operating Standard) certification program.

Overview

ACOS is SoftQuantus's certification program for quantum backends. It provides:

• Conformance Testing: Standardized test suite for QCOS compatibility
• Certification Tiers: Bronze, Silver, Gold, Platinum levels
• Evidence Bundles: Cryptographically signed proof of conformance
• Public Registry: Searchable database of certified backends

Installation

# Docker (recommended for certification runs)
docker pull sqtprodacr.azurecr.io/softqcos-acos:1.0.0-amd64

# Python (for development)
pip install softqcos-sdk

---

ACOS-ISA v1.0 Test Suite

The ACOS-ISA v1.0 specification defines 25+ conformance tests organized by category.

Test Categories

Category	Tests	Description
Basic Gates	8	Single-qubit gates (X, Y, Z, H, S, T, Rx, Ry)
Two-Qubit Gates	4	CNOT, CZ, SWAP, controlled rotations
Multi-Qubit	3	Toffoli, Fredkin, multi-control gates
Circuits	5	Bell state, GHZ, QFT, VQE ansatz
Measurement	3	Z-basis, multi-qubit, mid-circuit
Error Handling	2	Invalid input handling, timeout behavior

Test Execution

# Run full ACOS-ISA v1.0 conformance suite
docker run --rm \
  -v /path/to/backend-config.json:/config.json \
  sqtprodacr.azurecr.io/softqcos-acos:1.0.0-amd64 \
  run-conformance --config /config.json

# List available tests
docker run --rm sqtprodacr.azurecr.io/softqcos-acos:1.0.0-amd64 list-tests

# Run specific test category
docker run --rm \
  sqtprodacr.azurecr.io/softqcos-acos:1.0.0-amd64 \
  run-conformance --category basic_gates

---

Certification Tiers

Tier	Requirements	Badge
Bronze	80% tests pass, basic gates	🥉
Silver	90% tests pass, two-qubit gates	🥈
Gold	95% tests pass, all categories	🥇
Platinum	100% tests pass + stability	💎

Tier Requirements Detail

TIER_REQUIREMENTS = {
    "bronze": TierRequirement(
        min_pass_rate=0.80,
        required_categories=["basic_gates"],
        optional_categories=["two_qubit"],
        stability_required=False,
    ),
    "silver": TierRequirement(
        min_pass_rate=0.90,
        required_categories=["basic_gates", "two_qubit"],
        optional_categories=["circuits"],
        stability_required=False,
    ),
    "gold": TierRequirement(
        min_pass_rate=0.95,
        required_categories=["basic_gates", "two_qubit", "circuits", "measurement"],
        optional_categories=["multi_qubit"],
        stability_required=True,
    ),
    "platinum": TierRequirement(
        min_pass_rate=1.00,
        required_categories=["all"],
        optional_categories=[],
        stability_required=True,
        max_flaky_tests=0,
    ),
}

---

Python API

Running Conformance Tests

from acos import (
    ACOSISATestRunnerV1,
    run_acos_isa_conformance,
    BackendProtocol,
)

# Implement your backend
class MyQuantumBackend(BackendProtocol):
    def execute(self, qasm: str, shots: int) -> dict:
        # Execute circuit and return counts
        return {"00": 500, "11": 500}

    def get_info(self) -> dict:
        return {
            "name": "MyBackend",
            "version": "1.0.0",
            "num_qubits": 20,
        }

# Run conformance
backend = MyQuantumBackend()
report = run_acos_isa_conformance(backend)

print(f"Pass Rate: {report.pass_rate:.1%}")
print(f"Tier Achieved: {report.tier}")
print(f"Certificate ID: {report.certificate_id}")

Test Runner Options

runner = ACOSISATestRunnerV1(
    backend=backend,
    shots=1024,                    # Shots per test
    tolerance_profile="trapped_ion",  # Hardware type
    parallel=True,                 # Run tests in parallel
    timeout=300,                   # Timeout per test (seconds)
    retry_flaky=3,                 # Retry flaky tests
)

report = runner.run_all()

---

Evidence Bundles

ACOS creates cryptographically signed evidence bundles for audit and compliance.

Evidence Structure

from acos import create_evidence_bundle, ACOSEvidenceBundle

bundle = create_evidence_bundle(
    report=report,
    backend_info=backend.get_info(),
    tenant_id="tenant_001",
    sign=True,  # Sign with SoftQuantus keys
)

# Save bundle
bundle.save("evidence_2026-01-03.json")

# Bundle contents
print(bundle.bundle_id)      # Unique identifier
print(bundle.merkle_root)    # Integrity hash
print(bundle.signatures)     # Cryptographic signatures
print(bundle.items)          # Evidence items

Evidence Items

Each bundle contains:

Item	Description
test_results	Individual test results
backend_info	Backend metadata
environment	Execution environment
timestamps	Created/completed times
merkle_tree	Integrity verification
signatures	Cryptographic signatures

Offline Verification

# Verify bundle without network access
softqcos verify evidence.json

# With public key
softqcos verify evidence.json --public-key softquantus-public.pem

# JSON output
softqcos verify evidence.json --format json

---

Stability Testing

For Gold and Platinum tiers, stability testing is required.

Tolerance Profiles

from acos import get_tolerance_profile, QuantumTechnology

# Get tolerance for hardware type
profile = get_tolerance_profile(QuantumTechnology.TRAPPED_ION)

print(profile.fidelity_threshold)    # 0.99
print(profile.max_deviation)         # 0.02
print(profile.min_consistency)       # 0.95

Supported Technologies:

Technology	Fidelity	Deviation	Consistency
trapped_ion	99%	2%	95%
superconducting	95%	5%	90%
photonic	97%	3%	93%
neutral_atom	96%	4%	92%
simulator	99.9%	0.1%	99%

Stability Configuration

from acos import TestStabilityConfig, ACOS_ISA_STABILITY_CONFIG

config = ACOS_ISA_STABILITY_CONFIG

print(config.min_runs)           # 10
print(config.consistency_threshold)  # 0.90
print(config.max_flaky_rate)     # 0.05

---

Vendor Pack

Complete documentation package for backend vendors.

Generate Vendor Pack

from acos import generate_vendor_pack, VendorPackConfig

config = VendorPackConfig(
    vendor_name="Acme Quantum",
    backend_name="AcmeQ-1000",
    technology="superconducting",
    num_qubits=50,
    contact_email="quantum@acme.com",
)

pack = generate_vendor_pack(config)
pack.save("vendor-pack/")

Vendor Pack Contents

vendor-pack/
├── README.md              # Quick start guide
├── CHECKLIST.md           # Certification checklist
├── integration/
│   ├── backend_template.py    # Backend implementation template
│   ├── test_runner.py         # Local test runner
│   └── docker-compose.yml     # Local testing environment
├── docs/
│   ├── ACOS-ISA-v1.0.pdf      # Specification document
│   ├── API-REFERENCE.md       # BackendProtocol reference
│   └── TROUBLESHOOTING.md     # Common issues
└── examples/
    ├── basic_integration.py   # Simple example
    └── advanced_integration.py # Full featured example

Certification Checklist

from acos import VendorChecklist, VENDOR_CHECKLIST

checklist = VENDOR_CHECKLIST

for item in checklist.items:
    print(f"[{'✓' if item.completed else ' '}] {item.title}")
    print(f"    {item.description}")

---

Public Registry

Certified backends are listed in the public registry.

Registry API

from acos import BackendRegistry, RegistryAPI

# Query registry
registry = RegistryAPI()

# List all certified backends
backends = registry.list_certified()
for b in backends:
    print(f"{b.name}: {b.tier} ({b.certificate_id})")

# Search by tier
gold_backends = registry.search(tier="gold")

# Get certificate details
cert = registry.get_certificate("cert_abc123")

Registry Entry

@dataclass
class RegistryEntry:
    backend_id: str
    backend_name: str
    vendor_name: str
    tier: CertificationTier
    certificate_id: str
    certified_at: datetime
    expires_at: datetime
    pass_rate: float
    technology: str
    num_qubits: int
    public_url: str

---

Ledger Integration

Track certified executions for compliance.

from acos import CertifiedExecutionLedger, capture_certification_ref

# Capture certification during execution
ledger = CertifiedExecutionLedger(tenant_id="tenant_001")

with capture_certification_ref(ledger) as ref:
    result = backend.execute(circuit, shots=1024)

print(ref.certificate_id)
print(ref.execution_id)
print(ref.evidence_bundle_id)

Compliance Reports

from acos import ComplianceReporter

reporter = ComplianceReporter(ledger)

# Generate compliance report
report = reporter.generate_report(
    start_date="2026-01-01",
    end_date="2026-01-31",
    format="pdf"
)

report.save("compliance-january-2026.pdf")

---

CLI Commands

Docker CLI

# List all ACOS-ISA v1.0 tests
docker run --rm sqtprodacr.azurecr.io/softqcos-acos:1.0.0-amd64 list-tests

# Run conformance suite
docker run --rm \
  -v ./config.json:/config.json \
  -v ./output:/output \
  sqtprodacr.azurecr.io/softqcos-acos:1.0.0-amd64 \
  run-conformance \
    --config /config.json \
    --output /output/report.json \
    --evidence /output/evidence.json

# Generate vendor pack
docker run --rm \
  -v ./vendor-pack:/output \
  sqtprodacr.azurecr.io/softqcos-acos:1.0.0-amd64 \
  generate-vendor-pack \
    --vendor "Acme Quantum" \
    --backend "AcmeQ-1000" \
    --output /output

---

Integration Examples

Qiskit Backend

from qiskit_aer import AerSimulator
from acos import BackendProtocol, run_acos_isa_conformance

class QiskitACOSBackend(BackendProtocol):
    def __init__(self):
        self.simulator = AerSimulator()

    def execute(self, qasm: str, shots: int) -> dict:
        from qiskit import QuantumCircuit
        circuit = QuantumCircuit.from_qasm_str(qasm)
        job = self.simulator.run(circuit, shots=shots)
        return job.result().get_counts()

    def get_info(self) -> dict:
        return {
            "name": "Qiskit Aer Simulator",
            "version": "0.13.0",
            "num_qubits": 30,
            "technology": "simulator",
        }

# Run certification
backend = QiskitACOSBackend()
report = run_acos_isa_conformance(backend)
print(f"Certified: {report.tier}")

IBM Quantum Backend

from qiskit_ibm_runtime import QiskitRuntimeService
from acos import BackendProtocol

class IBMQuantumBackend(BackendProtocol):
    def __init__(self, backend_name="ibm_kyoto"):
        self.service = QiskitRuntimeService()
        self.backend = self.service.backend(backend_name)

    def execute(self, qasm: str, shots: int) -> dict:
        from qiskit import QuantumCircuit
        circuit = QuantumCircuit.from_qasm_str(qasm)
        job = self.backend.run(circuit, shots=shots)
        return job.result().get_counts()

    def get_info(self) -> dict:
        return {
            "name": self.backend.name,
            "num_qubits": self.backend.num_qubits,
            "technology": "superconducting",
        }

---

Exported Components

from acos import (
    # Test Suite
    ACOS_ISA_V1_TESTS,
    ACOSISATestSpec,

    # Runner
    ACOSTestRunner,
    ACOSISATestRunnerV1,
    run_acos_isa_conformance,

    # Results
    ACOSTestStatus,
    ACOSTestResult,
    ACOSISAReport,

    # Evidence
    ACOSEvidenceBundle,
    EvidenceItem,
    Signature,
    create_evidence_bundle,

    # Protocol
    BackendProtocol,

    # Stability
    QuantumTechnology,
    ToleranceProfile,
    get_tolerance_profile,

    # Tiers
    CertificationTier,
    TierRequirement,
    Certificate,
    issue_certificate,
    Badge,

    # Trust
    KeyStore,
    LocalKeyStore,
    PublicVerificationService,

    # Registry
    BackendRegistry,
    RegistryAPI,
    RegistryEntry,

    # Ledger
    CertifiedExecutionLedger,
    ComplianceReporter,

    # Vendor Pack
    VendorPackConfig,
    generate_vendor_pack,
    VENDOR_CHECKLIST,
)

---

© 2024-2026 SoftQuantus innovative OÜ. All Rights Reserved. Patent pending — Registration FR2513440.