Error Mitigation API Reference

HLQuantum includes a pluggable error-mitigation pipeline. Each technique is a subclass of MitigationMethod and can be composed together via apply_mitigation().

Built-in Methods

Class	Strategy
ThresholdMitigation	Discards bitstrings whose probability falls below a configurable threshold, treating them as noise.
ReadoutMitigation	Placeholder for readout-error correction (extensible).

Usage

import hlquantum as hlq
from hlquantum.mitigation import ThresholdMitigation, apply_mitigation

# Apply during execution
result = hlq.run(circuit, mitigation=ThresholdMitigation(threshold=0.01))

# Or apply after the fact
raw = hlq.run(circuit)
clean = apply_mitigation(raw, [ThresholdMitigation(threshold=0.01)])

Writing a Custom Mitigation Method

Subclass MitigationMethod and implement the apply(result) method:

from hlquantum.mitigation import MitigationMethod

class MyMitigation(MitigationMethod):
    def apply(self, result):
        # Return a new or modified ExecutionResult
        ...

---

Error mitigation hooks and post-processing.

MitigationMethod

Bases: ABC

Base class for error mitigation techniques.

Source code in hlquantum/mitigation.py

class MitigationMethod(ABC):
    """Base class for error mitigation techniques."""

    @abstractmethod
    def apply(self, result: ExecutionResult) -> ExecutionResult:
        """Apply mitigation to the result."""
        ...

apply(result) abstractmethod

Apply mitigation to the result.

Source code in hlquantum/mitigation.py

@abstractmethod
def apply(self, result: ExecutionResult) -> ExecutionResult:
    """Apply mitigation to the result."""
    ...

ReadoutMitigation

Bases: MitigationMethod

Readout Error Mitigation placeholder.

Source code in hlquantum/mitigation.py

class ReadoutMitigation(MitigationMethod):
    """Readout Error Mitigation placeholder."""

    def apply(self, result: ExecutionResult) -> ExecutionResult:
        return result

ThresholdMitigation

Bases: MitigationMethod

Filters low-probability bitstrings.

Source code in hlquantum/mitigation.py

class ThresholdMitigation(MitigationMethod):
    """Filters low-probability bitstrings."""

    def __init__(self, threshold: float = 0.005) -> None:
        self.threshold = threshold

    def apply(self, result: ExecutionResult) -> ExecutionResult:
        if not result.counts:
            return result

        from hlquantum.result import ExecutionResult as ER
        total_shots = result.shots
        new_counts = {
            k: v for k, v in result.counts.items() 
            if (v / total_shots) >= self.threshold
        }

        return ER(
            counts=new_counts,
            shots=result.shots,
            backend_name=result.backend_name,
            raw=result.raw,
            state_vector=result.state_vector,
            metadata=result.metadata,
        )

apply_mitigation(result, methods=None)

Apply a sequence of mitigation methods.

Source code in hlquantum/mitigation.py

def apply_mitigation(
    result: ExecutionResult, 
    methods: Optional[List[MitigationMethod]] = None
) -> ExecutionResult:
    """Apply a sequence of mitigation methods."""
    if not methods:
        return result
    for method in methods:
        result = method.apply(result)
    return result