qsci_vm_analysis

QURI VM integration for QSCI algorithms.

This module provides circuit analysis capabilities at both LogicalCircuit and ArchLogicalCircuit levels using QURI VM, enabling detailed resource estimation for QSCI algorithms on different quantum architectures.

Classes:

Name	Description
ArchitectureInfo	Information about quantum architecture.
CircuitResourceEstimate	Resource estimates for quantum circuit execution.
VMCircuitAnalyzer	Circuit analyzer using QURI VM capabilities.
QSCIVMAnalysis	Enhanced QSCI analysis using QURI VM capabilities.
VMEnabledQSCIAlgorithm	QSCI algorithm with QURI VM analysis capabilities.
VMSampler	VM-based sampler implementing quri-parts ConcurrentSampler interface.
VMFactory	Factory for creating pre-configured QURI VM instances.
QURIVMInterface	Interface to QURI VM for TE-QSCI analysis and sampling.

Functions:

Name	Description
create_vm_enabled_algorithm	Create VM-enabled QSCI algorithm with specified architecture.
demonstrate_star_architecture_analysis	Demonstrate QSCI analysis with STAR architecture.
create_star_vm_for_h6	Create STAR architecture VM interface optimized for H6 TE-QSCI.

Attributes:

Name	Type	Description
QURI_VM_AVAILABLE

QURI_VM_AVAILABLE module-attribute

QURI_VM_AVAILABLE = True

ArchitectureInfo dataclass

ArchitectureInfo(
    name,
    num_physical_qubits,
    connectivity,
    gate_fidelities,
    decoherence_times,
    gate_times,
)

Information about quantum architecture.

Attributes:

Name	Type	Description
name	str
num_physical_qubits	int
connectivity	str
gate_fidelities	Dict[str, float]
decoherence_times	Dict[str, float]
gate_times	Dict[str, float]

name instance-attribute

name

num_physical_qubits instance-attribute

num_physical_qubits

connectivity instance-attribute

connectivity

gate_fidelities instance-attribute

gate_fidelities

decoherence_times instance-attribute

decoherence_times

gate_times instance-attribute

gate_times

CircuitResourceEstimate dataclass

CircuitResourceEstimate(
    gate_count,
    circuit_depth,
    physical_qubit_count,
    logical_qubit_count,
    execution_time,
    fidelity_estimate,
    swap_overhead=0,
)

Resource estimates for quantum circuit execution.

Attributes:

Name	Type	Description
gate_count	Dict[str, int]
circuit_depth	int
physical_qubit_count	int
logical_qubit_count	int
execution_time	TimeValue
fidelity_estimate	float
swap_overhead	int

gate_count instance-attribute

gate_count

circuit_depth instance-attribute

circuit_depth

physical_qubit_count instance-attribute

physical_qubit_count

logical_qubit_count instance-attribute

logical_qubit_count

execution_time instance-attribute

execution_time

fidelity_estimate instance-attribute

fidelity_estimate

swap_overhead class-attribute instance-attribute

swap_overhead = 0

VMCircuitAnalyzer

VMCircuitAnalyzer(architecture=None)

Circuit analyzer using QURI VM capabilities.

Parameters:

Name	Type	Description	Default
architecture	Optional[ArchitectureInfo]	Quantum architecture information	None

Methods:

Name	Description
analyze_logical_circuit	Analyze circuit at LogicalCircuit level.
analyze_arch_logical_circuit	Analyze circuit at ArchLogicalCircuit level with architecture mapping.

Attributes:

Name	Type	Description
architecture

Source code in src/qsci_vm_analysis.py

def __init__(self, architecture: Optional[ArchitectureInfo] = None):
    """Initialize VM circuit analyzer.

    Args:
        architecture: Quantum architecture information
    """
    self.architecture = architecture or self._get_default_star_architecture()

architecture instance-attribute

architecture = (
    architecture or _get_default_star_architecture()
)

analyze_logical_circuit

analyze_logical_circuit(circuit)

Analyze circuit at LogicalCircuit level.

Parameters:

Name	Type	Description	Default
circuit	NonParametricQuantumCircuit	Quantum circuit to analyze	required

Returns:

Type	Description
CircuitResourceEstimate	CircuitResourceEstimate with logical-level analysis

Source code in src/qsci_vm_analysis.py

def analyze_logical_circuit(
    self, 
    circuit: NonParametricQuantumCircuit
) -> CircuitResourceEstimate:
    """Analyze circuit at LogicalCircuit level.

    Args:
        circuit: Quantum circuit to analyze

    Returns:
        CircuitResourceEstimate with logical-level analysis
    """
    # Logical circuit analysis - no architecture-specific optimizations
    gate_count = self._count_gates(circuit)
    circuit_depth = circuit.depth
    logical_qubit_count = circuit.qubit_count

    # Estimate execution time based on gate counts and types
    execution_time_us = sum(
        count * self._get_gate_time(gate_type)
        for gate_type, count in gate_count.items()
    )

    # Estimate fidelity based on gate fidelities
    fidelity_estimate = self._estimate_circuit_fidelity(gate_count)

    return CircuitResourceEstimate(
        gate_count=gate_count,
        circuit_depth=circuit_depth,
        physical_qubit_count=logical_qubit_count,  # Same at logical level
        logical_qubit_count=logical_qubit_count,
        execution_time=TimeValue(execution_time_us, TimeUnit.MICROSECOND),
        fidelity_estimate=fidelity_estimate
    )

analyze_arch_logical_circuit

analyze_arch_logical_circuit(circuit)

Analyze circuit at ArchLogicalCircuit level with architecture mapping.

Parameters:

Name	Type	Description	Default
circuit	NonParametricQuantumCircuit	Quantum circuit to analyze	required

Returns:

Type	Description
CircuitResourceEstimate	CircuitResourceEstimate with architecture-aware analysis

Source code in src/qsci_vm_analysis.py

def analyze_arch_logical_circuit(
    self, 
    circuit: NonParametricQuantumCircuit
) -> CircuitResourceEstimate:
    """Analyze circuit at ArchLogicalCircuit level with architecture mapping.

    Args:
        circuit: Quantum circuit to analyze

    Returns:
        CircuitResourceEstimate with architecture-aware analysis
    """
    # Start with logical analysis
    logical_estimate = self.analyze_logical_circuit(circuit)

    # Apply architecture-specific optimizations and overhead
    if self.architecture.connectivity == "star":
        arch_estimate = self._analyze_star_architecture(circuit, logical_estimate)
    else:
        # For other architectures, use logical estimate with connectivity overhead
        arch_estimate = self._apply_connectivity_overhead(logical_estimate)

    return arch_estimate

QSCIVMAnalysis

QSCIVMAnalysis(
    lowering_level,
    circuit_estimates,
    total_shots,
    architecture=None,
)

Bases: QSCIAnalysis

Enhanced QSCI analysis using QURI VM capabilities.

Parameters:

Name	Type	Description	Default
lowering_level	LoweringLevel	Analysis level	required
circuit_estimates	Dict[str, CircuitResourceEstimate]	Resource estimates for circuits	required
total_shots	int	Total measurement shots	required
architecture	Optional[ArchitectureInfo]	Architecture information	None

Attributes:

Name	Type	Description
circuit_estimates
architecture
total_shots
circuit_gate_count
circuit_depth
circuit_latency
circuit_execution_count
circuit_fidelities
circuit_qubit_count
total_latency	TimeValue	Total latency including all circuit executions.
max_physical_qubit_count	int	Maximum physical qubit count across all circuits.
total_swap_overhead	int	Total SWAP gate overhead across all circuits.
average_fidelity	float	Average fidelity across all circuits.

Source code in src/qsci_vm_analysis.py

def __init__(
    self,
    lowering_level: LoweringLevel,
    circuit_estimates: Dict[str, CircuitResourceEstimate],
    total_shots: int,
    architecture: Optional[ArchitectureInfo] = None
):
    """Initialize VM-enhanced QSCI analysis.

    Args:
        lowering_level: Analysis level
        circuit_estimates: Resource estimates for circuits
        total_shots: Total measurement shots
        architecture: Architecture information
    """
    self.circuit_estimates = circuit_estimates
    self.architecture = architecture
    self.total_shots = total_shots

    # Convert circuit estimates to base class format
    circuit_gate_count = {
        name: est.gate_count for name, est in circuit_estimates.items()
    }
    circuit_depth = {
        name: est.circuit_depth for name, est in circuit_estimates.items()
    }
    circuit_latency = {
        name: est.execution_time for name, est in circuit_estimates.items()
    }
    circuit_execution_count = {"total": total_shots}
    circuit_fidelities = {
        name: est.fidelity_estimate for name, est in circuit_estimates.items()
    }
    circuit_qubit_count = {
        name: est.physical_qubit_count for name, est in circuit_estimates.items()
    }

    # Create dummy QSCI result for base class
    from .qsci_algorithms import QSCIResult, QSCIVariant
    dummy_qsci_result = QSCIResult(
        eigenvalues=[0.0],
        eigenstates=[],
        selected_states=[],
        subspace_dimension=100,
        total_shots=total_shots,
        algorithm_variant=QSCIVariant.VANILLA
    )

    super().__init__(lowering_level, dummy_qsci_result)

    # Override with VM analysis
    self.circuit_gate_count = circuit_gate_count
    self.circuit_depth = circuit_depth
    self.circuit_latency = circuit_latency
    self.circuit_execution_count = circuit_execution_count
    self.circuit_fidelities = circuit_fidelities
    self.circuit_qubit_count = circuit_qubit_count

circuit_estimates instance-attribute

circuit_estimates = circuit_estimates

architecture instance-attribute

architecture = architecture

total_shots instance-attribute

total_shots = total_shots

circuit_gate_count instance-attribute

circuit_gate_count = circuit_gate_count

circuit_depth instance-attribute

circuit_depth = circuit_depth

circuit_latency instance-attribute

circuit_latency = circuit_latency

circuit_execution_count instance-attribute

circuit_execution_count = circuit_execution_count

circuit_fidelities instance-attribute

circuit_fidelities = circuit_fidelities

circuit_qubit_count instance-attribute

circuit_qubit_count = circuit_qubit_count

total_latency property

total_latency

Total latency including all circuit executions.

max_physical_qubit_count property

max_physical_qubit_count

Maximum physical qubit count across all circuits.

total_swap_overhead property

total_swap_overhead

Total SWAP gate overhead across all circuits.

average_fidelity property

average_fidelity

Average fidelity across all circuits.

VMEnabledQSCIAlgorithm

VMEnabledQSCIAlgorithm(base_algorithm, architecture=None)

Bases: QSCIAlgorithmBase

QSCI algorithm with QURI VM analysis capabilities.

Parameters:

Name	Type	Description	Default
base_algorithm	QSCIAlgorithmBase	Base QSCI algorithm	required
architecture	Optional[ArchitectureInfo]	Quantum architecture for analysis	None

Methods:

Name	Description
run	Run the base algorithm.
analyze	Perform VM-enhanced analysis of QSCI algorithm.

Attributes:

Name	Type	Description
base_algorithm
vm_analyzer
name	str

Source code in src/qsci_vm_analysis.py

def __init__(
    self,
    base_algorithm: QSCIAlgorithmBase,
    architecture: Optional[ArchitectureInfo] = None
):
    """Initialize VM-enabled QSCI algorithm.

    Args:
        base_algorithm: Base QSCI algorithm
        architecture: Quantum architecture for analysis
    """
    # Copy properties from base algorithm
    super().__init__(
        base_algorithm.hamiltonian,
        base_algorithm.sampler,
        base_algorithm.num_states_pick_out
    )
    self.base_algorithm = base_algorithm
    self.vm_analyzer = VMCircuitAnalyzer(architecture)

base_algorithm instance-attribute

base_algorithm = base_algorithm

vm_analyzer instance-attribute

vm_analyzer = VMCircuitAnalyzer(architecture)

name property

name

run

run(*args, **kwargs)

Run the base algorithm.

Source code in src/qsci_vm_analysis.py

def run(self, *args, **kwargs):
    """Run the base algorithm."""
    return self.base_algorithm.run(*args, **kwargs)

analyze

analyze(
    input_states,
    total_shots,
    lowering_level=LogicalCircuit,
    **kwargs
)

Perform VM-enhanced analysis of QSCI algorithm.

Source code in src/qsci_vm_analysis.py

def analyze(
    self,
    input_states: Sequence[CircuitQuantumState],
    total_shots: int,
    lowering_level: LoweringLevel = LoweringLevel.LogicalCircuit,
    **kwargs
) -> QSCIVMAnalysis:
    """Perform VM-enhanced analysis of QSCI algorithm."""
    circuit_estimates = {}

    for i, state in enumerate(input_states):
        circuit_name = f"input_circuit_{i}"

        if lowering_level == LoweringLevel.LogicalCircuit:
            estimate = self.vm_analyzer.analyze_logical_circuit(state.circuit)
        elif lowering_level == LoweringLevel.ArchLogicalCircuit:
            estimate = self.vm_analyzer.analyze_arch_logical_circuit(state.circuit)
        else:
            # For higher levels, use ArchLogicalCircuit analysis
            estimate = self.vm_analyzer.analyze_arch_logical_circuit(state.circuit)

        circuit_estimates[circuit_name] = estimate

    return QSCIVMAnalysis(
        lowering_level,
        circuit_estimates,
        total_shots,
        self.vm_analyzer.architecture
    )

VMSampler

VMSampler(vm_instance)

VM-based sampler implementing quri-parts ConcurrentSampler interface.

Parameters:

Name	Type	Description	Default
vm_instance		Pre-configured QURI VM instance	required

Attributes:

Name	Type	Description
vm

Source code in src/qsci_vm_analysis.py

def __init__(self, vm_instance):
    """Initialize VM sampler.

    Args:
        vm_instance: Pre-configured QURI VM instance
    """
    self.vm = vm_instance

vm instance-attribute

vm = vm_instance

VMFactory

Factory for creating pre-configured QURI VM instances.

Methods:

Name	Description
create_ideal_vm	Create ideal VM for LogicalCircuit level sampling.
create_star_vm	Create STAR architecture VM with specified error rate.
create_star_vm_for_h6	Create STAR VM optimized for H6 TE-QSCI calculations.

create_ideal_vm staticmethod

create_ideal_vm()

Create ideal VM for LogicalCircuit level sampling.

Returns:

Type	Description
VM	VM instance configured for ideal quantum computation

Source code in src/qsci_vm_analysis.py

@staticmethod
def create_ideal_vm() -> 'VM':
    """Create ideal VM for LogicalCircuit level sampling.

    Returns:
        VM instance configured for ideal quantum computation
    """
    # Create abstract ideal VM (no device-specific constraints) 
    # Following tutorial: VM() creates abstract VM
    return VM()

create_star_vm staticmethod

create_star_vm(error_rate=0.0)

Create STAR architecture VM with specified error rate.

Parameters:

Name	Type	Description	Default
error_rate	float	Physical error rate (0.0 to 1.0)	0.0

Returns:

Type	Description
VM	VM instance configured with STAR device properties for given error rate

Source code in src/qsci_vm_analysis.py

@staticmethod
def create_star_vm(error_rate: float = 0.0) -> 'VM':
    """Create STAR architecture VM with specified error rate.

    Args:
        error_rate: Physical error rate (0.0 to 1.0)

    Returns:
        VM instance configured with STAR device properties for given error rate
    """
    # Following tutorial: Create STAR VM with specific physical error rate
    # QEC cycle time (1.0 microsecond is standard)
    qec_cycle = TimeValue(value=1.0, unit=TimeUnit.MICROSECOND)

    # Generate STAR device property with physical error rate
    # Following tutorial pattern for error rate configuration
    device_property = star_device.generate_device_property(
        qubit_count=16,  # Sufficient for H6 (12 qubits) + overhead
        code_distance=7,  # Standard distance for fault tolerance
        qec_cycle=qec_cycle,
        physical_error_rate=error_rate  # This is the key parameter from tutorial
    )

    return VM.from_device_prop(device_property)

create_star_vm_for_h6 staticmethod

create_star_vm_for_h6(error_rate=0.0)

Create STAR VM optimized for H6 TE-QSCI calculations.

Parameters:

Name	Type	Description	Default
error_rate	float	Physical error rate for STAR architecture	0.0

Returns:

Type	Description
VM	VM instance optimized for H6 molecular calculations

Source code in src/qsci_vm_analysis.py

@staticmethod
def create_star_vm_for_h6(error_rate: float = 0.0) -> 'VM':
    """Create STAR VM optimized for H6 TE-QSCI calculations.

    Args:
        error_rate: Physical error rate for STAR architecture

    Returns:
        VM instance optimized for H6 molecular calculations
    """
    return VMFactory.create_star_vm(error_rate)

QURIVMInterface

QURIVMInterface(logical_vm=None, arch_vm=None)

Interface to QURI VM for TE-QSCI analysis and sampling.

Parameters:

Name	Type	Description	Default
logical_vm		Pre-configured VM for LogicalCircuit level (ideal)	None
arch_vm		Pre-configured VM for ArchLogicalCircuit level (with architecture)	None

Methods:

Name	Description
analyze_circuit_at_level	Analyze circuit at specified lowering level.
create_logical_sampler	Create sampler for LogicalCircuit level (ideal VM).
create_arch_sampler	Create sampler for ArchLogicalCircuit level (STAR architecture).
create_sampler	Create sampler for specified level.

Attributes:

Name	Type	Description
logical_vm
arch_vm

Source code in src/qsci_vm_analysis.py

def __init__(self, logical_vm=None, arch_vm=None):
    """Initialize QURI VM interface with pre-configured VM instances.

    Args:
        logical_vm: Pre-configured VM for LogicalCircuit level (ideal)
        arch_vm: Pre-configured VM for ArchLogicalCircuit level (with architecture)
    """
    if logical_vm is None:
        logical_vm = VMFactory.create_ideal_vm()
    if arch_vm is None:
        arch_vm = VMFactory.create_star_vm(0.0)  # Default to no error

    self.logical_vm = logical_vm
    self.arch_vm = arch_vm

logical_vm instance-attribute

logical_vm = logical_vm

arch_vm instance-attribute

arch_vm = arch_vm

analyze_circuit_at_level

analyze_circuit_at_level(circuit, level)

Analyze circuit at specified lowering level.

Parameters:

Name	Type	Description	Default
circuit	NonParametricQuantumCircuit	Circuit to analyze	required
level	LoweringLevel	Analysis level (LogicalCircuit or ArchLogicalCircuit)	required

Returns:

Type	Description
Dict[str, Any]	Analysis results dictionary

Source code in src/qsci_vm_analysis.py

def analyze_circuit_at_level(
    self,
    circuit: NonParametricQuantumCircuit,
    level: LoweringLevel
) -> Dict[str, Any]:
    """Analyze circuit at specified lowering level.

    Args:
        circuit: Circuit to analyze
        level: Analysis level (LogicalCircuit or ArchLogicalCircuit)

    Returns:
        Analysis results dictionary
    """
    if level == LoweringLevel.LogicalCircuit:
        return self._analyze_logical_level(circuit)
    elif level == LoweringLevel.ArchLogicalCircuit:
        return self._analyze_arch_level(circuit)
    else:
        # For higher levels, default to arch analysis
        return self._analyze_arch_level(circuit)

create_logical_sampler

create_logical_sampler()

Create sampler for LogicalCircuit level (ideal VM).

Returns:

Type	Description
	VMSampler instance for ideal quantum sampling

Source code in src/qsci_vm_analysis.py

def create_logical_sampler(self):
    """Create sampler for LogicalCircuit level (ideal VM).

    Returns:
        VMSampler instance for ideal quantum sampling
    """
    return VMSampler(self.logical_vm)

create_arch_sampler

create_arch_sampler()

Create sampler for ArchLogicalCircuit level (STAR architecture).

Returns:

Type	Description
	VMSampler instance for STAR architecture sampling

Source code in src/qsci_vm_analysis.py

def create_arch_sampler(self):
    """Create sampler for ArchLogicalCircuit level (STAR architecture).

    Returns:
        VMSampler instance for STAR architecture sampling
    """
    return VMSampler(self.arch_vm)

create_sampler

create_sampler(level)

Create sampler for specified level.

Parameters:

Name	Type	Description	Default
level	LoweringLevel	LoweringLevel for sampling (LogicalCircuit or ArchLogicalCircuit)	required

Returns:

Type	Description
	VMSampler instance for the specified level

Source code in src/qsci_vm_analysis.py

def create_sampler(self, level: LoweringLevel):
    """Create sampler for specified level.

    Args:
        level: LoweringLevel for sampling (LogicalCircuit or ArchLogicalCircuit)

    Returns:
        VMSampler instance for the specified level
    """
    if level == LoweringLevel.LogicalCircuit:
        return self.create_logical_sampler()
    elif level == LoweringLevel.ArchLogicalCircuit:
        return self.create_arch_sampler()
    else:
        # Default to arch level for higher levels
        return self.create_arch_sampler()

create_vm_enabled_algorithm

create_vm_enabled_algorithm(
    base_algorithm, architecture_name="STAR"
)

Create VM-enabled QSCI algorithm with specified architecture.

Parameters:

Name	Type	Description	Default
base_algorithm	QSCIAlgorithmBase	Base QSCI algorithm	required
architecture_name	str	Name of quantum architecture ("STAR", etc.)	'STAR'

Returns:

Type	Description
VMEnabledQSCIAlgorithm	VM-enabled QSCI algorithm

Source code in src/qsci_vm_analysis.py

def create_vm_enabled_algorithm(
    base_algorithm: QSCIAlgorithmBase,
    architecture_name: str = "STAR"
) -> VMEnabledQSCIAlgorithm:
    """Create VM-enabled QSCI algorithm with specified architecture.

    Args:
        base_algorithm: Base QSCI algorithm
        architecture_name: Name of quantum architecture ("STAR", etc.)

    Returns:
        VM-enabled QSCI algorithm
    """
    if architecture_name.upper() == "STAR":
        analyzer = VMCircuitAnalyzer()  # Uses STAR by default
    else:
        # For other architectures, create custom ArchitectureInfo
        architecture = ArchitectureInfo(
            name=architecture_name,
            num_physical_qubits=100,
            connectivity="custom",
            gate_fidelities={"single": 0.999, "two_qubit": 0.99, "measurement": 0.95},
            decoherence_times={"T1": 100.0, "T2": 50.0},
            gate_times={"single": 0.1, "two_qubit": 0.5, "measurement": 1.0}
        )
        analyzer = VMCircuitAnalyzer(architecture)

    return VMEnabledQSCIAlgorithm(base_algorithm, analyzer.architecture)

demonstrate_star_architecture_analysis

demonstrate_star_architecture_analysis()

Demonstrate QSCI analysis with STAR architecture.

Source code in src/qsci_vm_analysis.py

def demonstrate_star_architecture_analysis():
    """Demonstrate QSCI analysis with STAR architecture."""
    from .qsci_algo_interface import create_qsci_algorithm, QSCIVariant
    from quri_parts.core.operator import pauli_label

    # Create example Hamiltonian (H2 molecule)
    hamiltonian = pauli_label("Z0 Z1") + 0.5 * pauli_label("X0 X1")

    # Create TE-QSCI algorithm
    base_algorithm = create_qsci_algorithm(
        QSCIVariant.SINGLE_TIME_TE,
        hamiltonian,
        evolution_time=1.0
    )

    # Enable VM analysis
    vm_algorithm = create_vm_enabled_algorithm(base_algorithm, "STAR")

    # Create example input state (would be Hartree-Fock in practice)
    from quri_parts.circuit import QuantumCircuit
    from quri_parts.core.state import CircuitQuantumState

    circuit = QuantumCircuit(2)
    circuit.add_X_gate(0)  # Simple example state
    input_state = CircuitQuantumState(2, circuit)

    # Analyze at different levels
    logical_analysis = vm_algorithm.analyze(
        [input_state], 1000, LoweringLevel.LogicalCircuit
    )

    arch_analysis = vm_algorithm.analyze(
        [input_state], 1000, LoweringLevel.ArchLogicalCircuit
    )

    print(f"Logical circuit analysis:")
    print(f"  Total latency: {logical_analysis.total_latency}")
    print(f"  Max qubits: {logical_analysis.max_physical_qubit_count}")

    print(f"ArchLogical circuit analysis:")
    print(f"  Total latency: {arch_analysis.total_latency}")
    print(f"  Max qubits: {arch_analysis.max_physical_qubit_count}")
    print(f"  SWAP overhead: {arch_analysis.total_swap_overhead}")
    print(f"  Average fidelity: {arch_analysis.average_fidelity:.4f}")

create_star_vm_for_h6

create_star_vm_for_h6(error_rate=0.0)

Create STAR architecture VM interface optimized for H6 TE-QSCI.

Parameters:

Name	Type	Description	Default
error_rate	float	Physical error rate for STAR architecture (0.0 for ideal)	0.0

Source code in src/qsci_vm_analysis.py

def create_star_vm_for_h6(error_rate: float = 0.0) -> QURIVMInterface:
    """Create STAR architecture VM interface optimized for H6 TE-QSCI.

    Args:
        error_rate: Physical error rate for STAR architecture (0.0 for ideal)
    """
    logical_vm = VMFactory.create_ideal_vm()
    arch_vm = VMFactory.create_star_vm_for_h6(error_rate)
    return QURIVMInterface(logical_vm=logical_vm, arch_vm=arch_vm)