modules.solvers.random_classical_sat.RandomSAT

class RandomSAT

Bases: Solver

Classic Random Solver for the SAT problem.

__init__()

Constructor method.

Methods

__init__()

Constructor method.

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)

Given an option string by the user, this returns a submodule.

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 solver 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.

postprocess(input_data, config, **kwargs)

The actual solving process is done here, using the device which is provided by the device submodule and the problem data provided by the parent module.

preprocess(input_data, config, **kwargs)

Essential method for the benchmarking process.

run(mapped_problem, device_wrapper, config, ...)

The given application is a problem instance from the pysat library.
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
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

Given an option string by the user, this returns a submodule.

Parameters:

option -- String with the chosen submodule

Returns:

Module of type Core

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 solver has no configurable settings.

Returns:

Empty dict

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

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

The actual solving process is done here, using the device which is provided by the device submodule and the problem data provided by the parent module.

Parameters:

  • input_data -- Data passed to the run function of the solver

  • config -- Solver config

  • kwargs -- Optional keyword arguments

Returns:

Output and time needed

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

Essential method for the benchmarking process. This is always executed before traversing down to the next module, passing the data returned by this function.

Parameters:

  • input_data -- Data for the module, comes from the parent module if that exists

  • config -- Config for the module

  • kwargs -- Optional keyword arguments

Returns:

The output of the preprocessing and the time it took to preprocess

run(mapped_problem: WCNF, device_wrapper: any, config: Config, **kwargs: dict) → tuple[list, float, dict]

The given application is a problem instance from the pysat library. This generates a random solution to the problem.

Parameters:

  • mapped_problem -- The WCNF representation of the SAT problem

  • device_wrapper -- Local device

  • config -- Empty dict

  • kwargs -- No additionally settings needed

Returns:

Solution, the time it took to compute it and optional additional information