Quantum Ledger

The QCOS Quantum Ledger provides enterprise-grade governance for quantum computing workloads, including cryptographic evidence, cost management, and audit capabilities.

Patent Protected

Overview

The Quantum Ledger addresses critical enterprise requirements for quantum computing:

┌─────────────────────────────────────────────────────────────────┐
│                      QUANTUM LEDGER                              │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐              │
│  │   PROVENANCE │  │    FINOPS   │  │   EVIDENCE  │              │
│  │    ENGINE   │  │    ENGINE   │  │    BUNDLES  │              │
│  └─────────────┘  └─────────────┘  └─────────────┘              │
│        │                │                │                       │
│        ▼                ▼                ▼                       │
│  ┌─────────────────────────────────────────────────┐            │
│  │              ENTERPRISE ORCHESTRATOR            │            │
│  └─────────────────────────────────────────────────┘            │
│        │                │                │                       │
│        ▼                ▼                ▼                       │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐              │
│  │    RBAC     │  │   BUDGETS   │  │    AUDIT    │              │
│  │ ENFORCEMENT │  │ MANAGEMENT  │  │   LOGGING   │              │
│  └─────────────┘  └─────────────┘  └─────────────┘              │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

Who Benefits?

🔬 Research Institutions

Challenge	Solution
Reproducibility	Cryptographic proof of exact circuit execution
Audit Requirements	Tamper-evident evidence bundles
Grant Compliance	Cost tracking for funding reports
Collaboration	Provenance sharing with verification

🏢 Enterprises

Challenge	Solution
Cost Control	Budget enforcement before execution
Chargeback	Per-department cost allocation
Compliance	SOC2/ISO27001 audit trails
Governance	RBAC and approval workflows

🏭 Quantum Service Providers

Challenge	Solution
Multi-tenancy	Isolated tenant environments
Billing	Accurate usage metering
SLAs	Execution time guarantees
Reporting	Customer usage dashboards

Core Capabilities

1. Provenance Engine

Cryptographic proof of quantum circuit execution.

Every job execution generates a provenance record containing:

{
  "provenance_id": "prov-2026-abc123",
  "job_id": "job-xyz789",
  "circuit_hash": "sha256:a1b2c3d4e5f6...",
  "config_hash": "sha256:1a2b3c4d5e6f...",
  "result_hash": "sha256:deadbeef1234...",
  "backend_id": "ibm_brisbane",
  "timestamp": "2026-01-04T10:30:00Z",
  "execution_environment": {
    "sdk_version": "2.1.0",
    "backend_version": "1.5.2",
    "calibration_id": "cal-20260104"
  }
}

Use Cases:

Reproduce experiments exactly
Verify results haven't been tampered with
Share verifiable research results
Meet regulatory requirements

2. Evidence Bundles

Tamper-evident records of quantum job execution.

Evidence bundles are cryptographically signed packages containing:

evidence-bundle/
├── manifest.json           # Bundle metadata
├── provenance.json         # Provenance record
├── circuit.qasm            # Original circuit
├── config.json             # Execution configuration
├── results.json            # Execution results
├── telemetry.json          # Performance metrics
├── calibration.json        # Backend calibration data
└── signatures/
    ├── softquantus.sig     # SoftQuantus signature
    └── backend.sig         # Backend signature

Verification:

# Verify evidence bundle
softqcos ledger verify \
    --bundle evidence-bundle.json \
    --output verification-report.json

# Verify with public registry
softqcos ledger verify \
    --bundle evidence-bundle.json \
    --registry https://registry.softquantus.com

3. FinOps Engine

Real-time cost management for quantum workloads.

Cost Estimation (Pre-Submit)

from softqcos_sdk import QCOSClient

client = QCOSClient(api_key="your-api-key")

# Estimate cost before execution
estimate = client.estimate_cost(
    circuit=qasm_string,
    backend="ibm_brisbane",
    shots=10000
)

print(f"Estimated cost: ${estimate.cost_usd:.4f}")
print(f"Queue time: ~{estimate.estimated_queue_minutes} min")

Budget Management

from softqcos_sdk import QCOSClient

client = QCOSClient(api_key="your-api-key")

# Check budget before submitting
budget_check = client.check_budget(
    tenant_id="research-team-alpha",
    estimated_cost=0.50
)

if budget_check.can_proceed:
    result = client.execute(circuit=qasm, shots=10000)
else:
    print(f"Budget exceeded: {budget_check.message}")
    print(f"Remaining: ${budget_check.remaining_usd:.2f}")

Cost Tracking

# Get job with cost information
job = client.get_job("job-xyz789")

print(f"Actual cost: ${job.cost_usd:.4f}")
print(f"Cost breakdown:")
print(f"  - Queue: ${job.cost_breakdown.queue:.4f}")
print(f"  - Compute: ${job.cost_breakdown.compute:.4f}")
print(f"  - Storage: ${job.cost_breakdown.storage:.4f}")

4. Chargeback & Reporting

Multi-tenant cost allocation and reporting.

from softqcos_sdk import QCOSClient

client = QCOSClient(api_key="admin-api-key")

# Generate chargeback report
report = client.ledger.generate_report(
    report_type="chargeback",
    start_date="2026-01-01",
    end_date="2026-01-31",
    group_by=["tenant", "project", "backend"],
    format="csv"
)

# Download report
report.download("january-chargeback.csv")

Report Contents:

Tenant	Project	Backend	Jobs	Shots	Cost (USD)
research-alpha	quantum-ml	ibm_brisbane	150	1.5M	$45.00
research-beta	chemistry	ionq_aria	75	750K	$120.00
engineering	benchmark	simulator	500	5M	$0.00

5. Audit Logging

Complete audit trail for compliance.

All actions are logged with:

{
  "audit_id": "audit-20260104-001",
  "timestamp": "2026-01-04T10:30:00Z",
  "action": "JOB_SUBMITTED",
  "principal": {
    "user_id": "user-123",
    "tenant_id": "research-alpha",
    "roles": ["researcher", "submitter"]
  },
  "resource": {
    "type": "quantum_job",
    "id": "job-xyz789"
  },
  "details": {
    "backend": "ibm_brisbane",
    "estimated_cost_usd": 0.30,
    "circuit_hash": "sha256:abc123..."
  },
  "outcome": "SUCCESS"
}

Query Audit Logs:

# Query audit logs
logs = client.ledger.query_audit(
    tenant_id="research-alpha",
    start_date="2026-01-01",
    actions=["JOB_SUBMITTED", "JOB_COMPLETED", "BUDGET_EXCEEDED"],
    limit=100
)

for entry in logs:
    print(f"{entry.timestamp}: {entry.action} by {entry.principal.user_id}")

Integration

SDK Integration

from softqcos_sdk import QCOSClient

# Initialize with ledger enabled
client = QCOSClient(
    api_key="your-api-key",
    ledger_enabled=True,
    tenant_id="research-alpha",
    project="quantum-ml"
)

# Execute with automatic provenance
result = client.execute(
    circuit=qasm_string,
    backend="ibm_brisbane",
    shots=1024,
    tags={
        "experiment": "vqe-h2",
        "researcher": "alice",
        "grant": "NSF-2026-001"
    }
)

# Access provenance
print(f"Provenance ID: {result.provenance_id}")
print(f"Circuit hash: {result.circuit_hash}")

# Get evidence bundle
bundle = client.ledger.get_evidence_bundle(result.job_id)
bundle.save("experiment-evidence.json")

CLI Integration

# Submit job with ledger tracking
softqcos execute circuit.qasm \
    --backend ibm_brisbane \
    --shots 1024 \
    --ledger \
    --tenant research-alpha \
    --project quantum-ml \
    --tags experiment=vqe-h2,researcher=alice

# Get evidence bundle
softqcos ledger get-evidence job-xyz789 \
    --output evidence.json

# Generate report
softqcos ledger report \
    --type chargeback \
    --start 2026-01-01 \
    --end 2026-01-31 \
    --format csv \
    --output january-chargeback.csv

REST API Integration

# Submit job with ledger
curl -X POST https://api.softquantus.com/v2.1/jobs \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "circuit": "OPENQASM 3.0; ...",
    "backend": "ibm_brisbane",
    "shots": 1024,
    "ledger": {
      "enabled": true,
      "tenant_id": "research-alpha",
      "project": "quantum-ml",
      "tags": {
        "experiment": "vqe-h2"
      }
    }
  }'

# Get evidence bundle
curl https://api.softquantus.com/v2.1/jobs/job-xyz789/evidence \
  -H "Authorization: Bearer $API_KEY" \
  -o evidence.json

Budget Policies

Configure budget enforcement policies:

# budget-policy.yaml
tenant: research-alpha
budget:
  monthly_limit_usd: 1000.00
  daily_limit_usd: 100.00
  per_job_limit_usd: 50.00

policies:
  on_budget_warning:
    threshold_percent: 80
    action: notify
    notify:
      - alice@example.com
      - budget-alerts@example.com

  on_budget_exceeded:
    action: block  # block | notify | soft_block
    message: "Monthly budget exceeded. Contact admin."

  on_per_job_exceeded:
    action: require_approval
    approvers:
      - admin@example.com

cost_tiers:
  standard:
    multiplier: 1.0
  priority:
    multiplier: 1.5
  urgent:
    multiplier: 2.0

Evidence Bundle Verification

Local Verification

from softqcos_sdk import EvidenceBundle

# Load and verify bundle
bundle = EvidenceBundle.load("evidence.json")

verification = bundle.verify()

print(f"Valid: {verification.is_valid}")
print(f"Signatures verified: {verification.signatures_valid}")
print(f"Hashes verified: {verification.hashes_valid}")
print(f"Chain of custody: {verification.chain_valid}")

Public Registry Verification

from softqcos_sdk import QCOSClient

client = QCOSClient(api_key="your-api-key")

# Verify against public registry
verification = client.ledger.verify_bundle(
    bundle_id="bundle-abc123",
    check_registry=True
)

print(f"Registered: {verification.registered}")
print(f"Registration date: {verification.registration_date}")
print(f"Certificate: {verification.certificate_id}")

Compliance Support

The Quantum Ledger supports various compliance frameworks:

Framework	Features Used
SOC 2 Type II	Audit logging, RBAC, encryption
ISO 27001	Evidence bundles, access controls
GDPR	Data provenance, export capabilities
NIST	Cryptographic standards, key management
FDA 21 CFR Part 11	Electronic signatures, audit trails

Pricing

Feature	Free Tier	Pro Tier	Enterprise
Provenance tracking	✅	✅	✅
Evidence bundles	10/month	Unlimited	Unlimited
Budget management	Basic	Advanced	Custom
Audit log retention	7 days	90 days	Unlimited
Chargeback reports	-	✅	✅
KMS integration	-	-	✅
Custom policies	-	-	✅

Getting Started

Enable Ledger in your SDK configuration
Configure Tenant and project settings
Set Budgets for cost control
Tag Jobs for organization
Generate Reports for analysis

from softqcos_sdk import QCOSClient

# Quick start
client = QCOSClient(
    api_key="your-api-key",
    ledger_enabled=True,
    tenant_id="my-team"
)

# Your first tracked job
result = client.execute(
    circuit="OPENQASM 3.0; qubit q; h q; measure q;",
    backend="simulator",
    shots=100
)

print(f"Job ID: {result.job_id}")
print(f"Provenance: {result.provenance_id}")
print(f"Cost: ${result.cost_usd:.4f}")

Support

Documentation: docs.softquantus.com/ledger
API Reference: docs.softquantus.com/api/ledger
Enterprise Support: enterprise@softquantus.com

Overview​

Who Benefits?​

🔬 Research Institutions​

🏢 Enterprises​

🏭 Quantum Service Providers​

Core Capabilities​

1. Provenance Engine​

2. Evidence Bundles​

3. FinOps Engine​

Cost Estimation (Pre-Submit)​

Budget Management​

Cost Tracking​

4. Chargeback & Reporting​

5. Audit Logging​

Integration​

SDK Integration​

CLI Integration​

REST API Integration​

Budget Policies​

Evidence Bundle Verification​

Local Verification​

Public Registry Verification​

Compliance Support​

Pricing​

Getting Started​

Support​