def __call__(self, params: Sequence[float] | np.ndarray) -> float:
"""Return the cost value given the input parameters."""
if not is_sequence(params):
raise TypeError(
'Expected sequence for params, got %s.' % type(params), )
if not all(is_real_number(param) for param in params):
raise TypeError('Expected sequence of floats for params.', )
return self.get_cost(params)
def __init__(
self,
heuristic_factor: float = 10.0,
cost_factor: float = 1.0,
cost_gen: CostFunctionGenerator = HilbertSchmidtCostGenerator(),
) -> None:
"""
Construct a AStarHeuristic Function.
Args:
heuristic_factor (float): Scale the heuristic component by
this value.
cost_factor (float): Scale the cost component by this value.
cost_gen (CostFunctionGenerator): This is used to generate
cost functions used during evaluations.
"""
if not is_real_number(heuristic_factor):
raise TypeError(
'Expected float for heuristic_factor, got %s.' %
type(heuristic_factor), )
if not is_real_number(cost_factor):
raise TypeError(
'Expected float for cost_factor, got %s.' %
type(cost_factor), )
if not isinstance(cost_gen, CostFunctionGenerator):
raise TypeError(
'Expected CostFunctionGenerator for cost_gen, got %s.' %
type(cost_gen), )
self.heuristic_factor = heuristic_factor
self.cost_factor = cost_factor
self.cost_gen = cost_gen
def __call__( # type: ignore
self,
params: Sequence[float] | np.ndarray,
) -> np.ndarray:
"""Return the vector of residuals given the input parameters."""
if not is_sequence(params):
raise TypeError(
'Expected sequence for params, got %s.' % type(params),
)
if not all(is_real_number(param) for param in params):
raise TypeError(
'Expected sequence of floats for params.',
)
return self.get_residuals(params)
def __init__(
self,
heuristic_function: HeuristicFunction = AStarHeuristic(),
layer_generator: LayerGenerator = SimpleLayerGenerator(),
success_threshold: float = 1e-10,
cost: CostFunctionGenerator = HilbertSchmidtResidualsGenerator(),
max_layer: int | None = None,
min_prefix_size: int = 3,
instantiate_options: dict[str, Any] = {},
**kwargs: Any,
) -> None:
"""
Construct a search-based synthesis pass.
Args:
heuristic_function (HeuristicFunction): The heuristic to guide
search.
layer_generator (LayerGenerator): The successor function
to guide node expansion.
success_threshold (float): The distance threshold that
determines successful termintation. Measured in cost
described by the cost function. (Default: 1e-10)
cost (CostFunction | None): The cost function that determines
distance during synthesis. The goal of this synthesis pass
is to implement circuits for the given unitaries that have
a cost less than the `success_threshold`.
(Default: HSDistance())
max_layer (int): The maximum number of layers to append without
success before termination. If left as None it will default
to unlimited. (Default: None)
min_prefix_size (int): The minimum number of layers needed
to prefix the circuit.
instantiate_options (dict[str: Any]): Options passed directly
to circuit.instantiate when instantiating circuit
templates. (Default: {})
kwargs (dict[str, Any]): Keyword arguments that are passed
directly to SynthesisPass's constructor. See SynthesisPass
for more info.
Raises:
ValueError: If `max_depth` or `min_prefix_size` is nonpositive.
"""
if not isinstance(heuristic_function, HeuristicFunction):
raise TypeError(
'Expected HeursiticFunction, got %s.' %
type(heuristic_function), )
if not isinstance(layer_generator, LayerGenerator):
raise TypeError(
'Expected LayerGenerator, got %s.' % type(layer_generator), )
if not is_real_number(success_threshold):
raise TypeError(
'Expected real number for success_threshold'
', got %s' % type(success_threshold), )
if not isinstance(cost, CostFunctionGenerator):
raise TypeError(
'Expected cost to be a CostFunctionGenerator, got %s' %
type(cost), )
if max_layer is not None and not is_integer(max_layer):
raise TypeError(
'Expected max_layer to be an integer, got %s' %
type(max_layer), )
if max_layer is not None and max_layer <= 0:
raise ValueError(
'Expected max_layer to be positive, got %d.' %
int(max_layer), )
if min_prefix_size is not None and not is_integer(min_prefix_size):
raise TypeError(
'Expected min_prefix_size to be an integer, got %s' %
type(min_prefix_size), )
if min_prefix_size is not None and min_prefix_size <= 0:
raise ValueError(
'Expected min_prefix_size to be positive, got %d.' %
int(min_prefix_size), )
if not isinstance(instantiate_options, dict):
raise TypeError(
'Expected dictionary for instantiate_options, got %s.' %
type(instantiate_options), )
self.heuristic_function = heuristic_function
self.layer_gen = layer_generator
self.success_threshold = success_threshold
self.cost = cost
self.max_layer = max_layer
self.min_prefix_size = min_prefix_size
self.instantiate_options: dict[str, Any] = {'cost_fn_gen': self.cost}
self.instantiate_options.update(instantiate_options)
super().__init__(**kwargs)
def __init__(
self,
block_size_start: int = 2,
block_size_limit: int | None = None,
fail_limit: int = 3,
success_threshold: float = 1e-6,
progress_threshold_r: float = 5e-2,
progress_threshold_a: float = 1e-4,
cost: CostFunctionGenerator = HilbertSchmidtResidualsGenerator(),
max_depth: int | None = None,
instantiate_options: dict[str, Any] = {},
**kwargs: dict[str, Any],
) -> None:
"""
QPredictDecompositionPass Constructor.
Args:
block_size_start (int): The smallest block size to append
each step. (Default: 2)
block_size_limit (int | None): The largest block size to append
each step. If left as None, the unitary being synthesized
provides the limit. (Default: None)
fail_limit (int): The amount of tries to make progress before
increasing block size. (Default: 2)
success_threshold (float): The distance threshold that
determines successful termintation. Measured in cost
described by the cost function. (Default: 1e-6)
progress_threshold (float): The distance necessary to improve
for the synthesis algorithm to complete a layer and move
on. Lowering this will led to synthesis going deeper quicker,
and raising it will force to algorithm to spend more time
on each layer. Caution, changing this too much might break
the synthesis algorithm. (Default: 5e-3)
cost (CostFunction | None): The cost function that determines
distance during synthesis. The goal of this synthesis pass
is to implement circuits for the given unitaries that have
a cost less than the `success_threshold`.
(Default: HSDistance())
max_depth (int): The maximum number of gates to append without
success before termination. If left as None it will default
to unlimited. (Default: None)
instantiate_options (dict[str: Any]): Options passed directly
to circuit.instantiate when instantiating circuit
templates. (Default: {})
kwargs (dict[str, Any]): Keyword arguments that are passed
directly to SynthesisPass's constructor. See SynthesisPass
for more info.
Raises:
ValueError: If `block_size_start` is nonpositive.
ValueError: If `block_size_limit` is less than `block_size_start`.
ValueError: If `fail_limit` is nonpositive.
ValueError: If `max_depth` is nonpositive.
"""
if not is_integer(block_size_start):
raise TypeError(
'Expected block_size_start to be an integer, got %s' %
type(block_size_start), )
if block_size_start <= 0:
raise ValueError(
'Expected block_size_start to be positive, got %d.' %
block_size_start, )
if block_size_limit is not None and not is_integer(block_size_limit):
raise TypeError(
'Expected block_size_limit to be an integer, got %s' %
type(block_size_limit), )
if block_size_limit is not None and block_size_limit < block_size_start:
raise ValueError(
'Expected block_size_limit to be larger than block_size_start,'
'got %d.' % block_size_limit, )
if not is_integer(fail_limit):
raise TypeError(
'Expected fail_limit to be an integer, got %s' %
type(fail_limit), )
if fail_limit <= 0:
raise ValueError(
'Expected fail_limit to be positive, got %d.' % fail_limit, )
if not is_real_number(success_threshold):
raise TypeError(
'Expected real number for success_threshold'
', got %s' % type(success_threshold), )
if not is_real_number(progress_threshold_r):
raise TypeError(
'Expected real number for progress_threshold_r'
', got %s' % type(progress_threshold_r), )
if not is_real_number(progress_threshold_a):
raise TypeError(
'Expected real number for progress_threshold_a'
', got %s' % type(progress_threshold_a), )
if not isinstance(cost, CostFunctionGenerator):
raise TypeError(
'Expected cost to be a CostFunctionGenerator, got %s' %
type(cost), )
if max_depth is not None and not is_integer(max_depth):
raise TypeError(
'Expected max_depth to be an integer, got %s' %
type(max_depth), )
if max_depth is not None and max_depth <= 0:
raise ValueError(
'Expected max_depth to be positive, got %d.' %
int(max_depth), )
if not isinstance(instantiate_options, dict):
raise TypeError(
'Expected dictionary for instantiate_options, got %s.' %
type(instantiate_options), )
self.block_size_start = block_size_start
self.block_size_limit = block_size_limit
self.fail_limit = fail_limit
self.success_threshold = success_threshold
self.progress_threshold_r = progress_threshold_r
self.progress_threshold_a = progress_threshold_a
self.cost = cost
self.max_depth = max_depth
self.instantiate_options = {
'min_iters': 25,
'diff_tol_r': 1e-4,
}
self.instantiate_options.update(instantiate_options)
super().__init__(**kwargs) # type: ignore
def __init__(
self,
start_from_left: bool = True,
success_threshold: float = 1e-10,
cost: CostFunctionGenerator = HilbertSchmidtResidualsGenerator(),
instantiate_options: dict[str, Any] = {},
collection_filter: Callable[[Operation], bool] | None = None,
) -> None:
"""
Construct a ScanningGateRemovalPass.
Args:
start_from_left (bool): Determines where the scan starts
attempting to remove gates from. If True, scan goes left
to right, otherwise right to left. (Default: True)
success_threshold (float): The distance threshold that
determines successful termintation. Measured in cost
described by the hilbert schmidt cost function.
(Default: 1e-10)
cost (CostFunction | None): The cost function that determines
successful removal of a gate.
(Default: HilbertSchmidtResidualsGenerator())
instantiate_options (dict[str: Any]): Options passed directly
to circuit.instantiate when instantiating circuit
templates. (Default: {})
collection_filter (Callable[[Operation], bool] | None):
A predicate that determines which operations should be
attempted to be removed. Called with each operation
in the circuit. If this returns true, this pass will
attempt to remove that operation. Defaults to all
operations.
"""
if not is_real_number(success_threshold):
raise TypeError(
'Expected real number for success_threshold'
', got %s' % type(success_threshold), )
if not isinstance(cost, CostFunctionGenerator):
raise TypeError(
'Expected cost to be a CostFunctionGenerator, got %s' %
type(cost), )
if not isinstance(instantiate_options, dict):
raise TypeError(
'Expected dictionary for instantiate_options, got %s.' %
type(instantiate_options), )
self.collection_filter = collection_filter or default_collection_filter
if not callable(self.collection_filter):
raise TypeError(
'Expected callable method that maps Operations to booleans for'
' collection_filter, got %s.' % type(self.collection_filter), )
self.start_from_left = start_from_left
self.success_threshold = success_threshold
self.cost = cost
self.instantiate_options: dict[str, Any] = {
'dist_tol': self.success_threshold,
'min_iters': 100,
}
self.instantiate_options.update(instantiate_options)