modules.applications.optimization.acl.mappings.qubo.Qubo

class Qubo

Bases: Mapping

QUBO formulation for the ACL.

__init__()

Constructor method.

Methods

__init__()	Constructor method.
construct_qubo(penalty, variables)	Creates QUBO matrix Q to solve linear problem of the form x^T * Q + x.
convert_string_to_arguments(input_string)	Converts QUBO in string format to a list of separated arguments, used to construct the QUBO matrix.
get_available_submodule_options()	Gets the list of available options.
get_available_submodules(option)	If the module has submodules depending on certain options, this method should adjust the submodule_options accordingly.
get_default_submodule(option)	Returns the default submodule based on the provided option.
get_depending_parameters(option, config)	If the module has parameters depending on certain options, this method should return the parameters for the given option.
get_parameter_options()	Returns empty dict as this mapping has no configurable settings.
get_requirements()	Return requirements of this module.
get_submodule(option)	Submodule is instantiated according to the information given in self.sub_options.
map(problem, config)	Converts linear program created with pulp to quadratic program to Ising with qiskit to QUBO matrix.
map_pulp_to_qiskit(problem)	Maps the problem dict to a quadratic program.
postprocess(input_data, config, **kwargs)	Reverse transformation/mapping from the submodule's format to the mathematical formulation suitable for the parent module.
preprocess(input_data, config, **kwargs)	Maps the data to the correct target format.
reverse_map(solution)	Maps the solution back to the representation needed by the ACL class for validation/evaluation.

class Config

Bases: TypedDict

Empty config as this solver has no configurable settings.

clear() → None.  Remove all items from D.

copy() → a shallow copy of D

fromkeys(value=None, /)

Create a new dictionary with keys from iterable and values set to value.

get(key, default=None, /)

Return the value for key if key is in the dictionary, else default.

items() → a set-like object providing a view on D's items

keys() → a set-like object providing a view on D's keys

pop(k[, d]) → v, remove specified key and return the corresponding value.

If the key is not found, return the default if given; otherwise, raise a KeyError.

popitem()

Remove and return a (key, value) pair as a 2-tuple.

Pairs are returned in LIFO (last-in, first-out) order. Raises KeyError if the dict is empty.

setdefault(key, default=None, /)

Insert key with a value of default if key is not in the dictionary.

Return the value for key if key is in the dictionary, else default.

update([E, ]**F) → None.  Update D from mapping/iterable E and F.

If E is present and has a .keys() method, then does: for k in E.keys(): D[k] = E[k] If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v In either case, this is followed by: for k in F: D[k] = F[k]

values() → an object providing a view on D's values

construct_qubo(penalty: list[list], variables: list[str]) → ndarray

Creates QUBO matrix Q to solve linear problem of the form x^T * Q + x.

Parameters:

• penalty -- List of lists containing all non-zero elements of the QUBO matrix as strings

• variables -- Listing of all variables used in the problem

Returns:

QUBO in numpy array format

convert_string_to_arguments(input_string: str) → list[any]

Converts QUBO in string format to a list of separated arguments, used to construct the QUBO matrix.

Parameters:

input_string -- QUBO in raw string format

Returns:

List of arguments

get_available_submodule_options() → list

Gets the list of available options.

Returns:

List of module options

get_available_submodules(option: list) → list

If the module has submodules depending on certain options, this method should adjust the submodule_options accordingly.

Parameters:

option -- List of chosen options

Returns:

List of available submodules

get_default_submodule(option: str) → Core

Returns the default submodule based on the provided option.

Parameters:

option -- Option specifying the submodule

Returns:

Instance of the corresponding submodule

Raises:

NotImplementedError -- If the option is not recognized

get_depending_parameters(option: str, config: dict) → dict

If the module has parameters depending on certain options, this method should return the parameters for the given option.

Parameters:

• option -- The chosen option

• config -- Current config dictionary

Returns:

The parameters for the given option

get_parameter_options() → dict

Returns empty dict as this mapping has no configurable settings.

Returns:

Empty dictionary

static get_requirements() → list[dict]

Return requirements of this module.

Returns:

list of dict with requirements of this module

get_submodule(option: str) → Core

Submodule is instantiated according to the information given in self.sub_options. If self.sub_options is None, get_default_submodule is called as a fallback.

Parameters:

option -- String with the options

Returns:

Instance of a module

map(problem: dict, config: Config) → tuple[dict, float]

Converts linear program created with pulp to quadratic program to Ising with qiskit to QUBO matrix.

Parameters:

• problem -- Dict containing the problem parameters

• config -- Config with the parameters specified in Config class

Returns:

Dict with the QUBO, time it took to map it

map_pulp_to_qiskit(problem: dict) → QuadraticProgram

Maps the problem dict to a quadratic program.

Parameters:

problem -- Problem formulation in dict form

Returns:

Quadratic program in qiskit-optimization format

postprocess(input_data: any, config: dict, **kwargs) → tuple[any, float]

Reverse transformation/mapping from the submodule's format to the mathematical formulation suitable for the parent module.

Parameters:

• input_data -- Data which should be reverse-mapped

• config -- Config of the reverse mapping

• kwargs -- Optional keyword arguments

Returns:

Tuple with reverse-mapped problem and the time it took to map it

preprocess(input_data: any, config: dict, **kwargs) → tuple[any, float]

Maps the data to the correct target format.

Parameters:

• input_data -- Data which should be mapped

• config -- Config of the mapping

• kwargs -- Optional keyword arguments

Returns:

Tuple with mapped problem and the time it took to map it

reverse_map(solution: dict) → tuple[dict, float]

Maps the solution back to the representation needed by the ACL class for validation/evaluation.

Parameters:

solution -- bit_string containing the solution

Returns:

Solution mapped accordingly, time it took to map it