Skip to content

Order Inference

OrderInference selects modes based on quality factor (or frequency), then assigns labels in frequency order.

Usage

To use an inference, call the .infer() method with eigenmode results:

from quansys.simulation.quantum_epr.modes_to_labels import OrderInference

# Example eigenmode data
eigenmode_results = {
    1: {'frequency': 3.5, 'quality_factor': 100},
    2: {'frequency': 5.1, 'quality_factor': 120}, 
    3: {'frequency': 5.8, 'quality_factor': 90},
    4: {'frequency': 6.0, 'quality_factor': 150}
}

# Select 2 lowest quality factor modes (readout/purcell)
inference = OrderInference(
    num=2,
    min_or_max='min',                          # Pick lowest Q modes
    quantity='quality_factor',
    ordered_labels_by_frequency=['readout', 'purcell']  # Lower freq → readout
)

result = inference.infer(eigenmode_results)
print(result)  # Output: {1: 'readout', 3: 'purcell'}
# Modes 3 and 1 have lowest Q (90, 100)  
# Assigning labels by frequency order:
# Mode 1 (freq 3.5) gets 'readout', Mode 3 (freq 5.8) gets 'purcell'

Bases: InferenceBase

Inference strategy based on sorting modes by a specified property and assigning labels by order.

Attributes:

Name Type Description
type Literal['order']

Discriminator field with value 'order'.
num int

Number of modes to assign labels to.
min_or_max Literal['min', 'max']

Whether to choose modes with minimum or maximum values.
ordered_labels_by_frequency list[str]

List of labels to assign in the determined order.
quantity Literal['frequency', 'quality_factor']

The property to use for sorting modes.

infer 

infer(
    eigenmode_results: dict[int, dict[str, float]],
) -> dict[int, str]

Selects and labels a number of modes by sorting them based on a specified property.

Modes are ranked based on the quantity field (e.g., frequency or quality factor), either ascending (min) or descending (max), and labeled in the order specified by ordered_labels_by_frequency.

Parameters:

Name Type Description Default
eigenmode_results dict[int, dict[str, float]]

Dictionary of modes and their corresponding frequency or quality factor.

 required

Returns:

Type Description
dict[int, str]

dict[int, str]: Mapping from selected mode numbers to labels.

Raises:

Type Description
ValueError

If ordered_labels_by_frequency length does not match num.
Source code in src/quansys/simulation/quantum_epr/modes_to_labels/inferences.py 
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
def infer(self, eigenmode_results: dict[int, dict[str, float]]) -> dict[int, str]:
    """
    Selects and labels a number of modes by sorting them based on a specified property.

    Modes are ranked based on the `quantity` field (e.g., frequency or quality factor),
    either ascending (`min`) or descending (`max`), and labeled in the order specified
    by `ordered_labels_by_frequency`.

    Args:
        eigenmode_results (dict[int, dict[str, float]]):
            Dictionary of modes and their corresponding frequency or quality factor.

    Returns:
        dict[int, str]: Mapping from selected mode numbers to labels.

    Raises:
        ValueError: If `ordered_labels_by_frequency` length does not match `num`.
    """
    # Extract the desired quantity from mode_to_freq_and_q_factor
    mode_and_quantity = [(k, v[self.quantity]) for k, v in eigenmode_results.items()]

    # sort
    reverse = self.min_or_max == 'max'
    sorted_mode_and_quantity = sorted(mode_and_quantity, reverse=reverse, key=lambda x: x[1])[: self.num]
    modes = list(map(lambda x: x[0], sorted_mode_and_quantity))

    # modes by ordered labels
    return {m: self.ordered_labels_by_frequency[i] for i, m in enumerate(sorted(modes))}