object

simulated_annealing(Problem,RandomAlgorithm)

  • Problem - Problem object implementing simulated_annealing_protocol.

  • RandomAlgorithm - Random number generator algorithm for the fast_random library (e.g. xoshiro128pp, xoshiro256ss, well512a, …).

Simulated annealing optimization algorithm. Parameterized by a problem object implementing the simulated_annealing_protocol protocol and by a random number generator algorithm for the fast_random library. The algorithm minimizes the energy (cost) function defined by the problem. Custom cooling schedules, stop conditions, delta-energy neighbor generation, progress reporting, and reheating restarts can be defined by the problem object or configured via options; suitable defaults are used otherwise.

Availability:
logtalk_load(simulated_annealing(loader))
Author: Paulo Moura
Version: 1:0:0
Date: 2026-02-23
Compilation flags:
static, context_switching_calls
Imports:
public options
Uses:
fast_random(Algorithm)
type
Remarks:

  • Algorithm: Simulated annealing is a probabilistic metaheuristic for global optimization. It explores the solution space by iteratively generating neighbor states and accepting them based on an energy-dependent probability that decreases over time as the temperature cools.

  • Acceptance criterion: Uses the standard Boltzmann acceptance criterion: a worse neighbor is accepted with probability exp(-DeltaE / Temperature).

  • Default cooling schedule: Geometric cooling: NewTemp is Temp * 0.995. Override by defining cooling_schedule/3 in the problem object.

  • Default stop condition: The search stops when the maximum number of steps is reached or the temperature drops below the minimum temperature. Override by defining stop_condition/3 in the problem object.

  • Delta-energy optimization: If the problem object defines neighbor_state/3, the algorithm uses the returned delta energy directly instead of calling state_energy/2 on the neighbor. This is useful when computing the energy change is cheaper than recomputing the full energy.

  • Progress reporting: If the problem object defines progress/5, it is called periodically with the current step, temperature, best energy, acceptance rate, and improvement rate. The reporting interval is controlled by the updates(N) option. A final report is always produced when the loop terminates.

  • Best state tracking: The algorithm tracks the best state found across all iterations and across all restart cycles, not just the final state.

  • Seed control: The seed(S) option initializes the random number generator for reproducible runs.

  • Reheating restart: The restarts(N) option runs N additional SA cycles after the first. Each restart reheats the temperature to the initial value and begins from the best state found so far, allowing the search to escape local minima. Statistics accumulate across all cycles.

  • Auto-temperature estimation: The estimate_temperature/1-2 predicates sample random neighbor transitions and compute an initial temperature that would produce a target acceptance rate. This avoids manual tuning of the initial temperature.

Inherited public predicates:
 check_option/1  check_options/1  default_option/1  default_options/1  option/2  option/3  valid_option/1  valid_options/1

Public predicates

estimate_temperature/1

Estimates an initial temperature for the problem using default options (200 samples, 80% target acceptance rate).

Compilation flags:
static
Template:
estimate_temperature(Temperature)
Mode and number of proofs:
estimate_temperature(-float) - one

estimate_temperature/2

Estimates an initial temperature by sampling random neighbor transitions. The temperature is computed so that the Boltzmann acceptance probability for the average uphill move equals the target acceptance rate. Sampling starts from the problem initial state and follows a random walk.

Compilation flags:
static
Template:
estimate_temperature(Temperature,Options)
Mode and number of proofs:
estimate_temperature(-float,+list(compound)) - one
Remarks:

  • samples(N) option: Number of random neighbor transitions to sample (default: 200).

  • acceptance_rate(P) option: Target initial acceptance rate as an integer percentage between 1 and 99 (default: 80).

run/2

Runs the simulated annealing algorithm using default options and returns the best state found and its energy.

Compilation flags:
static
Template:
run(BestState,BestEnergy)
Mode and number of proofs:
run(-term,-number) - one

run/3

Runs the simulated annealing algorithm using the given options and returns the best state found and its energy.

Compilation flags:
static
Template:
run(BestState,BestEnergy,Options)
Mode and number of proofs:
run(-term,-number,+list(compound)) - one
Remarks:

  • max_steps(N) option: Maximum number of iterations per cycle (default: 10000).

  • min_temperature(T) option: Minimum temperature floor; search stops when temperature drops below this value (default: 0.001).

  • updates(N) option: Number of progress reports during the run. Set to 0 to disable. Progress is reported by calling progress/5 on the problem object (default: 0).

  • seed(S) option: Positive integer seed for the random number generator, enabling reproducible runs (default: none).

  • restarts(N) option: Number of additional SA cycles after the first. Each restart reheats the temperature and begins from the best state found so far (default: 0).

run/4

Runs the simulated annealing algorithm using the given options, returns the best state found and its energy, and returns run statistics.

Compilation flags:
static
Template:
run(BestState,BestEnergy,Statistics,Options)
Mode and number of proofs:
run(-term,-number,-list(compound),+list(compound)) - one
Remarks:

  • Statistics list: A list of Key(Value) pairs: steps(N) is the number of steps executed, acceptances(A) is the number of accepted moves, improvements(I) is the number of moves that improved the best energy, and final_temperature(T) is the temperature at termination.

Protected predicates

(no local declarations; see entity ancestors if any)

Private predicates

(no local declarations; see entity ancestors if any)

Operators

(none)

See also

simulated_annealing(Problem), simulated_annealing_protocol