🏛️ National Quantum Initiatives

Open tools for government quantum computing programs and research agencies.

Why QCOS for National Programs?

Requirement	QCOS Solution
Vendor neutrality	Open standards, no lock-in
Sovereignty concerns	EU-based infrastructure (LUMI)
Reproducibility	Full audit trail
Scale	Up to 100 qubits
Accessibility	Open API + documentation

Supported National Programs

QCOS is designed to support quantum initiatives including:

🇩🇪 DLR Quantum Computing Initiative (Germany)
🇫🇷 CEA-Leti / France Quantique (France)
🇫🇮 VTT / IQM Finnish Quantum (Finland)
🇦🇹 AQT / Austrian Quantum Initiative (Austria)
🇳🇱 QuTech / Quantum Delta NL (Netherlands)
🇪🇺 EuroQCS / LUMI Quantum (EU)

Use Case: National Quantum Testbed

Multi-Institution Research Platform

from qcos import QCOSClient
from qcos.auth import InstitutionalAuth
import json
from datetime import datetime

# Institutional authentication
client = QCOSClient(
    api_key="institutional-api-key",
    organization="dlr.de",
    project="quantum-testbed-2024"
)

class NationalQuantumTestbed:
    """
    Platform for multi-institution quantum research.
    """
    
    def __init__(self, client: QCOSClient):
        self.client = client
        self.experiments = []
    
    def submit_experiment(
        self,
        circuit: str,
        metadata: dict,
        institution: str,
        researcher: str
    ) -> dict:
        """
        Submit experiment with full provenance tracking.
        """
        experiment_id = f"{institution}-{datetime.now().strftime('%Y%m%d%H%M%S')}"
        
        result = self.client.execute(
            qasm=circuit,
            shots=metadata.get('shots', 1024)
        )
        
        experiment_record = {
            'experiment_id': experiment_id,
            'institution': institution,
            'researcher': researcher,
            'timestamp': datetime.now().isoformat(),
            'circuit_hash': hash(circuit),
            'metadata': metadata,
            'result': {
                'job_id': result.job_id,
                'counts': result.counts,
                'execution_time': result.execution_time,
                'backend': result.backend
            }
        }
        
        self.experiments.append(experiment_record)
        return experiment_record
    
    def generate_report(self) -> str:
        """
        Generate research report for national program.
        """
        report = f"""
# National Quantum Testbed Report

Generated: {datetime.now().isoformat()}
Total Experiments: {len(self.experiments)}

## Participating Institutions

"""
        institutions = set(e['institution'] for e in self.experiments)
        for inst in institutions:
            count = sum(1 for e in self.experiments if e['institution'] == inst)
            report += f"- {inst}: {count} experiments\n"
        
        report += "\n## Experiments Summary\n\n"
        report += "| ID | Institution | Qubits | Shots | Time |\n"
        report += "|-----|-------------|--------|-------|------|\n"
        
        for exp in self.experiments:
            report += f"| {exp['experiment_id'][:20]} | "
            report += f"{exp['institution']} | "
            report += f"{exp['metadata'].get('qubits', 'N/A')} | "
            report += f"{exp['metadata'].get('shots', 1024)} | "
            report += f"{exp['result']['execution_time']:.3f}s |\n"
        
        return report
    
    def export_data(self, filename: str):
        """
        Export all experiment data for archival.
        """
        with open(filename, 'w') as f:
            json.dump(self.experiments, f, indent=2, default=str)

# Usage example
testbed = NationalQuantumTestbed(client)

# Experiment from DLR
exp1 = testbed.submit_experiment(
    circuit="""
    OPENQASM 2.0;
    include "qelib1.inc";
    qreg q[5];
    creg c[5];
    h q[0];
    cx q[0],q[1];
    cx q[1],q[2];
    cx q[2],q[3];
    cx q[3],q[4];
    measure q -> c;
    """,
    metadata={'qubits': 5, 'shots': 2048, 'type': 'GHZ'},
    institution='DLR',
    researcher='Dr. Mueller'
)

# Experiment from CEA
exp2 = testbed.submit_experiment(
    circuit="""
    OPENQASM 2.0;
    include "qelib1.inc";
    qreg q[4];
    creg c[4];
    h q[0]; h q[1]; h q[2]; h q[3];
    measure q -> c;
    """,
    metadata={'qubits': 4, 'shots': 1024, 'type': 'superposition'},
    institution='CEA',
    researcher='Dr. Dupont'
)

# Generate report
report = testbed.generate_report()
print(report)

# Export data
testbed.export_data('testbed_data_2024.json')

Use Case: Quantum Education Platform

National Quantum Curriculum Support

from qcos import QCOSClient
from dataclasses import dataclass
from typing import List, Optional

client = QCOSClient()

@dataclass
class QuantumExercise:
    title: str
    description: str
    template_circuit: str
    solution_circuit: str
    hints: List[str]
    difficulty: str  # 'beginner', 'intermediate', 'advanced'

class QuantumEducationPlatform:
    """
    Educational platform for national quantum curriculum.
    """
    
    def __init__(self, client: QCOSClient):
        self.client = client
        self.exercises = self._load_curriculum()
    
    def _load_curriculum(self) -> List[QuantumExercise]:
        """
        Load national quantum computing curriculum.
        """
        return [
            QuantumExercise(
                title="1.1 - Quantum Superposition",
                description="Create a qubit in superposition using the Hadamard gate.",
                template_circuit="""
OPENQASM 2.0;
include "qelib1.inc";
qreg q[1];
creg c[1];

// TODO: Apply Hadamard gate to create superposition

measure q -> c;
""",
                solution_circuit="""
OPENQASM 2.0;
include "qelib1.inc";
qreg q[1];
creg c[1];
h q[0];
measure q -> c;
""",
                hints=[
                    "The Hadamard gate creates equal superposition",
                    "In OpenQASM, the Hadamard gate is 'h'",
                    "Syntax: h q[0];"
                ],
                difficulty="beginner"
            ),
            QuantumExercise(
                title="1.2 - Quantum Entanglement",
                description="Create a Bell state (maximally entangled pair).",
                template_circuit="""
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];

// TODO: Create Bell state |Φ+⟩ = (|00⟩ + |11⟩)/√2

measure q -> c;
""",
                solution_circuit="""
OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
creg c[2];
h q[0];
cx q[0], q[1];
measure q -> c;
""",
                hints=[
                    "Start with superposition on one qubit",
                    "Use CNOT to create entanglement",
                    "The result should show only |00⟩ and |11⟩"
                ],
                difficulty="beginner"
            ),
            QuantumExercise(
                title="2.1 - GHZ State",
                description="Create a 5-qubit GHZ state.",
                template_circuit="""
OPENQASM 2.0;
include "qelib1.inc";
qreg q[5];
creg c[5];

// TODO: Create GHZ state (|00000⟩ + |11111⟩)/√2

measure q -> c;
""",
                solution_circuit="""
OPENQASM 2.0;
include "qelib1.inc";
qreg q[5];
creg c[5];
h q[0];
cx q[0], q[1];
cx q[1], q[2];
cx q[2], q[3];
cx q[3], q[4];
measure q -> c;
""",
                hints=[
                    "GHZ extends Bell state to more qubits",
                    "Chain of CNOT gates propagates entanglement",
                    "Only two outcomes should appear"
                ],
                difficulty="intermediate"
            ),
        ]
    
    def validate_solution(self, exercise_id: int, student_circuit: str) -> dict:
        """
        Validate student's solution.
        """
        exercise = self.exercises[exercise_id]
        
        # Run student solution
        try:
            student_result = self.client.execute(
                qasm=student_circuit,
                shots=1000
            )
        except Exception as e:
            return {
                'passed': False,
                'error': str(e),
                'feedback': 'Circuit syntax error. Check your code.'
            }
        
        # Run expected solution
        expected_result = self.client.execute(
            qasm=exercise.solution_circuit,
            shots=1000
        )
        
        # Compare results
        student_probs = {k: v/1000 for k, v in student_result.counts.items()}
        expected_probs = {k: v/1000 for k, v in expected_result.counts.items()}
        
        # Check if distributions match (with tolerance)
        all_states = set(student_probs.keys()) | set(expected_probs.keys())
        max_diff = max(
            abs(student_probs.get(s, 0) - expected_probs.get(s, 0))
            for s in all_states
        )
        
        passed = max_diff < 0.1  # 10% tolerance
        
        return {
            'passed': passed,
            'student_result': student_result.counts,
            'expected_result': expected_result.counts,
            'feedback': 'Correct!' if passed else 'Not quite right. Check the probability distribution.',
            'execution_time': student_result.execution_time
        }
    
    def get_exercise(self, exercise_id: int) -> dict:
        """
        Get exercise for student.
        """
        ex = self.exercises[exercise_id]
        return {
            'title': ex.title,
            'description': ex.description,
            'template': ex.template_circuit,
            'difficulty': ex.difficulty,
            'hints_available': len(ex.hints)
        }
    
    def get_hint(self, exercise_id: int, hint_number: int) -> str:
        """
        Get progressive hint.
        """
        ex = self.exercises[exercise_id]
        if hint_number < len(ex.hints):
            return ex.hints[hint_number]
        return "No more hints available."

# Usage
platform = QuantumEducationPlatform(client)

# Student workflow
exercise = platform.get_exercise(0)
print(f"Exercise: {exercise['title']}")
print(f"Description: {exercise['description']}")
print(f"Template:\n{exercise['template']}")

# Student submits solution
student_code = """
OPENQASM 2.0;
include "qelib1.inc";
qreg q[1];
creg c[1];
h q[0];
measure q -> c;
"""

result = platform.validate_solution(0, student_code)
print(f"\nResult: {'PASSED' if result['passed'] else 'FAILED'}")
print(f"Feedback: {result['feedback']}")

Use Case: National Research Data Infrastructure

FAIR Data Principles for Quantum Research

from qcos import QCOSClient
import hashlib
import json
from datetime import datetime

client = QCOSClient()

class FAIRQuantumDataset:
    """
    FAIR-compliant quantum experiment dataset.
    
    Findable: DOI + metadata
    Accessible: Open API
    Interoperable: Standard formats (OpenQASM, JSON)
    Reusable: Full provenance + license
    """
    
    def __init__(self, dataset_id: str, title: str, creators: list):
        self.dataset_id = dataset_id
        self.title = title
        self.creators = creators
        self.experiments = []
        self.created = datetime.now().isoformat()
    
    def add_experiment(self, circuit: str, metadata: dict) -> str:
        """
        Add experiment with full metadata.
        """
        # Execute circuit
        result = client.execute(qasm=circuit, shots=metadata.get('shots', 1024))
        
        # Create FAIR-compliant record
        experiment_record = {
            'id': f"{self.dataset_id}/{len(self.experiments):04d}",
            'circuit': {
                'qasm': circuit,
                'hash': hashlib.sha256(circuit.encode()).hexdigest()
            },
            'parameters': metadata,
            'result': {
                'counts': result.counts,
                'execution_time': result.execution_time,
                'backend': result.backend,
                'job_id': result.job_id
            },
            'provenance': {
                'timestamp': datetime.now().isoformat(),
                'platform': 'QCOS',
                'version': '1.0.0'
            }
        }
        
        self.experiments.append(experiment_record)
        return experiment_record['id']
    
    def export_datacite(self) -> dict:
        """
        Export DataCite-compatible metadata.
        """
        return {
            '@context': 'http://schema.org/',
            '@type': 'Dataset',
            'identifier': self.dataset_id,
            'name': self.title,
            'creator': [{'name': c} for c in self.creators],
            'dateCreated': self.created,
            'description': f'Quantum computing experiments ({len(self.experiments)} circuits)',
            'license': 'CC-BY-4.0',
            'keywords': ['quantum computing', 'simulation', 'QCOS'],
            'distribution': {
                '@type': 'DataDownload',
                'encodingFormat': 'application/json',
                'contentUrl': f'https://api.softquantus.com/datasets/{self.dataset_id}'
            }
        }
    
    def export_ro_crate(self) -> dict:
        """
        Export RO-Crate research object.
        """
        return {
            '@context': 'https://w3id.org/ro/crate/1.1/context',
            '@graph': [
                {
                    '@type': 'CreativeWork',
                    '@id': 'ro-crate-metadata.json',
                    'about': {'@id': './'}
                },
                {
                    '@id': './',
                    '@type': 'Dataset',
                    'name': self.title,
                    'hasPart': [
                        {'@id': f'experiment_{i}.json'} 
                        for i in range(len(self.experiments))
                    ]
                }
            ]
        }
    
    def save(self, directory: str):
        """
        Save complete dataset.
        """
        import os
        os.makedirs(directory, exist_ok=True)
        
        # Save experiments
        for i, exp in enumerate(self.experiments):
            with open(f'{directory}/experiment_{i}.json', 'w') as f:
                json.dump(exp, f, indent=2)
        
        # Save metadata
        with open(f'{directory}/datacite.json', 'w') as f:
            json.dump(self.export_datacite(), f, indent=2)
        
        with open(f'{directory}/ro-crate-metadata.json', 'w') as f:
            json.dump(self.export_ro_crate(), f, indent=2)

# Create dataset for national project
dataset = FAIRQuantumDataset(
    dataset_id='10.5281/zenodo.12345678',
    title='German Quantum Computing Benchmark Suite 2024',
    creators=['DLR Institute for Software Technology', 'Fraunhofer IAF']
)

# Add experiments
circuits = [
    ('Bell State', """OPENQASM 2.0; include "qelib1.inc"; qreg q[2]; creg c[2]; h q[0]; cx q[0],q[1]; measure q -> c;"""),
    ('GHZ-5', """OPENQASM 2.0; include "qelib1.inc"; qreg q[5]; creg c[5]; h q[0]; cx q[0],q[1]; cx q[1],q[2]; cx q[2],q[3]; cx q[3],q[4]; measure q -> c;"""),
]

for name, circuit in circuits:
    exp_id = dataset.add_experiment(circuit, {'name': name, 'shots': 2048})
    print(f"Added: {exp_id}")

# Export FAIR-compliant dataset
dataset.save('./quantum_dataset_2024')
print("\n✓ FAIR-compliant dataset exported")

Compliance & Governance

Data Sovereignty

All QCOS computations run on LUMI supercomputer in Finland:

🇪🇺 EU jurisdiction - GDPR compliant
🔐 Data residency - No data leaves EU
📋 Audit logging - Full traceability

Security Certifications

ISO 27001 (in progress)
SOC 2 Type II (in progress)
EuroQCI compatible

Open Source Components

QCOS uses open-source tools:

Component	License
Qiskit	Apache 2.0
cuStateVec	BSD 3-Clause
OpenQASM	Apache 2.0
FastAPI	MIT

Integration with National Infrastructure

EOSC (European Open Science Cloud)

# eosc-descriptor.yaml
services:
  - name: QCOS
    type: quantum-computing
    provider: SoftQuantus
    access:
      url: https://api.softquantus.com
      authentication: API-Key
    compliance:
      - EOSC-Rules
      - FAIR-Data
      - GDPR

GÉANT eduroam

Institutional users can authenticate via their university credentials.

Funding Acknowledgment

QCOS development is partially supported by:

EuroHPC Joint Undertaking (LUMI access)
EU Horizon Europe (pending)

Contact

For national program partnerships:

📧 government@softquantus.com

We offer:

Dedicated infrastructure
Custom SLAs
On-site training
Joint grant applications

Why QCOS for National Programs?​

Supported National Programs​

Use Case: National Quantum Testbed​

Multi-Institution Research Platform​

Use Case: Quantum Education Platform​

National Quantum Curriculum Support​

Use Case: National Research Data Infrastructure​

FAIR Data Principles for Quantum Research​

Compliance & Governance​

Data Sovereignty​

Security Certifications​

Open Source Components​

Integration with National Infrastructure​

EOSC (European Open Science Cloud)​

GÉANT eduroam​

Funding Acknowledgment​

Contact​